github.com/djenriquez/nomad-1@v0.8.1/nomad/structs/structs.generated.go (about)

     1  // ************************************************************
     2  // DO NOT EDIT.
     3  // THIS FILE IS AUTO-GENERATED BY codecgen.
     4  // ************************************************************
     5  
     6  package structs
     7  
     8  import (
     9  	"errors"
    10  	"fmt"
    11  	codec1978 "github.com/ugorji/go/codec"
    12  	net "net"
    13  	"reflect"
    14  	"runtime"
    15  	time "time"
    16  )
    17  
    18  const (
    19  	// ----- content types ----
    20  	codecSelferC_UTF8100 = 1
    21  	codecSelferC_RAW100  = 0
    22  	// ----- value types used ----
    23  	codecSelferValueTypeArray100 = 10
    24  	codecSelferValueTypeMap100   = 9
    25  	// ----- containerStateValues ----
    26  	codecSelfer_containerMapKey100    = 2
    27  	codecSelfer_containerMapValue100  = 3
    28  	codecSelfer_containerMapEnd100    = 4
    29  	codecSelfer_containerArrayElem100 = 6
    30  	codecSelfer_containerArrayEnd100  = 7
    31  )
    32  
    33  var (
    34  	codecSelferBitsize100                         = uint8(reflect.TypeOf(uint(0)).Bits())
    35  	codecSelferOnlyMapOrArrayEncodeToStructErr100 = errors.New(`only encoded map or array can be decoded into a struct`)
    36  )
    37  
    38  type codecSelfer100 struct{}
    39  
    40  func init() {
    41  	if codec1978.GenVersion != 5 {
    42  		_, file, _, _ := runtime.Caller(0)
    43  		err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
    44  			5, codec1978.GenVersion, file)
    45  		panic(err)
    46  	}
    47  	if false { // reference the types, but skip this branch at build/run time
    48  		var v0 net.IP
    49  		var v1 time.Duration
    50  		_, _ = v0, v1
    51  	}
    52  }
    53  
    54  func (x MessageType) CodecEncodeSelf(e *codec1978.Encoder) {
    55  	var h codecSelfer100
    56  	z, r := codec1978.GenHelperEncoder(e)
    57  	_, _, _ = h, z, r
    58  	yym1 := z.EncBinary()
    59  	_ = yym1
    60  	if false {
    61  	} else if z.HasExtensions() && z.EncExt(x) {
    62  	} else {
    63  		r.EncodeUint(uint64(x))
    64  	}
    65  }
    66  
    67  func (x *MessageType) CodecDecodeSelf(d *codec1978.Decoder) {
    68  	var h codecSelfer100
    69  	z, r := codec1978.GenHelperDecoder(d)
    70  	_, _, _ = h, z, r
    71  	yym1 := z.DecBinary()
    72  	_ = yym1
    73  	if false {
    74  	} else if z.HasExtensions() && z.DecExt(x) {
    75  	} else {
    76  		*((*uint8)(x)) = uint8(r.DecodeUint(8))
    77  	}
    78  }
    79  
    80  func (x Context) CodecEncodeSelf(e *codec1978.Encoder) {
    81  	var h codecSelfer100
    82  	z, r := codec1978.GenHelperEncoder(e)
    83  	_, _, _ = h, z, r
    84  	yym1 := z.EncBinary()
    85  	_ = yym1
    86  	if false {
    87  	} else if z.HasExtensions() && z.EncExt(x) {
    88  	} else {
    89  		r.EncodeString(codecSelferC_UTF8100, string(x))
    90  	}
    91  }
    92  
    93  func (x *Context) CodecDecodeSelf(d *codec1978.Decoder) {
    94  	var h codecSelfer100
    95  	z, r := codec1978.GenHelperDecoder(d)
    96  	_, _, _ = h, z, r
    97  	yym1 := z.DecBinary()
    98  	_ = yym1
    99  	if false {
   100  	} else if z.HasExtensions() && z.DecExt(x) {
   101  	} else {
   102  		*((*string)(x)) = r.DecodeString()
   103  	}
   104  }
   105  
   106  func (x *NamespacedID) CodecEncodeSelf(e *codec1978.Encoder) {
   107  	var h codecSelfer100
   108  	z, r := codec1978.GenHelperEncoder(e)
   109  	_, _, _ = h, z, r
   110  	if x == nil {
   111  		r.EncodeNil()
   112  	} else {
   113  		yym1 := z.EncBinary()
   114  		_ = yym1
   115  		if false {
   116  		} else if z.HasExtensions() && z.EncExt(x) {
   117  		} else {
   118  			yysep2 := !z.EncBinary()
   119  			yy2arr2 := z.EncBasicHandle().StructToArray
   120  			var yyq2 [2]bool
   121  			_, _, _ = yysep2, yyq2, yy2arr2
   122  			const yyr2 bool = false
   123  			var yynn2 int
   124  			if yyr2 || yy2arr2 {
   125  				r.EncodeArrayStart(2)
   126  			} else {
   127  				yynn2 = 2
   128  				for _, b := range yyq2 {
   129  					if b {
   130  						yynn2++
   131  					}
   132  				}
   133  				r.EncodeMapStart(yynn2)
   134  				yynn2 = 0
   135  			}
   136  			if yyr2 || yy2arr2 {
   137  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
   138  				yym4 := z.EncBinary()
   139  				_ = yym4
   140  				if false {
   141  				} else {
   142  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
   143  				}
   144  			} else {
   145  				z.EncSendContainerState(codecSelfer_containerMapKey100)
   146  				r.EncodeString(codecSelferC_UTF8100, string("ID"))
   147  				z.EncSendContainerState(codecSelfer_containerMapValue100)
   148  				yym5 := z.EncBinary()
   149  				_ = yym5
   150  				if false {
   151  				} else {
   152  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
   153  				}
   154  			}
   155  			if yyr2 || yy2arr2 {
   156  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
   157  				yym7 := z.EncBinary()
   158  				_ = yym7
   159  				if false {
   160  				} else {
   161  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
   162  				}
   163  			} else {
   164  				z.EncSendContainerState(codecSelfer_containerMapKey100)
   165  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
   166  				z.EncSendContainerState(codecSelfer_containerMapValue100)
   167  				yym8 := z.EncBinary()
   168  				_ = yym8
   169  				if false {
   170  				} else {
   171  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
   172  				}
   173  			}
   174  			if yyr2 || yy2arr2 {
   175  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
   176  			} else {
   177  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
   178  			}
   179  		}
   180  	}
   181  }
   182  
   183  func (x *NamespacedID) CodecDecodeSelf(d *codec1978.Decoder) {
   184  	var h codecSelfer100
   185  	z, r := codec1978.GenHelperDecoder(d)
   186  	_, _, _ = h, z, r
   187  	yym1 := z.DecBinary()
   188  	_ = yym1
   189  	if false {
   190  	} else if z.HasExtensions() && z.DecExt(x) {
   191  	} else {
   192  		yyct2 := r.ContainerType()
   193  		if yyct2 == codecSelferValueTypeMap100 {
   194  			yyl2 := r.ReadMapStart()
   195  			if yyl2 == 0 {
   196  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
   197  			} else {
   198  				x.codecDecodeSelfFromMap(yyl2, d)
   199  			}
   200  		} else if yyct2 == codecSelferValueTypeArray100 {
   201  			yyl2 := r.ReadArrayStart()
   202  			if yyl2 == 0 {
   203  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
   204  			} else {
   205  				x.codecDecodeSelfFromArray(yyl2, d)
   206  			}
   207  		} else {
   208  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
   209  		}
   210  	}
   211  }
   212  
   213  func (x *NamespacedID) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
   214  	var h codecSelfer100
   215  	z, r := codec1978.GenHelperDecoder(d)
   216  	_, _, _ = h, z, r
   217  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
   218  	_ = yys3Slc
   219  	var yyhl3 bool = l >= 0
   220  	for yyj3 := 0; ; yyj3++ {
   221  		if yyhl3 {
   222  			if yyj3 >= l {
   223  				break
   224  			}
   225  		} else {
   226  			if r.CheckBreak() {
   227  				break
   228  			}
   229  		}
   230  		z.DecSendContainerState(codecSelfer_containerMapKey100)
   231  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
   232  		yys3 := string(yys3Slc)
   233  		z.DecSendContainerState(codecSelfer_containerMapValue100)
   234  		switch yys3 {
   235  		case "ID":
   236  			if r.TryDecodeAsNil() {
   237  				x.ID = ""
   238  			} else {
   239  				yyv4 := &x.ID
   240  				yym5 := z.DecBinary()
   241  				_ = yym5
   242  				if false {
   243  				} else {
   244  					*((*string)(yyv4)) = r.DecodeString()
   245  				}
   246  			}
   247  		case "Namespace":
   248  			if r.TryDecodeAsNil() {
   249  				x.Namespace = ""
   250  			} else {
   251  				yyv6 := &x.Namespace
   252  				yym7 := z.DecBinary()
   253  				_ = yym7
   254  				if false {
   255  				} else {
   256  					*((*string)(yyv6)) = r.DecodeString()
   257  				}
   258  			}
   259  		default:
   260  			z.DecStructFieldNotFound(-1, yys3)
   261  		} // end switch yys3
   262  	} // end for yyj3
   263  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
   264  }
   265  
   266  func (x *NamespacedID) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
   267  	var h codecSelfer100
   268  	z, r := codec1978.GenHelperDecoder(d)
   269  	_, _, _ = h, z, r
   270  	var yyj8 int
   271  	var yyb8 bool
   272  	var yyhl8 bool = l >= 0
   273  	yyj8++
   274  	if yyhl8 {
   275  		yyb8 = yyj8 > l
   276  	} else {
   277  		yyb8 = r.CheckBreak()
   278  	}
   279  	if yyb8 {
   280  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
   281  		return
   282  	}
   283  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
   284  	if r.TryDecodeAsNil() {
   285  		x.ID = ""
   286  	} else {
   287  		yyv9 := &x.ID
   288  		yym10 := z.DecBinary()
   289  		_ = yym10
   290  		if false {
   291  		} else {
   292  			*((*string)(yyv9)) = r.DecodeString()
   293  		}
   294  	}
   295  	yyj8++
   296  	if yyhl8 {
   297  		yyb8 = yyj8 > l
   298  	} else {
   299  		yyb8 = r.CheckBreak()
   300  	}
   301  	if yyb8 {
   302  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
   303  		return
   304  	}
   305  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
   306  	if r.TryDecodeAsNil() {
   307  		x.Namespace = ""
   308  	} else {
   309  		yyv11 := &x.Namespace
   310  		yym12 := z.DecBinary()
   311  		_ = yym12
   312  		if false {
   313  		} else {
   314  			*((*string)(yyv11)) = r.DecodeString()
   315  		}
   316  	}
   317  	for {
   318  		yyj8++
   319  		if yyhl8 {
   320  			yyb8 = yyj8 > l
   321  		} else {
   322  			yyb8 = r.CheckBreak()
   323  		}
   324  		if yyb8 {
   325  			break
   326  		}
   327  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
   328  		z.DecStructFieldNotFound(yyj8-1, "")
   329  	}
   330  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
   331  }
   332  
   333  func (x *InternalRpcInfo) CodecEncodeSelf(e *codec1978.Encoder) {
   334  	var h codecSelfer100
   335  	z, r := codec1978.GenHelperEncoder(e)
   336  	_, _, _ = h, z, r
   337  	if x == nil {
   338  		r.EncodeNil()
   339  	} else {
   340  		yym1 := z.EncBinary()
   341  		_ = yym1
   342  		if false {
   343  		} else if z.HasExtensions() && z.EncExt(x) {
   344  		} else {
   345  			yysep2 := !z.EncBinary()
   346  			yy2arr2 := z.EncBasicHandle().StructToArray
   347  			var yyq2 [1]bool
   348  			_, _, _ = yysep2, yyq2, yy2arr2
   349  			const yyr2 bool = false
   350  			var yynn2 int
   351  			if yyr2 || yy2arr2 {
   352  				r.EncodeArrayStart(1)
   353  			} else {
   354  				yynn2 = 1
   355  				for _, b := range yyq2 {
   356  					if b {
   357  						yynn2++
   358  					}
   359  				}
   360  				r.EncodeMapStart(yynn2)
   361  				yynn2 = 0
   362  			}
   363  			if yyr2 || yy2arr2 {
   364  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
   365  				yym4 := z.EncBinary()
   366  				_ = yym4
   367  				if false {
   368  				} else {
   369  					r.EncodeBool(bool(x.Forwarded))
   370  				}
   371  			} else {
   372  				z.EncSendContainerState(codecSelfer_containerMapKey100)
   373  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
   374  				z.EncSendContainerState(codecSelfer_containerMapValue100)
   375  				yym5 := z.EncBinary()
   376  				_ = yym5
   377  				if false {
   378  				} else {
   379  					r.EncodeBool(bool(x.Forwarded))
   380  				}
   381  			}
   382  			if yyr2 || yy2arr2 {
   383  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
   384  			} else {
   385  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
   386  			}
   387  		}
   388  	}
   389  }
   390  
   391  func (x *InternalRpcInfo) CodecDecodeSelf(d *codec1978.Decoder) {
   392  	var h codecSelfer100
   393  	z, r := codec1978.GenHelperDecoder(d)
   394  	_, _, _ = h, z, r
   395  	yym1 := z.DecBinary()
   396  	_ = yym1
   397  	if false {
   398  	} else if z.HasExtensions() && z.DecExt(x) {
   399  	} else {
   400  		yyct2 := r.ContainerType()
   401  		if yyct2 == codecSelferValueTypeMap100 {
   402  			yyl2 := r.ReadMapStart()
   403  			if yyl2 == 0 {
   404  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
   405  			} else {
   406  				x.codecDecodeSelfFromMap(yyl2, d)
   407  			}
   408  		} else if yyct2 == codecSelferValueTypeArray100 {
   409  			yyl2 := r.ReadArrayStart()
   410  			if yyl2 == 0 {
   411  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
   412  			} else {
   413  				x.codecDecodeSelfFromArray(yyl2, d)
   414  			}
   415  		} else {
   416  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
   417  		}
   418  	}
   419  }
   420  
   421  func (x *InternalRpcInfo) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
   422  	var h codecSelfer100
   423  	z, r := codec1978.GenHelperDecoder(d)
   424  	_, _, _ = h, z, r
   425  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
   426  	_ = yys3Slc
   427  	var yyhl3 bool = l >= 0
   428  	for yyj3 := 0; ; yyj3++ {
   429  		if yyhl3 {
   430  			if yyj3 >= l {
   431  				break
   432  			}
   433  		} else {
   434  			if r.CheckBreak() {
   435  				break
   436  			}
   437  		}
   438  		z.DecSendContainerState(codecSelfer_containerMapKey100)
   439  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
   440  		yys3 := string(yys3Slc)
   441  		z.DecSendContainerState(codecSelfer_containerMapValue100)
   442  		switch yys3 {
   443  		case "Forwarded":
   444  			if r.TryDecodeAsNil() {
   445  				x.Forwarded = false
   446  			} else {
   447  				yyv4 := &x.Forwarded
   448  				yym5 := z.DecBinary()
   449  				_ = yym5
   450  				if false {
   451  				} else {
   452  					*((*bool)(yyv4)) = r.DecodeBool()
   453  				}
   454  			}
   455  		default:
   456  			z.DecStructFieldNotFound(-1, yys3)
   457  		} // end switch yys3
   458  	} // end for yyj3
   459  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
   460  }
   461  
   462  func (x *InternalRpcInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
   463  	var h codecSelfer100
   464  	z, r := codec1978.GenHelperDecoder(d)
   465  	_, _, _ = h, z, r
   466  	var yyj6 int
   467  	var yyb6 bool
   468  	var yyhl6 bool = l >= 0
   469  	yyj6++
   470  	if yyhl6 {
   471  		yyb6 = yyj6 > l
   472  	} else {
   473  		yyb6 = r.CheckBreak()
   474  	}
   475  	if yyb6 {
   476  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
   477  		return
   478  	}
   479  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
   480  	if r.TryDecodeAsNil() {
   481  		x.Forwarded = false
   482  	} else {
   483  		yyv7 := &x.Forwarded
   484  		yym8 := z.DecBinary()
   485  		_ = yym8
   486  		if false {
   487  		} else {
   488  			*((*bool)(yyv7)) = r.DecodeBool()
   489  		}
   490  	}
   491  	for {
   492  		yyj6++
   493  		if yyhl6 {
   494  			yyb6 = yyj6 > l
   495  		} else {
   496  			yyb6 = r.CheckBreak()
   497  		}
   498  		if yyb6 {
   499  			break
   500  		}
   501  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
   502  		z.DecStructFieldNotFound(yyj6-1, "")
   503  	}
   504  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
   505  }
   506  
   507  func (x *QueryOptions) CodecEncodeSelf(e *codec1978.Encoder) {
   508  	var h codecSelfer100
   509  	z, r := codec1978.GenHelperEncoder(e)
   510  	_, _, _ = h, z, r
   511  	if x == nil {
   512  		r.EncodeNil()
   513  	} else {
   514  		yym1 := z.EncBinary()
   515  		_ = yym1
   516  		if false {
   517  		} else if z.HasExtensions() && z.EncExt(x) {
   518  		} else {
   519  			yysep2 := !z.EncBinary()
   520  			yy2arr2 := z.EncBasicHandle().StructToArray
   521  			var yyq2 [8]bool
   522  			_, _, _ = yysep2, yyq2, yy2arr2
   523  			const yyr2 bool = false
   524  			var yynn2 int
   525  			if yyr2 || yy2arr2 {
   526  				r.EncodeArrayStart(8)
   527  			} else {
   528  				yynn2 = 8
   529  				for _, b := range yyq2 {
   530  					if b {
   531  						yynn2++
   532  					}
   533  				}
   534  				r.EncodeMapStart(yynn2)
   535  				yynn2 = 0
   536  			}
   537  			if yyr2 || yy2arr2 {
   538  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
   539  				yym4 := z.EncBinary()
   540  				_ = yym4
   541  				if false {
   542  				} else {
   543  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
   544  				}
   545  			} else {
   546  				z.EncSendContainerState(codecSelfer_containerMapKey100)
   547  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
   548  				z.EncSendContainerState(codecSelfer_containerMapValue100)
   549  				yym5 := z.EncBinary()
   550  				_ = yym5
   551  				if false {
   552  				} else {
   553  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
   554  				}
   555  			}
   556  			if yyr2 || yy2arr2 {
   557  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
   558  				yym7 := z.EncBinary()
   559  				_ = yym7
   560  				if false {
   561  				} else {
   562  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
   563  				}
   564  			} else {
   565  				z.EncSendContainerState(codecSelfer_containerMapKey100)
   566  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
   567  				z.EncSendContainerState(codecSelfer_containerMapValue100)
   568  				yym8 := z.EncBinary()
   569  				_ = yym8
   570  				if false {
   571  				} else {
   572  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
   573  				}
   574  			}
   575  			if yyr2 || yy2arr2 {
   576  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
   577  				yym10 := z.EncBinary()
   578  				_ = yym10
   579  				if false {
   580  				} else {
   581  					r.EncodeUint(uint64(x.MinQueryIndex))
   582  				}
   583  			} else {
   584  				z.EncSendContainerState(codecSelfer_containerMapKey100)
   585  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
   586  				z.EncSendContainerState(codecSelfer_containerMapValue100)
   587  				yym11 := z.EncBinary()
   588  				_ = yym11
   589  				if false {
   590  				} else {
   591  					r.EncodeUint(uint64(x.MinQueryIndex))
   592  				}
   593  			}
   594  			if yyr2 || yy2arr2 {
   595  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
   596  				yym13 := z.EncBinary()
   597  				_ = yym13
   598  				if false {
   599  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
   600  				} else {
   601  					r.EncodeInt(int64(x.MaxQueryTime))
   602  				}
   603  			} else {
   604  				z.EncSendContainerState(codecSelfer_containerMapKey100)
   605  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
   606  				z.EncSendContainerState(codecSelfer_containerMapValue100)
   607  				yym14 := z.EncBinary()
   608  				_ = yym14
   609  				if false {
   610  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
   611  				} else {
   612  					r.EncodeInt(int64(x.MaxQueryTime))
   613  				}
   614  			}
   615  			if yyr2 || yy2arr2 {
   616  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
   617  				yym16 := z.EncBinary()
   618  				_ = yym16
   619  				if false {
   620  				} else {
   621  					r.EncodeBool(bool(x.AllowStale))
   622  				}
   623  			} else {
   624  				z.EncSendContainerState(codecSelfer_containerMapKey100)
   625  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
   626  				z.EncSendContainerState(codecSelfer_containerMapValue100)
   627  				yym17 := z.EncBinary()
   628  				_ = yym17
   629  				if false {
   630  				} else {
   631  					r.EncodeBool(bool(x.AllowStale))
   632  				}
   633  			}
   634  			if yyr2 || yy2arr2 {
   635  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
   636  				yym19 := z.EncBinary()
   637  				_ = yym19
   638  				if false {
   639  				} else {
   640  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
   641  				}
   642  			} else {
   643  				z.EncSendContainerState(codecSelfer_containerMapKey100)
   644  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
   645  				z.EncSendContainerState(codecSelfer_containerMapValue100)
   646  				yym20 := z.EncBinary()
   647  				_ = yym20
   648  				if false {
   649  				} else {
   650  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
   651  				}
   652  			}
   653  			if yyr2 || yy2arr2 {
   654  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
   655  				yym22 := z.EncBinary()
   656  				_ = yym22
   657  				if false {
   658  				} else {
   659  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
   660  				}
   661  			} else {
   662  				z.EncSendContainerState(codecSelfer_containerMapKey100)
   663  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
   664  				z.EncSendContainerState(codecSelfer_containerMapValue100)
   665  				yym23 := z.EncBinary()
   666  				_ = yym23
   667  				if false {
   668  				} else {
   669  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
   670  				}
   671  			}
   672  			if yyr2 || yy2arr2 {
   673  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
   674  				yym25 := z.EncBinary()
   675  				_ = yym25
   676  				if false {
   677  				} else {
   678  					r.EncodeBool(bool(x.Forwarded))
   679  				}
   680  			} else {
   681  				z.EncSendContainerState(codecSelfer_containerMapKey100)
   682  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
   683  				z.EncSendContainerState(codecSelfer_containerMapValue100)
   684  				yym26 := z.EncBinary()
   685  				_ = yym26
   686  				if false {
   687  				} else {
   688  					r.EncodeBool(bool(x.Forwarded))
   689  				}
   690  			}
   691  			if yyr2 || yy2arr2 {
   692  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
   693  			} else {
   694  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
   695  			}
   696  		}
   697  	}
   698  }
   699  
   700  func (x *QueryOptions) CodecDecodeSelf(d *codec1978.Decoder) {
   701  	var h codecSelfer100
   702  	z, r := codec1978.GenHelperDecoder(d)
   703  	_, _, _ = h, z, r
   704  	yym1 := z.DecBinary()
   705  	_ = yym1
   706  	if false {
   707  	} else if z.HasExtensions() && z.DecExt(x) {
   708  	} else {
   709  		yyct2 := r.ContainerType()
   710  		if yyct2 == codecSelferValueTypeMap100 {
   711  			yyl2 := r.ReadMapStart()
   712  			if yyl2 == 0 {
   713  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
   714  			} else {
   715  				x.codecDecodeSelfFromMap(yyl2, d)
   716  			}
   717  		} else if yyct2 == codecSelferValueTypeArray100 {
   718  			yyl2 := r.ReadArrayStart()
   719  			if yyl2 == 0 {
   720  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
   721  			} else {
   722  				x.codecDecodeSelfFromArray(yyl2, d)
   723  			}
   724  		} else {
   725  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
   726  		}
   727  	}
   728  }
   729  
   730  func (x *QueryOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
   731  	var h codecSelfer100
   732  	z, r := codec1978.GenHelperDecoder(d)
   733  	_, _, _ = h, z, r
   734  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
   735  	_ = yys3Slc
   736  	var yyhl3 bool = l >= 0
   737  	for yyj3 := 0; ; yyj3++ {
   738  		if yyhl3 {
   739  			if yyj3 >= l {
   740  				break
   741  			}
   742  		} else {
   743  			if r.CheckBreak() {
   744  				break
   745  			}
   746  		}
   747  		z.DecSendContainerState(codecSelfer_containerMapKey100)
   748  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
   749  		yys3 := string(yys3Slc)
   750  		z.DecSendContainerState(codecSelfer_containerMapValue100)
   751  		switch yys3 {
   752  		case "Region":
   753  			if r.TryDecodeAsNil() {
   754  				x.Region = ""
   755  			} else {
   756  				yyv4 := &x.Region
   757  				yym5 := z.DecBinary()
   758  				_ = yym5
   759  				if false {
   760  				} else {
   761  					*((*string)(yyv4)) = r.DecodeString()
   762  				}
   763  			}
   764  		case "Namespace":
   765  			if r.TryDecodeAsNil() {
   766  				x.Namespace = ""
   767  			} else {
   768  				yyv6 := &x.Namespace
   769  				yym7 := z.DecBinary()
   770  				_ = yym7
   771  				if false {
   772  				} else {
   773  					*((*string)(yyv6)) = r.DecodeString()
   774  				}
   775  			}
   776  		case "MinQueryIndex":
   777  			if r.TryDecodeAsNil() {
   778  				x.MinQueryIndex = 0
   779  			} else {
   780  				yyv8 := &x.MinQueryIndex
   781  				yym9 := z.DecBinary()
   782  				_ = yym9
   783  				if false {
   784  				} else {
   785  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
   786  				}
   787  			}
   788  		case "MaxQueryTime":
   789  			if r.TryDecodeAsNil() {
   790  				x.MaxQueryTime = 0
   791  			} else {
   792  				yyv10 := &x.MaxQueryTime
   793  				yym11 := z.DecBinary()
   794  				_ = yym11
   795  				if false {
   796  				} else if z.HasExtensions() && z.DecExt(yyv10) {
   797  				} else {
   798  					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
   799  				}
   800  			}
   801  		case "AllowStale":
   802  			if r.TryDecodeAsNil() {
   803  				x.AllowStale = false
   804  			} else {
   805  				yyv12 := &x.AllowStale
   806  				yym13 := z.DecBinary()
   807  				_ = yym13
   808  				if false {
   809  				} else {
   810  					*((*bool)(yyv12)) = r.DecodeBool()
   811  				}
   812  			}
   813  		case "Prefix":
   814  			if r.TryDecodeAsNil() {
   815  				x.Prefix = ""
   816  			} else {
   817  				yyv14 := &x.Prefix
   818  				yym15 := z.DecBinary()
   819  				_ = yym15
   820  				if false {
   821  				} else {
   822  					*((*string)(yyv14)) = r.DecodeString()
   823  				}
   824  			}
   825  		case "AuthToken":
   826  			if r.TryDecodeAsNil() {
   827  				x.AuthToken = ""
   828  			} else {
   829  				yyv16 := &x.AuthToken
   830  				yym17 := z.DecBinary()
   831  				_ = yym17
   832  				if false {
   833  				} else {
   834  					*((*string)(yyv16)) = r.DecodeString()
   835  				}
   836  			}
   837  		case "Forwarded":
   838  			if r.TryDecodeAsNil() {
   839  				x.Forwarded = false
   840  			} else {
   841  				yyv18 := &x.Forwarded
   842  				yym19 := z.DecBinary()
   843  				_ = yym19
   844  				if false {
   845  				} else {
   846  					*((*bool)(yyv18)) = r.DecodeBool()
   847  				}
   848  			}
   849  		default:
   850  			z.DecStructFieldNotFound(-1, yys3)
   851  		} // end switch yys3
   852  	} // end for yyj3
   853  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
   854  }
   855  
   856  func (x *QueryOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
   857  	var h codecSelfer100
   858  	z, r := codec1978.GenHelperDecoder(d)
   859  	_, _, _ = h, z, r
   860  	var yyj20 int
   861  	var yyb20 bool
   862  	var yyhl20 bool = l >= 0
   863  	yyj20++
   864  	if yyhl20 {
   865  		yyb20 = yyj20 > l
   866  	} else {
   867  		yyb20 = r.CheckBreak()
   868  	}
   869  	if yyb20 {
   870  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
   871  		return
   872  	}
   873  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
   874  	if r.TryDecodeAsNil() {
   875  		x.Region = ""
   876  	} else {
   877  		yyv21 := &x.Region
   878  		yym22 := z.DecBinary()
   879  		_ = yym22
   880  		if false {
   881  		} else {
   882  			*((*string)(yyv21)) = r.DecodeString()
   883  		}
   884  	}
   885  	yyj20++
   886  	if yyhl20 {
   887  		yyb20 = yyj20 > l
   888  	} else {
   889  		yyb20 = r.CheckBreak()
   890  	}
   891  	if yyb20 {
   892  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
   893  		return
   894  	}
   895  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
   896  	if r.TryDecodeAsNil() {
   897  		x.Namespace = ""
   898  	} else {
   899  		yyv23 := &x.Namespace
   900  		yym24 := z.DecBinary()
   901  		_ = yym24
   902  		if false {
   903  		} else {
   904  			*((*string)(yyv23)) = r.DecodeString()
   905  		}
   906  	}
   907  	yyj20++
   908  	if yyhl20 {
   909  		yyb20 = yyj20 > l
   910  	} else {
   911  		yyb20 = r.CheckBreak()
   912  	}
   913  	if yyb20 {
   914  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
   915  		return
   916  	}
   917  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
   918  	if r.TryDecodeAsNil() {
   919  		x.MinQueryIndex = 0
   920  	} else {
   921  		yyv25 := &x.MinQueryIndex
   922  		yym26 := z.DecBinary()
   923  		_ = yym26
   924  		if false {
   925  		} else {
   926  			*((*uint64)(yyv25)) = uint64(r.DecodeUint(64))
   927  		}
   928  	}
   929  	yyj20++
   930  	if yyhl20 {
   931  		yyb20 = yyj20 > l
   932  	} else {
   933  		yyb20 = r.CheckBreak()
   934  	}
   935  	if yyb20 {
   936  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
   937  		return
   938  	}
   939  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
   940  	if r.TryDecodeAsNil() {
   941  		x.MaxQueryTime = 0
   942  	} else {
   943  		yyv27 := &x.MaxQueryTime
   944  		yym28 := z.DecBinary()
   945  		_ = yym28
   946  		if false {
   947  		} else if z.HasExtensions() && z.DecExt(yyv27) {
   948  		} else {
   949  			*((*int64)(yyv27)) = int64(r.DecodeInt(64))
   950  		}
   951  	}
   952  	yyj20++
   953  	if yyhl20 {
   954  		yyb20 = yyj20 > l
   955  	} else {
   956  		yyb20 = r.CheckBreak()
   957  	}
   958  	if yyb20 {
   959  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
   960  		return
   961  	}
   962  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
   963  	if r.TryDecodeAsNil() {
   964  		x.AllowStale = false
   965  	} else {
   966  		yyv29 := &x.AllowStale
   967  		yym30 := z.DecBinary()
   968  		_ = yym30
   969  		if false {
   970  		} else {
   971  			*((*bool)(yyv29)) = r.DecodeBool()
   972  		}
   973  	}
   974  	yyj20++
   975  	if yyhl20 {
   976  		yyb20 = yyj20 > l
   977  	} else {
   978  		yyb20 = r.CheckBreak()
   979  	}
   980  	if yyb20 {
   981  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
   982  		return
   983  	}
   984  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
   985  	if r.TryDecodeAsNil() {
   986  		x.Prefix = ""
   987  	} else {
   988  		yyv31 := &x.Prefix
   989  		yym32 := z.DecBinary()
   990  		_ = yym32
   991  		if false {
   992  		} else {
   993  			*((*string)(yyv31)) = r.DecodeString()
   994  		}
   995  	}
   996  	yyj20++
   997  	if yyhl20 {
   998  		yyb20 = yyj20 > l
   999  	} else {
  1000  		yyb20 = r.CheckBreak()
  1001  	}
  1002  	if yyb20 {
  1003  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1004  		return
  1005  	}
  1006  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  1007  	if r.TryDecodeAsNil() {
  1008  		x.AuthToken = ""
  1009  	} else {
  1010  		yyv33 := &x.AuthToken
  1011  		yym34 := z.DecBinary()
  1012  		_ = yym34
  1013  		if false {
  1014  		} else {
  1015  			*((*string)(yyv33)) = r.DecodeString()
  1016  		}
  1017  	}
  1018  	yyj20++
  1019  	if yyhl20 {
  1020  		yyb20 = yyj20 > l
  1021  	} else {
  1022  		yyb20 = r.CheckBreak()
  1023  	}
  1024  	if yyb20 {
  1025  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1026  		return
  1027  	}
  1028  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  1029  	if r.TryDecodeAsNil() {
  1030  		x.Forwarded = false
  1031  	} else {
  1032  		yyv35 := &x.Forwarded
  1033  		yym36 := z.DecBinary()
  1034  		_ = yym36
  1035  		if false {
  1036  		} else {
  1037  			*((*bool)(yyv35)) = r.DecodeBool()
  1038  		}
  1039  	}
  1040  	for {
  1041  		yyj20++
  1042  		if yyhl20 {
  1043  			yyb20 = yyj20 > l
  1044  		} else {
  1045  			yyb20 = r.CheckBreak()
  1046  		}
  1047  		if yyb20 {
  1048  			break
  1049  		}
  1050  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  1051  		z.DecStructFieldNotFound(yyj20-1, "")
  1052  	}
  1053  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1054  }
  1055  
  1056  func (x *WriteRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  1057  	var h codecSelfer100
  1058  	z, r := codec1978.GenHelperEncoder(e)
  1059  	_, _, _ = h, z, r
  1060  	if x == nil {
  1061  		r.EncodeNil()
  1062  	} else {
  1063  		yym1 := z.EncBinary()
  1064  		_ = yym1
  1065  		if false {
  1066  		} else if z.HasExtensions() && z.EncExt(x) {
  1067  		} else {
  1068  			yysep2 := !z.EncBinary()
  1069  			yy2arr2 := z.EncBasicHandle().StructToArray
  1070  			var yyq2 [4]bool
  1071  			_, _, _ = yysep2, yyq2, yy2arr2
  1072  			const yyr2 bool = false
  1073  			var yynn2 int
  1074  			if yyr2 || yy2arr2 {
  1075  				r.EncodeArrayStart(4)
  1076  			} else {
  1077  				yynn2 = 4
  1078  				for _, b := range yyq2 {
  1079  					if b {
  1080  						yynn2++
  1081  					}
  1082  				}
  1083  				r.EncodeMapStart(yynn2)
  1084  				yynn2 = 0
  1085  			}
  1086  			if yyr2 || yy2arr2 {
  1087  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  1088  				yym4 := z.EncBinary()
  1089  				_ = yym4
  1090  				if false {
  1091  				} else {
  1092  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  1093  				}
  1094  			} else {
  1095  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  1096  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  1097  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  1098  				yym5 := z.EncBinary()
  1099  				_ = yym5
  1100  				if false {
  1101  				} else {
  1102  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  1103  				}
  1104  			}
  1105  			if yyr2 || yy2arr2 {
  1106  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  1107  				yym7 := z.EncBinary()
  1108  				_ = yym7
  1109  				if false {
  1110  				} else {
  1111  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  1112  				}
  1113  			} else {
  1114  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  1115  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  1116  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  1117  				yym8 := z.EncBinary()
  1118  				_ = yym8
  1119  				if false {
  1120  				} else {
  1121  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  1122  				}
  1123  			}
  1124  			if yyr2 || yy2arr2 {
  1125  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  1126  				yym10 := z.EncBinary()
  1127  				_ = yym10
  1128  				if false {
  1129  				} else {
  1130  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  1131  				}
  1132  			} else {
  1133  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  1134  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  1135  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  1136  				yym11 := z.EncBinary()
  1137  				_ = yym11
  1138  				if false {
  1139  				} else {
  1140  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  1141  				}
  1142  			}
  1143  			if yyr2 || yy2arr2 {
  1144  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  1145  				yym13 := z.EncBinary()
  1146  				_ = yym13
  1147  				if false {
  1148  				} else {
  1149  					r.EncodeBool(bool(x.Forwarded))
  1150  				}
  1151  			} else {
  1152  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  1153  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  1154  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  1155  				yym14 := z.EncBinary()
  1156  				_ = yym14
  1157  				if false {
  1158  				} else {
  1159  					r.EncodeBool(bool(x.Forwarded))
  1160  				}
  1161  			}
  1162  			if yyr2 || yy2arr2 {
  1163  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  1164  			} else {
  1165  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  1166  			}
  1167  		}
  1168  	}
  1169  }
  1170  
  1171  func (x *WriteRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  1172  	var h codecSelfer100
  1173  	z, r := codec1978.GenHelperDecoder(d)
  1174  	_, _, _ = h, z, r
  1175  	yym1 := z.DecBinary()
  1176  	_ = yym1
  1177  	if false {
  1178  	} else if z.HasExtensions() && z.DecExt(x) {
  1179  	} else {
  1180  		yyct2 := r.ContainerType()
  1181  		if yyct2 == codecSelferValueTypeMap100 {
  1182  			yyl2 := r.ReadMapStart()
  1183  			if yyl2 == 0 {
  1184  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  1185  			} else {
  1186  				x.codecDecodeSelfFromMap(yyl2, d)
  1187  			}
  1188  		} else if yyct2 == codecSelferValueTypeArray100 {
  1189  			yyl2 := r.ReadArrayStart()
  1190  			if yyl2 == 0 {
  1191  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1192  			} else {
  1193  				x.codecDecodeSelfFromArray(yyl2, d)
  1194  			}
  1195  		} else {
  1196  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  1197  		}
  1198  	}
  1199  }
  1200  
  1201  func (x *WriteRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  1202  	var h codecSelfer100
  1203  	z, r := codec1978.GenHelperDecoder(d)
  1204  	_, _, _ = h, z, r
  1205  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  1206  	_ = yys3Slc
  1207  	var yyhl3 bool = l >= 0
  1208  	for yyj3 := 0; ; yyj3++ {
  1209  		if yyhl3 {
  1210  			if yyj3 >= l {
  1211  				break
  1212  			}
  1213  		} else {
  1214  			if r.CheckBreak() {
  1215  				break
  1216  			}
  1217  		}
  1218  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  1219  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  1220  		yys3 := string(yys3Slc)
  1221  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  1222  		switch yys3 {
  1223  		case "Region":
  1224  			if r.TryDecodeAsNil() {
  1225  				x.Region = ""
  1226  			} else {
  1227  				yyv4 := &x.Region
  1228  				yym5 := z.DecBinary()
  1229  				_ = yym5
  1230  				if false {
  1231  				} else {
  1232  					*((*string)(yyv4)) = r.DecodeString()
  1233  				}
  1234  			}
  1235  		case "Namespace":
  1236  			if r.TryDecodeAsNil() {
  1237  				x.Namespace = ""
  1238  			} else {
  1239  				yyv6 := &x.Namespace
  1240  				yym7 := z.DecBinary()
  1241  				_ = yym7
  1242  				if false {
  1243  				} else {
  1244  					*((*string)(yyv6)) = r.DecodeString()
  1245  				}
  1246  			}
  1247  		case "AuthToken":
  1248  			if r.TryDecodeAsNil() {
  1249  				x.AuthToken = ""
  1250  			} else {
  1251  				yyv8 := &x.AuthToken
  1252  				yym9 := z.DecBinary()
  1253  				_ = yym9
  1254  				if false {
  1255  				} else {
  1256  					*((*string)(yyv8)) = r.DecodeString()
  1257  				}
  1258  			}
  1259  		case "Forwarded":
  1260  			if r.TryDecodeAsNil() {
  1261  				x.Forwarded = false
  1262  			} else {
  1263  				yyv10 := &x.Forwarded
  1264  				yym11 := z.DecBinary()
  1265  				_ = yym11
  1266  				if false {
  1267  				} else {
  1268  					*((*bool)(yyv10)) = r.DecodeBool()
  1269  				}
  1270  			}
  1271  		default:
  1272  			z.DecStructFieldNotFound(-1, yys3)
  1273  		} // end switch yys3
  1274  	} // end for yyj3
  1275  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  1276  }
  1277  
  1278  func (x *WriteRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  1279  	var h codecSelfer100
  1280  	z, r := codec1978.GenHelperDecoder(d)
  1281  	_, _, _ = h, z, r
  1282  	var yyj12 int
  1283  	var yyb12 bool
  1284  	var yyhl12 bool = l >= 0
  1285  	yyj12++
  1286  	if yyhl12 {
  1287  		yyb12 = yyj12 > l
  1288  	} else {
  1289  		yyb12 = r.CheckBreak()
  1290  	}
  1291  	if yyb12 {
  1292  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1293  		return
  1294  	}
  1295  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  1296  	if r.TryDecodeAsNil() {
  1297  		x.Region = ""
  1298  	} else {
  1299  		yyv13 := &x.Region
  1300  		yym14 := z.DecBinary()
  1301  		_ = yym14
  1302  		if false {
  1303  		} else {
  1304  			*((*string)(yyv13)) = r.DecodeString()
  1305  		}
  1306  	}
  1307  	yyj12++
  1308  	if yyhl12 {
  1309  		yyb12 = yyj12 > l
  1310  	} else {
  1311  		yyb12 = r.CheckBreak()
  1312  	}
  1313  	if yyb12 {
  1314  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1315  		return
  1316  	}
  1317  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  1318  	if r.TryDecodeAsNil() {
  1319  		x.Namespace = ""
  1320  	} else {
  1321  		yyv15 := &x.Namespace
  1322  		yym16 := z.DecBinary()
  1323  		_ = yym16
  1324  		if false {
  1325  		} else {
  1326  			*((*string)(yyv15)) = r.DecodeString()
  1327  		}
  1328  	}
  1329  	yyj12++
  1330  	if yyhl12 {
  1331  		yyb12 = yyj12 > l
  1332  	} else {
  1333  		yyb12 = r.CheckBreak()
  1334  	}
  1335  	if yyb12 {
  1336  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1337  		return
  1338  	}
  1339  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  1340  	if r.TryDecodeAsNil() {
  1341  		x.AuthToken = ""
  1342  	} else {
  1343  		yyv17 := &x.AuthToken
  1344  		yym18 := z.DecBinary()
  1345  		_ = yym18
  1346  		if false {
  1347  		} else {
  1348  			*((*string)(yyv17)) = r.DecodeString()
  1349  		}
  1350  	}
  1351  	yyj12++
  1352  	if yyhl12 {
  1353  		yyb12 = yyj12 > l
  1354  	} else {
  1355  		yyb12 = r.CheckBreak()
  1356  	}
  1357  	if yyb12 {
  1358  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1359  		return
  1360  	}
  1361  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  1362  	if r.TryDecodeAsNil() {
  1363  		x.Forwarded = false
  1364  	} else {
  1365  		yyv19 := &x.Forwarded
  1366  		yym20 := z.DecBinary()
  1367  		_ = yym20
  1368  		if false {
  1369  		} else {
  1370  			*((*bool)(yyv19)) = r.DecodeBool()
  1371  		}
  1372  	}
  1373  	for {
  1374  		yyj12++
  1375  		if yyhl12 {
  1376  			yyb12 = yyj12 > l
  1377  		} else {
  1378  			yyb12 = r.CheckBreak()
  1379  		}
  1380  		if yyb12 {
  1381  			break
  1382  		}
  1383  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  1384  		z.DecStructFieldNotFound(yyj12-1, "")
  1385  	}
  1386  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1387  }
  1388  
  1389  func (x *QueryMeta) CodecEncodeSelf(e *codec1978.Encoder) {
  1390  	var h codecSelfer100
  1391  	z, r := codec1978.GenHelperEncoder(e)
  1392  	_, _, _ = h, z, r
  1393  	if x == nil {
  1394  		r.EncodeNil()
  1395  	} else {
  1396  		yym1 := z.EncBinary()
  1397  		_ = yym1
  1398  		if false {
  1399  		} else if z.HasExtensions() && z.EncExt(x) {
  1400  		} else {
  1401  			yysep2 := !z.EncBinary()
  1402  			yy2arr2 := z.EncBasicHandle().StructToArray
  1403  			var yyq2 [3]bool
  1404  			_, _, _ = yysep2, yyq2, yy2arr2
  1405  			const yyr2 bool = false
  1406  			var yynn2 int
  1407  			if yyr2 || yy2arr2 {
  1408  				r.EncodeArrayStart(3)
  1409  			} else {
  1410  				yynn2 = 3
  1411  				for _, b := range yyq2 {
  1412  					if b {
  1413  						yynn2++
  1414  					}
  1415  				}
  1416  				r.EncodeMapStart(yynn2)
  1417  				yynn2 = 0
  1418  			}
  1419  			if yyr2 || yy2arr2 {
  1420  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  1421  				yym4 := z.EncBinary()
  1422  				_ = yym4
  1423  				if false {
  1424  				} else {
  1425  					r.EncodeUint(uint64(x.Index))
  1426  				}
  1427  			} else {
  1428  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  1429  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
  1430  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  1431  				yym5 := z.EncBinary()
  1432  				_ = yym5
  1433  				if false {
  1434  				} else {
  1435  					r.EncodeUint(uint64(x.Index))
  1436  				}
  1437  			}
  1438  			if yyr2 || yy2arr2 {
  1439  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  1440  				yym7 := z.EncBinary()
  1441  				_ = yym7
  1442  				if false {
  1443  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
  1444  				} else {
  1445  					r.EncodeInt(int64(x.LastContact))
  1446  				}
  1447  			} else {
  1448  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  1449  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
  1450  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  1451  				yym8 := z.EncBinary()
  1452  				_ = yym8
  1453  				if false {
  1454  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
  1455  				} else {
  1456  					r.EncodeInt(int64(x.LastContact))
  1457  				}
  1458  			}
  1459  			if yyr2 || yy2arr2 {
  1460  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  1461  				yym10 := z.EncBinary()
  1462  				_ = yym10
  1463  				if false {
  1464  				} else {
  1465  					r.EncodeBool(bool(x.KnownLeader))
  1466  				}
  1467  			} else {
  1468  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  1469  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
  1470  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  1471  				yym11 := z.EncBinary()
  1472  				_ = yym11
  1473  				if false {
  1474  				} else {
  1475  					r.EncodeBool(bool(x.KnownLeader))
  1476  				}
  1477  			}
  1478  			if yyr2 || yy2arr2 {
  1479  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  1480  			} else {
  1481  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  1482  			}
  1483  		}
  1484  	}
  1485  }
  1486  
  1487  func (x *QueryMeta) CodecDecodeSelf(d *codec1978.Decoder) {
  1488  	var h codecSelfer100
  1489  	z, r := codec1978.GenHelperDecoder(d)
  1490  	_, _, _ = h, z, r
  1491  	yym1 := z.DecBinary()
  1492  	_ = yym1
  1493  	if false {
  1494  	} else if z.HasExtensions() && z.DecExt(x) {
  1495  	} else {
  1496  		yyct2 := r.ContainerType()
  1497  		if yyct2 == codecSelferValueTypeMap100 {
  1498  			yyl2 := r.ReadMapStart()
  1499  			if yyl2 == 0 {
  1500  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  1501  			} else {
  1502  				x.codecDecodeSelfFromMap(yyl2, d)
  1503  			}
  1504  		} else if yyct2 == codecSelferValueTypeArray100 {
  1505  			yyl2 := r.ReadArrayStart()
  1506  			if yyl2 == 0 {
  1507  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1508  			} else {
  1509  				x.codecDecodeSelfFromArray(yyl2, d)
  1510  			}
  1511  		} else {
  1512  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  1513  		}
  1514  	}
  1515  }
  1516  
  1517  func (x *QueryMeta) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  1518  	var h codecSelfer100
  1519  	z, r := codec1978.GenHelperDecoder(d)
  1520  	_, _, _ = h, z, r
  1521  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  1522  	_ = yys3Slc
  1523  	var yyhl3 bool = l >= 0
  1524  	for yyj3 := 0; ; yyj3++ {
  1525  		if yyhl3 {
  1526  			if yyj3 >= l {
  1527  				break
  1528  			}
  1529  		} else {
  1530  			if r.CheckBreak() {
  1531  				break
  1532  			}
  1533  		}
  1534  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  1535  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  1536  		yys3 := string(yys3Slc)
  1537  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  1538  		switch yys3 {
  1539  		case "Index":
  1540  			if r.TryDecodeAsNil() {
  1541  				x.Index = 0
  1542  			} else {
  1543  				yyv4 := &x.Index
  1544  				yym5 := z.DecBinary()
  1545  				_ = yym5
  1546  				if false {
  1547  				} else {
  1548  					*((*uint64)(yyv4)) = uint64(r.DecodeUint(64))
  1549  				}
  1550  			}
  1551  		case "LastContact":
  1552  			if r.TryDecodeAsNil() {
  1553  				x.LastContact = 0
  1554  			} else {
  1555  				yyv6 := &x.LastContact
  1556  				yym7 := z.DecBinary()
  1557  				_ = yym7
  1558  				if false {
  1559  				} else if z.HasExtensions() && z.DecExt(yyv6) {
  1560  				} else {
  1561  					*((*int64)(yyv6)) = int64(r.DecodeInt(64))
  1562  				}
  1563  			}
  1564  		case "KnownLeader":
  1565  			if r.TryDecodeAsNil() {
  1566  				x.KnownLeader = false
  1567  			} else {
  1568  				yyv8 := &x.KnownLeader
  1569  				yym9 := z.DecBinary()
  1570  				_ = yym9
  1571  				if false {
  1572  				} else {
  1573  					*((*bool)(yyv8)) = r.DecodeBool()
  1574  				}
  1575  			}
  1576  		default:
  1577  			z.DecStructFieldNotFound(-1, yys3)
  1578  		} // end switch yys3
  1579  	} // end for yyj3
  1580  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  1581  }
  1582  
  1583  func (x *QueryMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  1584  	var h codecSelfer100
  1585  	z, r := codec1978.GenHelperDecoder(d)
  1586  	_, _, _ = h, z, r
  1587  	var yyj10 int
  1588  	var yyb10 bool
  1589  	var yyhl10 bool = l >= 0
  1590  	yyj10++
  1591  	if yyhl10 {
  1592  		yyb10 = yyj10 > l
  1593  	} else {
  1594  		yyb10 = r.CheckBreak()
  1595  	}
  1596  	if yyb10 {
  1597  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1598  		return
  1599  	}
  1600  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  1601  	if r.TryDecodeAsNil() {
  1602  		x.Index = 0
  1603  	} else {
  1604  		yyv11 := &x.Index
  1605  		yym12 := z.DecBinary()
  1606  		_ = yym12
  1607  		if false {
  1608  		} else {
  1609  			*((*uint64)(yyv11)) = uint64(r.DecodeUint(64))
  1610  		}
  1611  	}
  1612  	yyj10++
  1613  	if yyhl10 {
  1614  		yyb10 = yyj10 > l
  1615  	} else {
  1616  		yyb10 = r.CheckBreak()
  1617  	}
  1618  	if yyb10 {
  1619  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1620  		return
  1621  	}
  1622  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  1623  	if r.TryDecodeAsNil() {
  1624  		x.LastContact = 0
  1625  	} else {
  1626  		yyv13 := &x.LastContact
  1627  		yym14 := z.DecBinary()
  1628  		_ = yym14
  1629  		if false {
  1630  		} else if z.HasExtensions() && z.DecExt(yyv13) {
  1631  		} else {
  1632  			*((*int64)(yyv13)) = int64(r.DecodeInt(64))
  1633  		}
  1634  	}
  1635  	yyj10++
  1636  	if yyhl10 {
  1637  		yyb10 = yyj10 > l
  1638  	} else {
  1639  		yyb10 = r.CheckBreak()
  1640  	}
  1641  	if yyb10 {
  1642  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1643  		return
  1644  	}
  1645  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  1646  	if r.TryDecodeAsNil() {
  1647  		x.KnownLeader = false
  1648  	} else {
  1649  		yyv15 := &x.KnownLeader
  1650  		yym16 := z.DecBinary()
  1651  		_ = yym16
  1652  		if false {
  1653  		} else {
  1654  			*((*bool)(yyv15)) = r.DecodeBool()
  1655  		}
  1656  	}
  1657  	for {
  1658  		yyj10++
  1659  		if yyhl10 {
  1660  			yyb10 = yyj10 > l
  1661  		} else {
  1662  			yyb10 = r.CheckBreak()
  1663  		}
  1664  		if yyb10 {
  1665  			break
  1666  		}
  1667  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  1668  		z.DecStructFieldNotFound(yyj10-1, "")
  1669  	}
  1670  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1671  }
  1672  
  1673  func (x *WriteMeta) CodecEncodeSelf(e *codec1978.Encoder) {
  1674  	var h codecSelfer100
  1675  	z, r := codec1978.GenHelperEncoder(e)
  1676  	_, _, _ = h, z, r
  1677  	if x == nil {
  1678  		r.EncodeNil()
  1679  	} else {
  1680  		yym1 := z.EncBinary()
  1681  		_ = yym1
  1682  		if false {
  1683  		} else if z.HasExtensions() && z.EncExt(x) {
  1684  		} else {
  1685  			yysep2 := !z.EncBinary()
  1686  			yy2arr2 := z.EncBasicHandle().StructToArray
  1687  			var yyq2 [1]bool
  1688  			_, _, _ = yysep2, yyq2, yy2arr2
  1689  			const yyr2 bool = false
  1690  			var yynn2 int
  1691  			if yyr2 || yy2arr2 {
  1692  				r.EncodeArrayStart(1)
  1693  			} else {
  1694  				yynn2 = 1
  1695  				for _, b := range yyq2 {
  1696  					if b {
  1697  						yynn2++
  1698  					}
  1699  				}
  1700  				r.EncodeMapStart(yynn2)
  1701  				yynn2 = 0
  1702  			}
  1703  			if yyr2 || yy2arr2 {
  1704  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  1705  				yym4 := z.EncBinary()
  1706  				_ = yym4
  1707  				if false {
  1708  				} else {
  1709  					r.EncodeUint(uint64(x.Index))
  1710  				}
  1711  			} else {
  1712  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  1713  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
  1714  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  1715  				yym5 := z.EncBinary()
  1716  				_ = yym5
  1717  				if false {
  1718  				} else {
  1719  					r.EncodeUint(uint64(x.Index))
  1720  				}
  1721  			}
  1722  			if yyr2 || yy2arr2 {
  1723  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  1724  			} else {
  1725  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  1726  			}
  1727  		}
  1728  	}
  1729  }
  1730  
  1731  func (x *WriteMeta) CodecDecodeSelf(d *codec1978.Decoder) {
  1732  	var h codecSelfer100
  1733  	z, r := codec1978.GenHelperDecoder(d)
  1734  	_, _, _ = h, z, r
  1735  	yym1 := z.DecBinary()
  1736  	_ = yym1
  1737  	if false {
  1738  	} else if z.HasExtensions() && z.DecExt(x) {
  1739  	} else {
  1740  		yyct2 := r.ContainerType()
  1741  		if yyct2 == codecSelferValueTypeMap100 {
  1742  			yyl2 := r.ReadMapStart()
  1743  			if yyl2 == 0 {
  1744  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  1745  			} else {
  1746  				x.codecDecodeSelfFromMap(yyl2, d)
  1747  			}
  1748  		} else if yyct2 == codecSelferValueTypeArray100 {
  1749  			yyl2 := r.ReadArrayStart()
  1750  			if yyl2 == 0 {
  1751  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1752  			} else {
  1753  				x.codecDecodeSelfFromArray(yyl2, d)
  1754  			}
  1755  		} else {
  1756  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  1757  		}
  1758  	}
  1759  }
  1760  
  1761  func (x *WriteMeta) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  1762  	var h codecSelfer100
  1763  	z, r := codec1978.GenHelperDecoder(d)
  1764  	_, _, _ = h, z, r
  1765  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  1766  	_ = yys3Slc
  1767  	var yyhl3 bool = l >= 0
  1768  	for yyj3 := 0; ; yyj3++ {
  1769  		if yyhl3 {
  1770  			if yyj3 >= l {
  1771  				break
  1772  			}
  1773  		} else {
  1774  			if r.CheckBreak() {
  1775  				break
  1776  			}
  1777  		}
  1778  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  1779  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  1780  		yys3 := string(yys3Slc)
  1781  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  1782  		switch yys3 {
  1783  		case "Index":
  1784  			if r.TryDecodeAsNil() {
  1785  				x.Index = 0
  1786  			} else {
  1787  				yyv4 := &x.Index
  1788  				yym5 := z.DecBinary()
  1789  				_ = yym5
  1790  				if false {
  1791  				} else {
  1792  					*((*uint64)(yyv4)) = uint64(r.DecodeUint(64))
  1793  				}
  1794  			}
  1795  		default:
  1796  			z.DecStructFieldNotFound(-1, yys3)
  1797  		} // end switch yys3
  1798  	} // end for yyj3
  1799  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  1800  }
  1801  
  1802  func (x *WriteMeta) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  1803  	var h codecSelfer100
  1804  	z, r := codec1978.GenHelperDecoder(d)
  1805  	_, _, _ = h, z, r
  1806  	var yyj6 int
  1807  	var yyb6 bool
  1808  	var yyhl6 bool = l >= 0
  1809  	yyj6++
  1810  	if yyhl6 {
  1811  		yyb6 = yyj6 > l
  1812  	} else {
  1813  		yyb6 = r.CheckBreak()
  1814  	}
  1815  	if yyb6 {
  1816  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1817  		return
  1818  	}
  1819  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  1820  	if r.TryDecodeAsNil() {
  1821  		x.Index = 0
  1822  	} else {
  1823  		yyv7 := &x.Index
  1824  		yym8 := z.DecBinary()
  1825  		_ = yym8
  1826  		if false {
  1827  		} else {
  1828  			*((*uint64)(yyv7)) = uint64(r.DecodeUint(64))
  1829  		}
  1830  	}
  1831  	for {
  1832  		yyj6++
  1833  		if yyhl6 {
  1834  			yyb6 = yyj6 > l
  1835  		} else {
  1836  			yyb6 = r.CheckBreak()
  1837  		}
  1838  		if yyb6 {
  1839  			break
  1840  		}
  1841  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  1842  		z.DecStructFieldNotFound(yyj6-1, "")
  1843  	}
  1844  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  1845  }
  1846  
  1847  func (x *NodeRegisterRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  1848  	var h codecSelfer100
  1849  	z, r := codec1978.GenHelperEncoder(e)
  1850  	_, _, _ = h, z, r
  1851  	if x == nil {
  1852  		r.EncodeNil()
  1853  	} else {
  1854  		yym1 := z.EncBinary()
  1855  		_ = yym1
  1856  		if false {
  1857  		} else if z.HasExtensions() && z.EncExt(x) {
  1858  		} else {
  1859  			yysep2 := !z.EncBinary()
  1860  			yy2arr2 := z.EncBasicHandle().StructToArray
  1861  			var yyq2 [5]bool
  1862  			_, _, _ = yysep2, yyq2, yy2arr2
  1863  			const yyr2 bool = false
  1864  			var yynn2 int
  1865  			if yyr2 || yy2arr2 {
  1866  				r.EncodeArrayStart(5)
  1867  			} else {
  1868  				yynn2 = 5
  1869  				for _, b := range yyq2 {
  1870  					if b {
  1871  						yynn2++
  1872  					}
  1873  				}
  1874  				r.EncodeMapStart(yynn2)
  1875  				yynn2 = 0
  1876  			}
  1877  			if yyr2 || yy2arr2 {
  1878  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  1879  				if x.Node == nil {
  1880  					r.EncodeNil()
  1881  				} else {
  1882  					x.Node.CodecEncodeSelf(e)
  1883  				}
  1884  			} else {
  1885  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  1886  				r.EncodeString(codecSelferC_UTF8100, string("Node"))
  1887  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  1888  				if x.Node == nil {
  1889  					r.EncodeNil()
  1890  				} else {
  1891  					x.Node.CodecEncodeSelf(e)
  1892  				}
  1893  			}
  1894  			if yyr2 || yy2arr2 {
  1895  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  1896  				yym7 := z.EncBinary()
  1897  				_ = yym7
  1898  				if false {
  1899  				} else {
  1900  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  1901  				}
  1902  			} else {
  1903  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  1904  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  1905  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  1906  				yym8 := z.EncBinary()
  1907  				_ = yym8
  1908  				if false {
  1909  				} else {
  1910  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  1911  				}
  1912  			}
  1913  			if yyr2 || yy2arr2 {
  1914  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  1915  				yym10 := z.EncBinary()
  1916  				_ = yym10
  1917  				if false {
  1918  				} else {
  1919  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  1920  				}
  1921  			} else {
  1922  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  1923  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  1924  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  1925  				yym11 := z.EncBinary()
  1926  				_ = yym11
  1927  				if false {
  1928  				} else {
  1929  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  1930  				}
  1931  			}
  1932  			if yyr2 || yy2arr2 {
  1933  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  1934  				yym13 := z.EncBinary()
  1935  				_ = yym13
  1936  				if false {
  1937  				} else {
  1938  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  1939  				}
  1940  			} else {
  1941  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  1942  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  1943  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  1944  				yym14 := z.EncBinary()
  1945  				_ = yym14
  1946  				if false {
  1947  				} else {
  1948  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  1949  				}
  1950  			}
  1951  			if yyr2 || yy2arr2 {
  1952  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  1953  				yym16 := z.EncBinary()
  1954  				_ = yym16
  1955  				if false {
  1956  				} else {
  1957  					r.EncodeBool(bool(x.Forwarded))
  1958  				}
  1959  			} else {
  1960  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  1961  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  1962  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  1963  				yym17 := z.EncBinary()
  1964  				_ = yym17
  1965  				if false {
  1966  				} else {
  1967  					r.EncodeBool(bool(x.Forwarded))
  1968  				}
  1969  			}
  1970  			if yyr2 || yy2arr2 {
  1971  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  1972  			} else {
  1973  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  1974  			}
  1975  		}
  1976  	}
  1977  }
  1978  
  1979  func (x *NodeRegisterRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  1980  	var h codecSelfer100
  1981  	z, r := codec1978.GenHelperDecoder(d)
  1982  	_, _, _ = h, z, r
  1983  	yym1 := z.DecBinary()
  1984  	_ = yym1
  1985  	if false {
  1986  	} else if z.HasExtensions() && z.DecExt(x) {
  1987  	} else {
  1988  		yyct2 := r.ContainerType()
  1989  		if yyct2 == codecSelferValueTypeMap100 {
  1990  			yyl2 := r.ReadMapStart()
  1991  			if yyl2 == 0 {
  1992  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  1993  			} else {
  1994  				x.codecDecodeSelfFromMap(yyl2, d)
  1995  			}
  1996  		} else if yyct2 == codecSelferValueTypeArray100 {
  1997  			yyl2 := r.ReadArrayStart()
  1998  			if yyl2 == 0 {
  1999  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2000  			} else {
  2001  				x.codecDecodeSelfFromArray(yyl2, d)
  2002  			}
  2003  		} else {
  2004  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  2005  		}
  2006  	}
  2007  }
  2008  
  2009  func (x *NodeRegisterRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  2010  	var h codecSelfer100
  2011  	z, r := codec1978.GenHelperDecoder(d)
  2012  	_, _, _ = h, z, r
  2013  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  2014  	_ = yys3Slc
  2015  	var yyhl3 bool = l >= 0
  2016  	for yyj3 := 0; ; yyj3++ {
  2017  		if yyhl3 {
  2018  			if yyj3 >= l {
  2019  				break
  2020  			}
  2021  		} else {
  2022  			if r.CheckBreak() {
  2023  				break
  2024  			}
  2025  		}
  2026  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  2027  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  2028  		yys3 := string(yys3Slc)
  2029  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  2030  		switch yys3 {
  2031  		case "Node":
  2032  			if r.TryDecodeAsNil() {
  2033  				if x.Node != nil {
  2034  					x.Node = nil
  2035  				}
  2036  			} else {
  2037  				if x.Node == nil {
  2038  					x.Node = new(Node)
  2039  				}
  2040  				x.Node.CodecDecodeSelf(d)
  2041  			}
  2042  		case "Region":
  2043  			if r.TryDecodeAsNil() {
  2044  				x.Region = ""
  2045  			} else {
  2046  				yyv5 := &x.Region
  2047  				yym6 := z.DecBinary()
  2048  				_ = yym6
  2049  				if false {
  2050  				} else {
  2051  					*((*string)(yyv5)) = r.DecodeString()
  2052  				}
  2053  			}
  2054  		case "Namespace":
  2055  			if r.TryDecodeAsNil() {
  2056  				x.Namespace = ""
  2057  			} else {
  2058  				yyv7 := &x.Namespace
  2059  				yym8 := z.DecBinary()
  2060  				_ = yym8
  2061  				if false {
  2062  				} else {
  2063  					*((*string)(yyv7)) = r.DecodeString()
  2064  				}
  2065  			}
  2066  		case "AuthToken":
  2067  			if r.TryDecodeAsNil() {
  2068  				x.AuthToken = ""
  2069  			} else {
  2070  				yyv9 := &x.AuthToken
  2071  				yym10 := z.DecBinary()
  2072  				_ = yym10
  2073  				if false {
  2074  				} else {
  2075  					*((*string)(yyv9)) = r.DecodeString()
  2076  				}
  2077  			}
  2078  		case "Forwarded":
  2079  			if r.TryDecodeAsNil() {
  2080  				x.Forwarded = false
  2081  			} else {
  2082  				yyv11 := &x.Forwarded
  2083  				yym12 := z.DecBinary()
  2084  				_ = yym12
  2085  				if false {
  2086  				} else {
  2087  					*((*bool)(yyv11)) = r.DecodeBool()
  2088  				}
  2089  			}
  2090  		default:
  2091  			z.DecStructFieldNotFound(-1, yys3)
  2092  		} // end switch yys3
  2093  	} // end for yyj3
  2094  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  2095  }
  2096  
  2097  func (x *NodeRegisterRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  2098  	var h codecSelfer100
  2099  	z, r := codec1978.GenHelperDecoder(d)
  2100  	_, _, _ = h, z, r
  2101  	var yyj13 int
  2102  	var yyb13 bool
  2103  	var yyhl13 bool = l >= 0
  2104  	yyj13++
  2105  	if yyhl13 {
  2106  		yyb13 = yyj13 > l
  2107  	} else {
  2108  		yyb13 = r.CheckBreak()
  2109  	}
  2110  	if yyb13 {
  2111  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2112  		return
  2113  	}
  2114  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2115  	if r.TryDecodeAsNil() {
  2116  		if x.Node != nil {
  2117  			x.Node = nil
  2118  		}
  2119  	} else {
  2120  		if x.Node == nil {
  2121  			x.Node = new(Node)
  2122  		}
  2123  		x.Node.CodecDecodeSelf(d)
  2124  	}
  2125  	yyj13++
  2126  	if yyhl13 {
  2127  		yyb13 = yyj13 > l
  2128  	} else {
  2129  		yyb13 = r.CheckBreak()
  2130  	}
  2131  	if yyb13 {
  2132  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2133  		return
  2134  	}
  2135  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2136  	if r.TryDecodeAsNil() {
  2137  		x.Region = ""
  2138  	} else {
  2139  		yyv15 := &x.Region
  2140  		yym16 := z.DecBinary()
  2141  		_ = yym16
  2142  		if false {
  2143  		} else {
  2144  			*((*string)(yyv15)) = r.DecodeString()
  2145  		}
  2146  	}
  2147  	yyj13++
  2148  	if yyhl13 {
  2149  		yyb13 = yyj13 > l
  2150  	} else {
  2151  		yyb13 = r.CheckBreak()
  2152  	}
  2153  	if yyb13 {
  2154  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2155  		return
  2156  	}
  2157  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2158  	if r.TryDecodeAsNil() {
  2159  		x.Namespace = ""
  2160  	} else {
  2161  		yyv17 := &x.Namespace
  2162  		yym18 := z.DecBinary()
  2163  		_ = yym18
  2164  		if false {
  2165  		} else {
  2166  			*((*string)(yyv17)) = r.DecodeString()
  2167  		}
  2168  	}
  2169  	yyj13++
  2170  	if yyhl13 {
  2171  		yyb13 = yyj13 > l
  2172  	} else {
  2173  		yyb13 = r.CheckBreak()
  2174  	}
  2175  	if yyb13 {
  2176  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2177  		return
  2178  	}
  2179  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2180  	if r.TryDecodeAsNil() {
  2181  		x.AuthToken = ""
  2182  	} else {
  2183  		yyv19 := &x.AuthToken
  2184  		yym20 := z.DecBinary()
  2185  		_ = yym20
  2186  		if false {
  2187  		} else {
  2188  			*((*string)(yyv19)) = r.DecodeString()
  2189  		}
  2190  	}
  2191  	yyj13++
  2192  	if yyhl13 {
  2193  		yyb13 = yyj13 > l
  2194  	} else {
  2195  		yyb13 = r.CheckBreak()
  2196  	}
  2197  	if yyb13 {
  2198  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2199  		return
  2200  	}
  2201  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2202  	if r.TryDecodeAsNil() {
  2203  		x.Forwarded = false
  2204  	} else {
  2205  		yyv21 := &x.Forwarded
  2206  		yym22 := z.DecBinary()
  2207  		_ = yym22
  2208  		if false {
  2209  		} else {
  2210  			*((*bool)(yyv21)) = r.DecodeBool()
  2211  		}
  2212  	}
  2213  	for {
  2214  		yyj13++
  2215  		if yyhl13 {
  2216  			yyb13 = yyj13 > l
  2217  		} else {
  2218  			yyb13 = r.CheckBreak()
  2219  		}
  2220  		if yyb13 {
  2221  			break
  2222  		}
  2223  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2224  		z.DecStructFieldNotFound(yyj13-1, "")
  2225  	}
  2226  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2227  }
  2228  
  2229  func (x *NodeDeregisterRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  2230  	var h codecSelfer100
  2231  	z, r := codec1978.GenHelperEncoder(e)
  2232  	_, _, _ = h, z, r
  2233  	if x == nil {
  2234  		r.EncodeNil()
  2235  	} else {
  2236  		yym1 := z.EncBinary()
  2237  		_ = yym1
  2238  		if false {
  2239  		} else if z.HasExtensions() && z.EncExt(x) {
  2240  		} else {
  2241  			yysep2 := !z.EncBinary()
  2242  			yy2arr2 := z.EncBasicHandle().StructToArray
  2243  			var yyq2 [5]bool
  2244  			_, _, _ = yysep2, yyq2, yy2arr2
  2245  			const yyr2 bool = false
  2246  			var yynn2 int
  2247  			if yyr2 || yy2arr2 {
  2248  				r.EncodeArrayStart(5)
  2249  			} else {
  2250  				yynn2 = 5
  2251  				for _, b := range yyq2 {
  2252  					if b {
  2253  						yynn2++
  2254  					}
  2255  				}
  2256  				r.EncodeMapStart(yynn2)
  2257  				yynn2 = 0
  2258  			}
  2259  			if yyr2 || yy2arr2 {
  2260  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  2261  				yym4 := z.EncBinary()
  2262  				_ = yym4
  2263  				if false {
  2264  				} else {
  2265  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
  2266  				}
  2267  			} else {
  2268  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  2269  				r.EncodeString(codecSelferC_UTF8100, string("NodeID"))
  2270  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  2271  				yym5 := z.EncBinary()
  2272  				_ = yym5
  2273  				if false {
  2274  				} else {
  2275  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
  2276  				}
  2277  			}
  2278  			if yyr2 || yy2arr2 {
  2279  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  2280  				yym7 := z.EncBinary()
  2281  				_ = yym7
  2282  				if false {
  2283  				} else {
  2284  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  2285  				}
  2286  			} else {
  2287  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  2288  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  2289  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  2290  				yym8 := z.EncBinary()
  2291  				_ = yym8
  2292  				if false {
  2293  				} else {
  2294  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  2295  				}
  2296  			}
  2297  			if yyr2 || yy2arr2 {
  2298  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  2299  				yym10 := z.EncBinary()
  2300  				_ = yym10
  2301  				if false {
  2302  				} else {
  2303  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  2304  				}
  2305  			} else {
  2306  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  2307  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  2308  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  2309  				yym11 := z.EncBinary()
  2310  				_ = yym11
  2311  				if false {
  2312  				} else {
  2313  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  2314  				}
  2315  			}
  2316  			if yyr2 || yy2arr2 {
  2317  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  2318  				yym13 := z.EncBinary()
  2319  				_ = yym13
  2320  				if false {
  2321  				} else {
  2322  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  2323  				}
  2324  			} else {
  2325  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  2326  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  2327  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  2328  				yym14 := z.EncBinary()
  2329  				_ = yym14
  2330  				if false {
  2331  				} else {
  2332  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  2333  				}
  2334  			}
  2335  			if yyr2 || yy2arr2 {
  2336  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  2337  				yym16 := z.EncBinary()
  2338  				_ = yym16
  2339  				if false {
  2340  				} else {
  2341  					r.EncodeBool(bool(x.Forwarded))
  2342  				}
  2343  			} else {
  2344  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  2345  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  2346  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  2347  				yym17 := z.EncBinary()
  2348  				_ = yym17
  2349  				if false {
  2350  				} else {
  2351  					r.EncodeBool(bool(x.Forwarded))
  2352  				}
  2353  			}
  2354  			if yyr2 || yy2arr2 {
  2355  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  2356  			} else {
  2357  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  2358  			}
  2359  		}
  2360  	}
  2361  }
  2362  
  2363  func (x *NodeDeregisterRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  2364  	var h codecSelfer100
  2365  	z, r := codec1978.GenHelperDecoder(d)
  2366  	_, _, _ = h, z, r
  2367  	yym1 := z.DecBinary()
  2368  	_ = yym1
  2369  	if false {
  2370  	} else if z.HasExtensions() && z.DecExt(x) {
  2371  	} else {
  2372  		yyct2 := r.ContainerType()
  2373  		if yyct2 == codecSelferValueTypeMap100 {
  2374  			yyl2 := r.ReadMapStart()
  2375  			if yyl2 == 0 {
  2376  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  2377  			} else {
  2378  				x.codecDecodeSelfFromMap(yyl2, d)
  2379  			}
  2380  		} else if yyct2 == codecSelferValueTypeArray100 {
  2381  			yyl2 := r.ReadArrayStart()
  2382  			if yyl2 == 0 {
  2383  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2384  			} else {
  2385  				x.codecDecodeSelfFromArray(yyl2, d)
  2386  			}
  2387  		} else {
  2388  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  2389  		}
  2390  	}
  2391  }
  2392  
  2393  func (x *NodeDeregisterRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  2394  	var h codecSelfer100
  2395  	z, r := codec1978.GenHelperDecoder(d)
  2396  	_, _, _ = h, z, r
  2397  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  2398  	_ = yys3Slc
  2399  	var yyhl3 bool = l >= 0
  2400  	for yyj3 := 0; ; yyj3++ {
  2401  		if yyhl3 {
  2402  			if yyj3 >= l {
  2403  				break
  2404  			}
  2405  		} else {
  2406  			if r.CheckBreak() {
  2407  				break
  2408  			}
  2409  		}
  2410  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  2411  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  2412  		yys3 := string(yys3Slc)
  2413  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  2414  		switch yys3 {
  2415  		case "NodeID":
  2416  			if r.TryDecodeAsNil() {
  2417  				x.NodeID = ""
  2418  			} else {
  2419  				yyv4 := &x.NodeID
  2420  				yym5 := z.DecBinary()
  2421  				_ = yym5
  2422  				if false {
  2423  				} else {
  2424  					*((*string)(yyv4)) = r.DecodeString()
  2425  				}
  2426  			}
  2427  		case "Region":
  2428  			if r.TryDecodeAsNil() {
  2429  				x.Region = ""
  2430  			} else {
  2431  				yyv6 := &x.Region
  2432  				yym7 := z.DecBinary()
  2433  				_ = yym7
  2434  				if false {
  2435  				} else {
  2436  					*((*string)(yyv6)) = r.DecodeString()
  2437  				}
  2438  			}
  2439  		case "Namespace":
  2440  			if r.TryDecodeAsNil() {
  2441  				x.Namespace = ""
  2442  			} else {
  2443  				yyv8 := &x.Namespace
  2444  				yym9 := z.DecBinary()
  2445  				_ = yym9
  2446  				if false {
  2447  				} else {
  2448  					*((*string)(yyv8)) = r.DecodeString()
  2449  				}
  2450  			}
  2451  		case "AuthToken":
  2452  			if r.TryDecodeAsNil() {
  2453  				x.AuthToken = ""
  2454  			} else {
  2455  				yyv10 := &x.AuthToken
  2456  				yym11 := z.DecBinary()
  2457  				_ = yym11
  2458  				if false {
  2459  				} else {
  2460  					*((*string)(yyv10)) = r.DecodeString()
  2461  				}
  2462  			}
  2463  		case "Forwarded":
  2464  			if r.TryDecodeAsNil() {
  2465  				x.Forwarded = false
  2466  			} else {
  2467  				yyv12 := &x.Forwarded
  2468  				yym13 := z.DecBinary()
  2469  				_ = yym13
  2470  				if false {
  2471  				} else {
  2472  					*((*bool)(yyv12)) = r.DecodeBool()
  2473  				}
  2474  			}
  2475  		default:
  2476  			z.DecStructFieldNotFound(-1, yys3)
  2477  		} // end switch yys3
  2478  	} // end for yyj3
  2479  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  2480  }
  2481  
  2482  func (x *NodeDeregisterRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  2483  	var h codecSelfer100
  2484  	z, r := codec1978.GenHelperDecoder(d)
  2485  	_, _, _ = h, z, r
  2486  	var yyj14 int
  2487  	var yyb14 bool
  2488  	var yyhl14 bool = l >= 0
  2489  	yyj14++
  2490  	if yyhl14 {
  2491  		yyb14 = yyj14 > l
  2492  	} else {
  2493  		yyb14 = r.CheckBreak()
  2494  	}
  2495  	if yyb14 {
  2496  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2497  		return
  2498  	}
  2499  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2500  	if r.TryDecodeAsNil() {
  2501  		x.NodeID = ""
  2502  	} else {
  2503  		yyv15 := &x.NodeID
  2504  		yym16 := z.DecBinary()
  2505  		_ = yym16
  2506  		if false {
  2507  		} else {
  2508  			*((*string)(yyv15)) = r.DecodeString()
  2509  		}
  2510  	}
  2511  	yyj14++
  2512  	if yyhl14 {
  2513  		yyb14 = yyj14 > l
  2514  	} else {
  2515  		yyb14 = r.CheckBreak()
  2516  	}
  2517  	if yyb14 {
  2518  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2519  		return
  2520  	}
  2521  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2522  	if r.TryDecodeAsNil() {
  2523  		x.Region = ""
  2524  	} else {
  2525  		yyv17 := &x.Region
  2526  		yym18 := z.DecBinary()
  2527  		_ = yym18
  2528  		if false {
  2529  		} else {
  2530  			*((*string)(yyv17)) = r.DecodeString()
  2531  		}
  2532  	}
  2533  	yyj14++
  2534  	if yyhl14 {
  2535  		yyb14 = yyj14 > l
  2536  	} else {
  2537  		yyb14 = r.CheckBreak()
  2538  	}
  2539  	if yyb14 {
  2540  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2541  		return
  2542  	}
  2543  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2544  	if r.TryDecodeAsNil() {
  2545  		x.Namespace = ""
  2546  	} else {
  2547  		yyv19 := &x.Namespace
  2548  		yym20 := z.DecBinary()
  2549  		_ = yym20
  2550  		if false {
  2551  		} else {
  2552  			*((*string)(yyv19)) = r.DecodeString()
  2553  		}
  2554  	}
  2555  	yyj14++
  2556  	if yyhl14 {
  2557  		yyb14 = yyj14 > l
  2558  	} else {
  2559  		yyb14 = r.CheckBreak()
  2560  	}
  2561  	if yyb14 {
  2562  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2563  		return
  2564  	}
  2565  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2566  	if r.TryDecodeAsNil() {
  2567  		x.AuthToken = ""
  2568  	} else {
  2569  		yyv21 := &x.AuthToken
  2570  		yym22 := z.DecBinary()
  2571  		_ = yym22
  2572  		if false {
  2573  		} else {
  2574  			*((*string)(yyv21)) = r.DecodeString()
  2575  		}
  2576  	}
  2577  	yyj14++
  2578  	if yyhl14 {
  2579  		yyb14 = yyj14 > l
  2580  	} else {
  2581  		yyb14 = r.CheckBreak()
  2582  	}
  2583  	if yyb14 {
  2584  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2585  		return
  2586  	}
  2587  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2588  	if r.TryDecodeAsNil() {
  2589  		x.Forwarded = false
  2590  	} else {
  2591  		yyv23 := &x.Forwarded
  2592  		yym24 := z.DecBinary()
  2593  		_ = yym24
  2594  		if false {
  2595  		} else {
  2596  			*((*bool)(yyv23)) = r.DecodeBool()
  2597  		}
  2598  	}
  2599  	for {
  2600  		yyj14++
  2601  		if yyhl14 {
  2602  			yyb14 = yyj14 > l
  2603  		} else {
  2604  			yyb14 = r.CheckBreak()
  2605  		}
  2606  		if yyb14 {
  2607  			break
  2608  		}
  2609  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2610  		z.DecStructFieldNotFound(yyj14-1, "")
  2611  	}
  2612  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2613  }
  2614  
  2615  func (x *NodeServerInfo) CodecEncodeSelf(e *codec1978.Encoder) {
  2616  	var h codecSelfer100
  2617  	z, r := codec1978.GenHelperEncoder(e)
  2618  	_, _, _ = h, z, r
  2619  	if x == nil {
  2620  		r.EncodeNil()
  2621  	} else {
  2622  		yym1 := z.EncBinary()
  2623  		_ = yym1
  2624  		if false {
  2625  		} else if z.HasExtensions() && z.EncExt(x) {
  2626  		} else {
  2627  			yysep2 := !z.EncBinary()
  2628  			yy2arr2 := z.EncBasicHandle().StructToArray
  2629  			var yyq2 [4]bool
  2630  			_, _, _ = yysep2, yyq2, yy2arr2
  2631  			const yyr2 bool = false
  2632  			var yynn2 int
  2633  			if yyr2 || yy2arr2 {
  2634  				r.EncodeArrayStart(4)
  2635  			} else {
  2636  				yynn2 = 4
  2637  				for _, b := range yyq2 {
  2638  					if b {
  2639  						yynn2++
  2640  					}
  2641  				}
  2642  				r.EncodeMapStart(yynn2)
  2643  				yynn2 = 0
  2644  			}
  2645  			if yyr2 || yy2arr2 {
  2646  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  2647  				yym4 := z.EncBinary()
  2648  				_ = yym4
  2649  				if false {
  2650  				} else {
  2651  					r.EncodeString(codecSelferC_UTF8100, string(x.RPCAdvertiseAddr))
  2652  				}
  2653  			} else {
  2654  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  2655  				r.EncodeString(codecSelferC_UTF8100, string("RPCAdvertiseAddr"))
  2656  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  2657  				yym5 := z.EncBinary()
  2658  				_ = yym5
  2659  				if false {
  2660  				} else {
  2661  					r.EncodeString(codecSelferC_UTF8100, string(x.RPCAdvertiseAddr))
  2662  				}
  2663  			}
  2664  			if yyr2 || yy2arr2 {
  2665  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  2666  				yym7 := z.EncBinary()
  2667  				_ = yym7
  2668  				if false {
  2669  				} else {
  2670  					r.EncodeInt(int64(x.RPCMajorVersion))
  2671  				}
  2672  			} else {
  2673  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  2674  				r.EncodeString(codecSelferC_UTF8100, string("RPCMajorVersion"))
  2675  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  2676  				yym8 := z.EncBinary()
  2677  				_ = yym8
  2678  				if false {
  2679  				} else {
  2680  					r.EncodeInt(int64(x.RPCMajorVersion))
  2681  				}
  2682  			}
  2683  			if yyr2 || yy2arr2 {
  2684  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  2685  				yym10 := z.EncBinary()
  2686  				_ = yym10
  2687  				if false {
  2688  				} else {
  2689  					r.EncodeInt(int64(x.RPCMinorVersion))
  2690  				}
  2691  			} else {
  2692  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  2693  				r.EncodeString(codecSelferC_UTF8100, string("RPCMinorVersion"))
  2694  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  2695  				yym11 := z.EncBinary()
  2696  				_ = yym11
  2697  				if false {
  2698  				} else {
  2699  					r.EncodeInt(int64(x.RPCMinorVersion))
  2700  				}
  2701  			}
  2702  			if yyr2 || yy2arr2 {
  2703  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  2704  				yym13 := z.EncBinary()
  2705  				_ = yym13
  2706  				if false {
  2707  				} else {
  2708  					r.EncodeString(codecSelferC_UTF8100, string(x.Datacenter))
  2709  				}
  2710  			} else {
  2711  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  2712  				r.EncodeString(codecSelferC_UTF8100, string("Datacenter"))
  2713  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  2714  				yym14 := z.EncBinary()
  2715  				_ = yym14
  2716  				if false {
  2717  				} else {
  2718  					r.EncodeString(codecSelferC_UTF8100, string(x.Datacenter))
  2719  				}
  2720  			}
  2721  			if yyr2 || yy2arr2 {
  2722  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  2723  			} else {
  2724  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  2725  			}
  2726  		}
  2727  	}
  2728  }
  2729  
  2730  func (x *NodeServerInfo) CodecDecodeSelf(d *codec1978.Decoder) {
  2731  	var h codecSelfer100
  2732  	z, r := codec1978.GenHelperDecoder(d)
  2733  	_, _, _ = h, z, r
  2734  	yym1 := z.DecBinary()
  2735  	_ = yym1
  2736  	if false {
  2737  	} else if z.HasExtensions() && z.DecExt(x) {
  2738  	} else {
  2739  		yyct2 := r.ContainerType()
  2740  		if yyct2 == codecSelferValueTypeMap100 {
  2741  			yyl2 := r.ReadMapStart()
  2742  			if yyl2 == 0 {
  2743  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  2744  			} else {
  2745  				x.codecDecodeSelfFromMap(yyl2, d)
  2746  			}
  2747  		} else if yyct2 == codecSelferValueTypeArray100 {
  2748  			yyl2 := r.ReadArrayStart()
  2749  			if yyl2 == 0 {
  2750  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2751  			} else {
  2752  				x.codecDecodeSelfFromArray(yyl2, d)
  2753  			}
  2754  		} else {
  2755  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  2756  		}
  2757  	}
  2758  }
  2759  
  2760  func (x *NodeServerInfo) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  2761  	var h codecSelfer100
  2762  	z, r := codec1978.GenHelperDecoder(d)
  2763  	_, _, _ = h, z, r
  2764  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  2765  	_ = yys3Slc
  2766  	var yyhl3 bool = l >= 0
  2767  	for yyj3 := 0; ; yyj3++ {
  2768  		if yyhl3 {
  2769  			if yyj3 >= l {
  2770  				break
  2771  			}
  2772  		} else {
  2773  			if r.CheckBreak() {
  2774  				break
  2775  			}
  2776  		}
  2777  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  2778  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  2779  		yys3 := string(yys3Slc)
  2780  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  2781  		switch yys3 {
  2782  		case "RPCAdvertiseAddr":
  2783  			if r.TryDecodeAsNil() {
  2784  				x.RPCAdvertiseAddr = ""
  2785  			} else {
  2786  				yyv4 := &x.RPCAdvertiseAddr
  2787  				yym5 := z.DecBinary()
  2788  				_ = yym5
  2789  				if false {
  2790  				} else {
  2791  					*((*string)(yyv4)) = r.DecodeString()
  2792  				}
  2793  			}
  2794  		case "RPCMajorVersion":
  2795  			if r.TryDecodeAsNil() {
  2796  				x.RPCMajorVersion = 0
  2797  			} else {
  2798  				yyv6 := &x.RPCMajorVersion
  2799  				yym7 := z.DecBinary()
  2800  				_ = yym7
  2801  				if false {
  2802  				} else {
  2803  					*((*int32)(yyv6)) = int32(r.DecodeInt(32))
  2804  				}
  2805  			}
  2806  		case "RPCMinorVersion":
  2807  			if r.TryDecodeAsNil() {
  2808  				x.RPCMinorVersion = 0
  2809  			} else {
  2810  				yyv8 := &x.RPCMinorVersion
  2811  				yym9 := z.DecBinary()
  2812  				_ = yym9
  2813  				if false {
  2814  				} else {
  2815  					*((*int32)(yyv8)) = int32(r.DecodeInt(32))
  2816  				}
  2817  			}
  2818  		case "Datacenter":
  2819  			if r.TryDecodeAsNil() {
  2820  				x.Datacenter = ""
  2821  			} else {
  2822  				yyv10 := &x.Datacenter
  2823  				yym11 := z.DecBinary()
  2824  				_ = yym11
  2825  				if false {
  2826  				} else {
  2827  					*((*string)(yyv10)) = r.DecodeString()
  2828  				}
  2829  			}
  2830  		default:
  2831  			z.DecStructFieldNotFound(-1, yys3)
  2832  		} // end switch yys3
  2833  	} // end for yyj3
  2834  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  2835  }
  2836  
  2837  func (x *NodeServerInfo) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  2838  	var h codecSelfer100
  2839  	z, r := codec1978.GenHelperDecoder(d)
  2840  	_, _, _ = h, z, r
  2841  	var yyj12 int
  2842  	var yyb12 bool
  2843  	var yyhl12 bool = l >= 0
  2844  	yyj12++
  2845  	if yyhl12 {
  2846  		yyb12 = yyj12 > l
  2847  	} else {
  2848  		yyb12 = r.CheckBreak()
  2849  	}
  2850  	if yyb12 {
  2851  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2852  		return
  2853  	}
  2854  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2855  	if r.TryDecodeAsNil() {
  2856  		x.RPCAdvertiseAddr = ""
  2857  	} else {
  2858  		yyv13 := &x.RPCAdvertiseAddr
  2859  		yym14 := z.DecBinary()
  2860  		_ = yym14
  2861  		if false {
  2862  		} else {
  2863  			*((*string)(yyv13)) = r.DecodeString()
  2864  		}
  2865  	}
  2866  	yyj12++
  2867  	if yyhl12 {
  2868  		yyb12 = yyj12 > l
  2869  	} else {
  2870  		yyb12 = r.CheckBreak()
  2871  	}
  2872  	if yyb12 {
  2873  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2874  		return
  2875  	}
  2876  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2877  	if r.TryDecodeAsNil() {
  2878  		x.RPCMajorVersion = 0
  2879  	} else {
  2880  		yyv15 := &x.RPCMajorVersion
  2881  		yym16 := z.DecBinary()
  2882  		_ = yym16
  2883  		if false {
  2884  		} else {
  2885  			*((*int32)(yyv15)) = int32(r.DecodeInt(32))
  2886  		}
  2887  	}
  2888  	yyj12++
  2889  	if yyhl12 {
  2890  		yyb12 = yyj12 > l
  2891  	} else {
  2892  		yyb12 = r.CheckBreak()
  2893  	}
  2894  	if yyb12 {
  2895  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2896  		return
  2897  	}
  2898  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2899  	if r.TryDecodeAsNil() {
  2900  		x.RPCMinorVersion = 0
  2901  	} else {
  2902  		yyv17 := &x.RPCMinorVersion
  2903  		yym18 := z.DecBinary()
  2904  		_ = yym18
  2905  		if false {
  2906  		} else {
  2907  			*((*int32)(yyv17)) = int32(r.DecodeInt(32))
  2908  		}
  2909  	}
  2910  	yyj12++
  2911  	if yyhl12 {
  2912  		yyb12 = yyj12 > l
  2913  	} else {
  2914  		yyb12 = r.CheckBreak()
  2915  	}
  2916  	if yyb12 {
  2917  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2918  		return
  2919  	}
  2920  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2921  	if r.TryDecodeAsNil() {
  2922  		x.Datacenter = ""
  2923  	} else {
  2924  		yyv19 := &x.Datacenter
  2925  		yym20 := z.DecBinary()
  2926  		_ = yym20
  2927  		if false {
  2928  		} else {
  2929  			*((*string)(yyv19)) = r.DecodeString()
  2930  		}
  2931  	}
  2932  	for {
  2933  		yyj12++
  2934  		if yyhl12 {
  2935  			yyb12 = yyj12 > l
  2936  		} else {
  2937  			yyb12 = r.CheckBreak()
  2938  		}
  2939  		if yyb12 {
  2940  			break
  2941  		}
  2942  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  2943  		z.DecStructFieldNotFound(yyj12-1, "")
  2944  	}
  2945  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  2946  }
  2947  
  2948  func (x *NodeUpdateStatusRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  2949  	var h codecSelfer100
  2950  	z, r := codec1978.GenHelperEncoder(e)
  2951  	_, _, _ = h, z, r
  2952  	if x == nil {
  2953  		r.EncodeNil()
  2954  	} else {
  2955  		yym1 := z.EncBinary()
  2956  		_ = yym1
  2957  		if false {
  2958  		} else if z.HasExtensions() && z.EncExt(x) {
  2959  		} else {
  2960  			yysep2 := !z.EncBinary()
  2961  			yy2arr2 := z.EncBasicHandle().StructToArray
  2962  			var yyq2 [6]bool
  2963  			_, _, _ = yysep2, yyq2, yy2arr2
  2964  			const yyr2 bool = false
  2965  			var yynn2 int
  2966  			if yyr2 || yy2arr2 {
  2967  				r.EncodeArrayStart(6)
  2968  			} else {
  2969  				yynn2 = 6
  2970  				for _, b := range yyq2 {
  2971  					if b {
  2972  						yynn2++
  2973  					}
  2974  				}
  2975  				r.EncodeMapStart(yynn2)
  2976  				yynn2 = 0
  2977  			}
  2978  			if yyr2 || yy2arr2 {
  2979  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  2980  				yym4 := z.EncBinary()
  2981  				_ = yym4
  2982  				if false {
  2983  				} else {
  2984  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
  2985  				}
  2986  			} else {
  2987  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  2988  				r.EncodeString(codecSelferC_UTF8100, string("NodeID"))
  2989  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  2990  				yym5 := z.EncBinary()
  2991  				_ = yym5
  2992  				if false {
  2993  				} else {
  2994  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
  2995  				}
  2996  			}
  2997  			if yyr2 || yy2arr2 {
  2998  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  2999  				yym7 := z.EncBinary()
  3000  				_ = yym7
  3001  				if false {
  3002  				} else {
  3003  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
  3004  				}
  3005  			} else {
  3006  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  3007  				r.EncodeString(codecSelferC_UTF8100, string("Status"))
  3008  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  3009  				yym8 := z.EncBinary()
  3010  				_ = yym8
  3011  				if false {
  3012  				} else {
  3013  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
  3014  				}
  3015  			}
  3016  			if yyr2 || yy2arr2 {
  3017  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  3018  				yym10 := z.EncBinary()
  3019  				_ = yym10
  3020  				if false {
  3021  				} else {
  3022  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  3023  				}
  3024  			} else {
  3025  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  3026  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  3027  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  3028  				yym11 := z.EncBinary()
  3029  				_ = yym11
  3030  				if false {
  3031  				} else {
  3032  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  3033  				}
  3034  			}
  3035  			if yyr2 || yy2arr2 {
  3036  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  3037  				yym13 := z.EncBinary()
  3038  				_ = yym13
  3039  				if false {
  3040  				} else {
  3041  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  3042  				}
  3043  			} else {
  3044  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  3045  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  3046  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  3047  				yym14 := z.EncBinary()
  3048  				_ = yym14
  3049  				if false {
  3050  				} else {
  3051  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  3052  				}
  3053  			}
  3054  			if yyr2 || yy2arr2 {
  3055  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  3056  				yym16 := z.EncBinary()
  3057  				_ = yym16
  3058  				if false {
  3059  				} else {
  3060  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  3061  				}
  3062  			} else {
  3063  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  3064  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  3065  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  3066  				yym17 := z.EncBinary()
  3067  				_ = yym17
  3068  				if false {
  3069  				} else {
  3070  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  3071  				}
  3072  			}
  3073  			if yyr2 || yy2arr2 {
  3074  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  3075  				yym19 := z.EncBinary()
  3076  				_ = yym19
  3077  				if false {
  3078  				} else {
  3079  					r.EncodeBool(bool(x.Forwarded))
  3080  				}
  3081  			} else {
  3082  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  3083  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  3084  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  3085  				yym20 := z.EncBinary()
  3086  				_ = yym20
  3087  				if false {
  3088  				} else {
  3089  					r.EncodeBool(bool(x.Forwarded))
  3090  				}
  3091  			}
  3092  			if yyr2 || yy2arr2 {
  3093  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  3094  			} else {
  3095  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  3096  			}
  3097  		}
  3098  	}
  3099  }
  3100  
  3101  func (x *NodeUpdateStatusRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  3102  	var h codecSelfer100
  3103  	z, r := codec1978.GenHelperDecoder(d)
  3104  	_, _, _ = h, z, r
  3105  	yym1 := z.DecBinary()
  3106  	_ = yym1
  3107  	if false {
  3108  	} else if z.HasExtensions() && z.DecExt(x) {
  3109  	} else {
  3110  		yyct2 := r.ContainerType()
  3111  		if yyct2 == codecSelferValueTypeMap100 {
  3112  			yyl2 := r.ReadMapStart()
  3113  			if yyl2 == 0 {
  3114  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  3115  			} else {
  3116  				x.codecDecodeSelfFromMap(yyl2, d)
  3117  			}
  3118  		} else if yyct2 == codecSelferValueTypeArray100 {
  3119  			yyl2 := r.ReadArrayStart()
  3120  			if yyl2 == 0 {
  3121  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3122  			} else {
  3123  				x.codecDecodeSelfFromArray(yyl2, d)
  3124  			}
  3125  		} else {
  3126  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  3127  		}
  3128  	}
  3129  }
  3130  
  3131  func (x *NodeUpdateStatusRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  3132  	var h codecSelfer100
  3133  	z, r := codec1978.GenHelperDecoder(d)
  3134  	_, _, _ = h, z, r
  3135  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  3136  	_ = yys3Slc
  3137  	var yyhl3 bool = l >= 0
  3138  	for yyj3 := 0; ; yyj3++ {
  3139  		if yyhl3 {
  3140  			if yyj3 >= l {
  3141  				break
  3142  			}
  3143  		} else {
  3144  			if r.CheckBreak() {
  3145  				break
  3146  			}
  3147  		}
  3148  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  3149  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  3150  		yys3 := string(yys3Slc)
  3151  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  3152  		switch yys3 {
  3153  		case "NodeID":
  3154  			if r.TryDecodeAsNil() {
  3155  				x.NodeID = ""
  3156  			} else {
  3157  				yyv4 := &x.NodeID
  3158  				yym5 := z.DecBinary()
  3159  				_ = yym5
  3160  				if false {
  3161  				} else {
  3162  					*((*string)(yyv4)) = r.DecodeString()
  3163  				}
  3164  			}
  3165  		case "Status":
  3166  			if r.TryDecodeAsNil() {
  3167  				x.Status = ""
  3168  			} else {
  3169  				yyv6 := &x.Status
  3170  				yym7 := z.DecBinary()
  3171  				_ = yym7
  3172  				if false {
  3173  				} else {
  3174  					*((*string)(yyv6)) = r.DecodeString()
  3175  				}
  3176  			}
  3177  		case "Region":
  3178  			if r.TryDecodeAsNil() {
  3179  				x.Region = ""
  3180  			} else {
  3181  				yyv8 := &x.Region
  3182  				yym9 := z.DecBinary()
  3183  				_ = yym9
  3184  				if false {
  3185  				} else {
  3186  					*((*string)(yyv8)) = r.DecodeString()
  3187  				}
  3188  			}
  3189  		case "Namespace":
  3190  			if r.TryDecodeAsNil() {
  3191  				x.Namespace = ""
  3192  			} else {
  3193  				yyv10 := &x.Namespace
  3194  				yym11 := z.DecBinary()
  3195  				_ = yym11
  3196  				if false {
  3197  				} else {
  3198  					*((*string)(yyv10)) = r.DecodeString()
  3199  				}
  3200  			}
  3201  		case "AuthToken":
  3202  			if r.TryDecodeAsNil() {
  3203  				x.AuthToken = ""
  3204  			} else {
  3205  				yyv12 := &x.AuthToken
  3206  				yym13 := z.DecBinary()
  3207  				_ = yym13
  3208  				if false {
  3209  				} else {
  3210  					*((*string)(yyv12)) = r.DecodeString()
  3211  				}
  3212  			}
  3213  		case "Forwarded":
  3214  			if r.TryDecodeAsNil() {
  3215  				x.Forwarded = false
  3216  			} else {
  3217  				yyv14 := &x.Forwarded
  3218  				yym15 := z.DecBinary()
  3219  				_ = yym15
  3220  				if false {
  3221  				} else {
  3222  					*((*bool)(yyv14)) = r.DecodeBool()
  3223  				}
  3224  			}
  3225  		default:
  3226  			z.DecStructFieldNotFound(-1, yys3)
  3227  		} // end switch yys3
  3228  	} // end for yyj3
  3229  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  3230  }
  3231  
  3232  func (x *NodeUpdateStatusRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  3233  	var h codecSelfer100
  3234  	z, r := codec1978.GenHelperDecoder(d)
  3235  	_, _, _ = h, z, r
  3236  	var yyj16 int
  3237  	var yyb16 bool
  3238  	var yyhl16 bool = l >= 0
  3239  	yyj16++
  3240  	if yyhl16 {
  3241  		yyb16 = yyj16 > l
  3242  	} else {
  3243  		yyb16 = r.CheckBreak()
  3244  	}
  3245  	if yyb16 {
  3246  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3247  		return
  3248  	}
  3249  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3250  	if r.TryDecodeAsNil() {
  3251  		x.NodeID = ""
  3252  	} else {
  3253  		yyv17 := &x.NodeID
  3254  		yym18 := z.DecBinary()
  3255  		_ = yym18
  3256  		if false {
  3257  		} else {
  3258  			*((*string)(yyv17)) = r.DecodeString()
  3259  		}
  3260  	}
  3261  	yyj16++
  3262  	if yyhl16 {
  3263  		yyb16 = yyj16 > l
  3264  	} else {
  3265  		yyb16 = r.CheckBreak()
  3266  	}
  3267  	if yyb16 {
  3268  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3269  		return
  3270  	}
  3271  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3272  	if r.TryDecodeAsNil() {
  3273  		x.Status = ""
  3274  	} else {
  3275  		yyv19 := &x.Status
  3276  		yym20 := z.DecBinary()
  3277  		_ = yym20
  3278  		if false {
  3279  		} else {
  3280  			*((*string)(yyv19)) = r.DecodeString()
  3281  		}
  3282  	}
  3283  	yyj16++
  3284  	if yyhl16 {
  3285  		yyb16 = yyj16 > l
  3286  	} else {
  3287  		yyb16 = r.CheckBreak()
  3288  	}
  3289  	if yyb16 {
  3290  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3291  		return
  3292  	}
  3293  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3294  	if r.TryDecodeAsNil() {
  3295  		x.Region = ""
  3296  	} else {
  3297  		yyv21 := &x.Region
  3298  		yym22 := z.DecBinary()
  3299  		_ = yym22
  3300  		if false {
  3301  		} else {
  3302  			*((*string)(yyv21)) = r.DecodeString()
  3303  		}
  3304  	}
  3305  	yyj16++
  3306  	if yyhl16 {
  3307  		yyb16 = yyj16 > l
  3308  	} else {
  3309  		yyb16 = r.CheckBreak()
  3310  	}
  3311  	if yyb16 {
  3312  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3313  		return
  3314  	}
  3315  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3316  	if r.TryDecodeAsNil() {
  3317  		x.Namespace = ""
  3318  	} else {
  3319  		yyv23 := &x.Namespace
  3320  		yym24 := z.DecBinary()
  3321  		_ = yym24
  3322  		if false {
  3323  		} else {
  3324  			*((*string)(yyv23)) = r.DecodeString()
  3325  		}
  3326  	}
  3327  	yyj16++
  3328  	if yyhl16 {
  3329  		yyb16 = yyj16 > l
  3330  	} else {
  3331  		yyb16 = r.CheckBreak()
  3332  	}
  3333  	if yyb16 {
  3334  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3335  		return
  3336  	}
  3337  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3338  	if r.TryDecodeAsNil() {
  3339  		x.AuthToken = ""
  3340  	} else {
  3341  		yyv25 := &x.AuthToken
  3342  		yym26 := z.DecBinary()
  3343  		_ = yym26
  3344  		if false {
  3345  		} else {
  3346  			*((*string)(yyv25)) = r.DecodeString()
  3347  		}
  3348  	}
  3349  	yyj16++
  3350  	if yyhl16 {
  3351  		yyb16 = yyj16 > l
  3352  	} else {
  3353  		yyb16 = r.CheckBreak()
  3354  	}
  3355  	if yyb16 {
  3356  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3357  		return
  3358  	}
  3359  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3360  	if r.TryDecodeAsNil() {
  3361  		x.Forwarded = false
  3362  	} else {
  3363  		yyv27 := &x.Forwarded
  3364  		yym28 := z.DecBinary()
  3365  		_ = yym28
  3366  		if false {
  3367  		} else {
  3368  			*((*bool)(yyv27)) = r.DecodeBool()
  3369  		}
  3370  	}
  3371  	for {
  3372  		yyj16++
  3373  		if yyhl16 {
  3374  			yyb16 = yyj16 > l
  3375  		} else {
  3376  			yyb16 = r.CheckBreak()
  3377  		}
  3378  		if yyb16 {
  3379  			break
  3380  		}
  3381  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3382  		z.DecStructFieldNotFound(yyj16-1, "")
  3383  	}
  3384  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3385  }
  3386  
  3387  func (x *NodeUpdateDrainRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  3388  	var h codecSelfer100
  3389  	z, r := codec1978.GenHelperEncoder(e)
  3390  	_, _, _ = h, z, r
  3391  	if x == nil {
  3392  		r.EncodeNil()
  3393  	} else {
  3394  		yym1 := z.EncBinary()
  3395  		_ = yym1
  3396  		if false {
  3397  		} else if z.HasExtensions() && z.EncExt(x) {
  3398  		} else {
  3399  			yysep2 := !z.EncBinary()
  3400  			yy2arr2 := z.EncBasicHandle().StructToArray
  3401  			var yyq2 [8]bool
  3402  			_, _, _ = yysep2, yyq2, yy2arr2
  3403  			const yyr2 bool = false
  3404  			var yynn2 int
  3405  			if yyr2 || yy2arr2 {
  3406  				r.EncodeArrayStart(8)
  3407  			} else {
  3408  				yynn2 = 8
  3409  				for _, b := range yyq2 {
  3410  					if b {
  3411  						yynn2++
  3412  					}
  3413  				}
  3414  				r.EncodeMapStart(yynn2)
  3415  				yynn2 = 0
  3416  			}
  3417  			if yyr2 || yy2arr2 {
  3418  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  3419  				yym4 := z.EncBinary()
  3420  				_ = yym4
  3421  				if false {
  3422  				} else {
  3423  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
  3424  				}
  3425  			} else {
  3426  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  3427  				r.EncodeString(codecSelferC_UTF8100, string("NodeID"))
  3428  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  3429  				yym5 := z.EncBinary()
  3430  				_ = yym5
  3431  				if false {
  3432  				} else {
  3433  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
  3434  				}
  3435  			}
  3436  			if yyr2 || yy2arr2 {
  3437  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  3438  				if x.DrainStrategy == nil {
  3439  					r.EncodeNil()
  3440  				} else {
  3441  					x.DrainStrategy.CodecEncodeSelf(e)
  3442  				}
  3443  			} else {
  3444  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  3445  				r.EncodeString(codecSelferC_UTF8100, string("DrainStrategy"))
  3446  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  3447  				if x.DrainStrategy == nil {
  3448  					r.EncodeNil()
  3449  				} else {
  3450  					x.DrainStrategy.CodecEncodeSelf(e)
  3451  				}
  3452  			}
  3453  			if yyr2 || yy2arr2 {
  3454  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  3455  				yym10 := z.EncBinary()
  3456  				_ = yym10
  3457  				if false {
  3458  				} else {
  3459  					r.EncodeBool(bool(x.Drain))
  3460  				}
  3461  			} else {
  3462  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  3463  				r.EncodeString(codecSelferC_UTF8100, string("Drain"))
  3464  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  3465  				yym11 := z.EncBinary()
  3466  				_ = yym11
  3467  				if false {
  3468  				} else {
  3469  					r.EncodeBool(bool(x.Drain))
  3470  				}
  3471  			}
  3472  			if yyr2 || yy2arr2 {
  3473  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  3474  				yym13 := z.EncBinary()
  3475  				_ = yym13
  3476  				if false {
  3477  				} else {
  3478  					r.EncodeBool(bool(x.MarkEligible))
  3479  				}
  3480  			} else {
  3481  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  3482  				r.EncodeString(codecSelferC_UTF8100, string("MarkEligible"))
  3483  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  3484  				yym14 := z.EncBinary()
  3485  				_ = yym14
  3486  				if false {
  3487  				} else {
  3488  					r.EncodeBool(bool(x.MarkEligible))
  3489  				}
  3490  			}
  3491  			if yyr2 || yy2arr2 {
  3492  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  3493  				yym16 := z.EncBinary()
  3494  				_ = yym16
  3495  				if false {
  3496  				} else {
  3497  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  3498  				}
  3499  			} else {
  3500  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  3501  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  3502  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  3503  				yym17 := z.EncBinary()
  3504  				_ = yym17
  3505  				if false {
  3506  				} else {
  3507  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  3508  				}
  3509  			}
  3510  			if yyr2 || yy2arr2 {
  3511  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  3512  				yym19 := z.EncBinary()
  3513  				_ = yym19
  3514  				if false {
  3515  				} else {
  3516  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  3517  				}
  3518  			} else {
  3519  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  3520  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  3521  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  3522  				yym20 := z.EncBinary()
  3523  				_ = yym20
  3524  				if false {
  3525  				} else {
  3526  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  3527  				}
  3528  			}
  3529  			if yyr2 || yy2arr2 {
  3530  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  3531  				yym22 := z.EncBinary()
  3532  				_ = yym22
  3533  				if false {
  3534  				} else {
  3535  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  3536  				}
  3537  			} else {
  3538  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  3539  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  3540  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  3541  				yym23 := z.EncBinary()
  3542  				_ = yym23
  3543  				if false {
  3544  				} else {
  3545  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  3546  				}
  3547  			}
  3548  			if yyr2 || yy2arr2 {
  3549  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  3550  				yym25 := z.EncBinary()
  3551  				_ = yym25
  3552  				if false {
  3553  				} else {
  3554  					r.EncodeBool(bool(x.Forwarded))
  3555  				}
  3556  			} else {
  3557  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  3558  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  3559  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  3560  				yym26 := z.EncBinary()
  3561  				_ = yym26
  3562  				if false {
  3563  				} else {
  3564  					r.EncodeBool(bool(x.Forwarded))
  3565  				}
  3566  			}
  3567  			if yyr2 || yy2arr2 {
  3568  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  3569  			} else {
  3570  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  3571  			}
  3572  		}
  3573  	}
  3574  }
  3575  
  3576  func (x *NodeUpdateDrainRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  3577  	var h codecSelfer100
  3578  	z, r := codec1978.GenHelperDecoder(d)
  3579  	_, _, _ = h, z, r
  3580  	yym1 := z.DecBinary()
  3581  	_ = yym1
  3582  	if false {
  3583  	} else if z.HasExtensions() && z.DecExt(x) {
  3584  	} else {
  3585  		yyct2 := r.ContainerType()
  3586  		if yyct2 == codecSelferValueTypeMap100 {
  3587  			yyl2 := r.ReadMapStart()
  3588  			if yyl2 == 0 {
  3589  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  3590  			} else {
  3591  				x.codecDecodeSelfFromMap(yyl2, d)
  3592  			}
  3593  		} else if yyct2 == codecSelferValueTypeArray100 {
  3594  			yyl2 := r.ReadArrayStart()
  3595  			if yyl2 == 0 {
  3596  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3597  			} else {
  3598  				x.codecDecodeSelfFromArray(yyl2, d)
  3599  			}
  3600  		} else {
  3601  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  3602  		}
  3603  	}
  3604  }
  3605  
  3606  func (x *NodeUpdateDrainRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  3607  	var h codecSelfer100
  3608  	z, r := codec1978.GenHelperDecoder(d)
  3609  	_, _, _ = h, z, r
  3610  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  3611  	_ = yys3Slc
  3612  	var yyhl3 bool = l >= 0
  3613  	for yyj3 := 0; ; yyj3++ {
  3614  		if yyhl3 {
  3615  			if yyj3 >= l {
  3616  				break
  3617  			}
  3618  		} else {
  3619  			if r.CheckBreak() {
  3620  				break
  3621  			}
  3622  		}
  3623  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  3624  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  3625  		yys3 := string(yys3Slc)
  3626  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  3627  		switch yys3 {
  3628  		case "NodeID":
  3629  			if r.TryDecodeAsNil() {
  3630  				x.NodeID = ""
  3631  			} else {
  3632  				yyv4 := &x.NodeID
  3633  				yym5 := z.DecBinary()
  3634  				_ = yym5
  3635  				if false {
  3636  				} else {
  3637  					*((*string)(yyv4)) = r.DecodeString()
  3638  				}
  3639  			}
  3640  		case "DrainStrategy":
  3641  			if r.TryDecodeAsNil() {
  3642  				if x.DrainStrategy != nil {
  3643  					x.DrainStrategy = nil
  3644  				}
  3645  			} else {
  3646  				if x.DrainStrategy == nil {
  3647  					x.DrainStrategy = new(DrainStrategy)
  3648  				}
  3649  				x.DrainStrategy.CodecDecodeSelf(d)
  3650  			}
  3651  		case "Drain":
  3652  			if r.TryDecodeAsNil() {
  3653  				x.Drain = false
  3654  			} else {
  3655  				yyv7 := &x.Drain
  3656  				yym8 := z.DecBinary()
  3657  				_ = yym8
  3658  				if false {
  3659  				} else {
  3660  					*((*bool)(yyv7)) = r.DecodeBool()
  3661  				}
  3662  			}
  3663  		case "MarkEligible":
  3664  			if r.TryDecodeAsNil() {
  3665  				x.MarkEligible = false
  3666  			} else {
  3667  				yyv9 := &x.MarkEligible
  3668  				yym10 := z.DecBinary()
  3669  				_ = yym10
  3670  				if false {
  3671  				} else {
  3672  					*((*bool)(yyv9)) = r.DecodeBool()
  3673  				}
  3674  			}
  3675  		case "Region":
  3676  			if r.TryDecodeAsNil() {
  3677  				x.Region = ""
  3678  			} else {
  3679  				yyv11 := &x.Region
  3680  				yym12 := z.DecBinary()
  3681  				_ = yym12
  3682  				if false {
  3683  				} else {
  3684  					*((*string)(yyv11)) = r.DecodeString()
  3685  				}
  3686  			}
  3687  		case "Namespace":
  3688  			if r.TryDecodeAsNil() {
  3689  				x.Namespace = ""
  3690  			} else {
  3691  				yyv13 := &x.Namespace
  3692  				yym14 := z.DecBinary()
  3693  				_ = yym14
  3694  				if false {
  3695  				} else {
  3696  					*((*string)(yyv13)) = r.DecodeString()
  3697  				}
  3698  			}
  3699  		case "AuthToken":
  3700  			if r.TryDecodeAsNil() {
  3701  				x.AuthToken = ""
  3702  			} else {
  3703  				yyv15 := &x.AuthToken
  3704  				yym16 := z.DecBinary()
  3705  				_ = yym16
  3706  				if false {
  3707  				} else {
  3708  					*((*string)(yyv15)) = r.DecodeString()
  3709  				}
  3710  			}
  3711  		case "Forwarded":
  3712  			if r.TryDecodeAsNil() {
  3713  				x.Forwarded = false
  3714  			} else {
  3715  				yyv17 := &x.Forwarded
  3716  				yym18 := z.DecBinary()
  3717  				_ = yym18
  3718  				if false {
  3719  				} else {
  3720  					*((*bool)(yyv17)) = r.DecodeBool()
  3721  				}
  3722  			}
  3723  		default:
  3724  			z.DecStructFieldNotFound(-1, yys3)
  3725  		} // end switch yys3
  3726  	} // end for yyj3
  3727  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  3728  }
  3729  
  3730  func (x *NodeUpdateDrainRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  3731  	var h codecSelfer100
  3732  	z, r := codec1978.GenHelperDecoder(d)
  3733  	_, _, _ = h, z, r
  3734  	var yyj19 int
  3735  	var yyb19 bool
  3736  	var yyhl19 bool = l >= 0
  3737  	yyj19++
  3738  	if yyhl19 {
  3739  		yyb19 = yyj19 > l
  3740  	} else {
  3741  		yyb19 = r.CheckBreak()
  3742  	}
  3743  	if yyb19 {
  3744  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3745  		return
  3746  	}
  3747  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3748  	if r.TryDecodeAsNil() {
  3749  		x.NodeID = ""
  3750  	} else {
  3751  		yyv20 := &x.NodeID
  3752  		yym21 := z.DecBinary()
  3753  		_ = yym21
  3754  		if false {
  3755  		} else {
  3756  			*((*string)(yyv20)) = r.DecodeString()
  3757  		}
  3758  	}
  3759  	yyj19++
  3760  	if yyhl19 {
  3761  		yyb19 = yyj19 > l
  3762  	} else {
  3763  		yyb19 = r.CheckBreak()
  3764  	}
  3765  	if yyb19 {
  3766  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3767  		return
  3768  	}
  3769  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3770  	if r.TryDecodeAsNil() {
  3771  		if x.DrainStrategy != nil {
  3772  			x.DrainStrategy = nil
  3773  		}
  3774  	} else {
  3775  		if x.DrainStrategy == nil {
  3776  			x.DrainStrategy = new(DrainStrategy)
  3777  		}
  3778  		x.DrainStrategy.CodecDecodeSelf(d)
  3779  	}
  3780  	yyj19++
  3781  	if yyhl19 {
  3782  		yyb19 = yyj19 > l
  3783  	} else {
  3784  		yyb19 = r.CheckBreak()
  3785  	}
  3786  	if yyb19 {
  3787  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3788  		return
  3789  	}
  3790  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3791  	if r.TryDecodeAsNil() {
  3792  		x.Drain = false
  3793  	} else {
  3794  		yyv23 := &x.Drain
  3795  		yym24 := z.DecBinary()
  3796  		_ = yym24
  3797  		if false {
  3798  		} else {
  3799  			*((*bool)(yyv23)) = r.DecodeBool()
  3800  		}
  3801  	}
  3802  	yyj19++
  3803  	if yyhl19 {
  3804  		yyb19 = yyj19 > l
  3805  	} else {
  3806  		yyb19 = r.CheckBreak()
  3807  	}
  3808  	if yyb19 {
  3809  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3810  		return
  3811  	}
  3812  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3813  	if r.TryDecodeAsNil() {
  3814  		x.MarkEligible = false
  3815  	} else {
  3816  		yyv25 := &x.MarkEligible
  3817  		yym26 := z.DecBinary()
  3818  		_ = yym26
  3819  		if false {
  3820  		} else {
  3821  			*((*bool)(yyv25)) = r.DecodeBool()
  3822  		}
  3823  	}
  3824  	yyj19++
  3825  	if yyhl19 {
  3826  		yyb19 = yyj19 > l
  3827  	} else {
  3828  		yyb19 = r.CheckBreak()
  3829  	}
  3830  	if yyb19 {
  3831  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3832  		return
  3833  	}
  3834  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3835  	if r.TryDecodeAsNil() {
  3836  		x.Region = ""
  3837  	} else {
  3838  		yyv27 := &x.Region
  3839  		yym28 := z.DecBinary()
  3840  		_ = yym28
  3841  		if false {
  3842  		} else {
  3843  			*((*string)(yyv27)) = r.DecodeString()
  3844  		}
  3845  	}
  3846  	yyj19++
  3847  	if yyhl19 {
  3848  		yyb19 = yyj19 > l
  3849  	} else {
  3850  		yyb19 = r.CheckBreak()
  3851  	}
  3852  	if yyb19 {
  3853  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3854  		return
  3855  	}
  3856  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3857  	if r.TryDecodeAsNil() {
  3858  		x.Namespace = ""
  3859  	} else {
  3860  		yyv29 := &x.Namespace
  3861  		yym30 := z.DecBinary()
  3862  		_ = yym30
  3863  		if false {
  3864  		} else {
  3865  			*((*string)(yyv29)) = r.DecodeString()
  3866  		}
  3867  	}
  3868  	yyj19++
  3869  	if yyhl19 {
  3870  		yyb19 = yyj19 > l
  3871  	} else {
  3872  		yyb19 = r.CheckBreak()
  3873  	}
  3874  	if yyb19 {
  3875  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3876  		return
  3877  	}
  3878  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3879  	if r.TryDecodeAsNil() {
  3880  		x.AuthToken = ""
  3881  	} else {
  3882  		yyv31 := &x.AuthToken
  3883  		yym32 := z.DecBinary()
  3884  		_ = yym32
  3885  		if false {
  3886  		} else {
  3887  			*((*string)(yyv31)) = r.DecodeString()
  3888  		}
  3889  	}
  3890  	yyj19++
  3891  	if yyhl19 {
  3892  		yyb19 = yyj19 > l
  3893  	} else {
  3894  		yyb19 = r.CheckBreak()
  3895  	}
  3896  	if yyb19 {
  3897  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3898  		return
  3899  	}
  3900  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3901  	if r.TryDecodeAsNil() {
  3902  		x.Forwarded = false
  3903  	} else {
  3904  		yyv33 := &x.Forwarded
  3905  		yym34 := z.DecBinary()
  3906  		_ = yym34
  3907  		if false {
  3908  		} else {
  3909  			*((*bool)(yyv33)) = r.DecodeBool()
  3910  		}
  3911  	}
  3912  	for {
  3913  		yyj19++
  3914  		if yyhl19 {
  3915  			yyb19 = yyj19 > l
  3916  		} else {
  3917  			yyb19 = r.CheckBreak()
  3918  		}
  3919  		if yyb19 {
  3920  			break
  3921  		}
  3922  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  3923  		z.DecStructFieldNotFound(yyj19-1, "")
  3924  	}
  3925  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  3926  }
  3927  
  3928  func (x *BatchNodeUpdateDrainRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  3929  	var h codecSelfer100
  3930  	z, r := codec1978.GenHelperEncoder(e)
  3931  	_, _, _ = h, z, r
  3932  	if x == nil {
  3933  		r.EncodeNil()
  3934  	} else {
  3935  		yym1 := z.EncBinary()
  3936  		_ = yym1
  3937  		if false {
  3938  		} else if z.HasExtensions() && z.EncExt(x) {
  3939  		} else {
  3940  			yysep2 := !z.EncBinary()
  3941  			yy2arr2 := z.EncBasicHandle().StructToArray
  3942  			var yyq2 [5]bool
  3943  			_, _, _ = yysep2, yyq2, yy2arr2
  3944  			const yyr2 bool = false
  3945  			var yynn2 int
  3946  			if yyr2 || yy2arr2 {
  3947  				r.EncodeArrayStart(5)
  3948  			} else {
  3949  				yynn2 = 5
  3950  				for _, b := range yyq2 {
  3951  					if b {
  3952  						yynn2++
  3953  					}
  3954  				}
  3955  				r.EncodeMapStart(yynn2)
  3956  				yynn2 = 0
  3957  			}
  3958  			if yyr2 || yy2arr2 {
  3959  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  3960  				if x.Updates == nil {
  3961  					r.EncodeNil()
  3962  				} else {
  3963  					yym4 := z.EncBinary()
  3964  					_ = yym4
  3965  					if false {
  3966  					} else {
  3967  						h.encMapstringPtrtoDrainUpdate((map[string]*DrainUpdate)(x.Updates), e)
  3968  					}
  3969  				}
  3970  			} else {
  3971  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  3972  				r.EncodeString(codecSelferC_UTF8100, string("Updates"))
  3973  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  3974  				if x.Updates == nil {
  3975  					r.EncodeNil()
  3976  				} else {
  3977  					yym5 := z.EncBinary()
  3978  					_ = yym5
  3979  					if false {
  3980  					} else {
  3981  						h.encMapstringPtrtoDrainUpdate((map[string]*DrainUpdate)(x.Updates), e)
  3982  					}
  3983  				}
  3984  			}
  3985  			if yyr2 || yy2arr2 {
  3986  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  3987  				yym7 := z.EncBinary()
  3988  				_ = yym7
  3989  				if false {
  3990  				} else {
  3991  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  3992  				}
  3993  			} else {
  3994  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  3995  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  3996  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  3997  				yym8 := z.EncBinary()
  3998  				_ = yym8
  3999  				if false {
  4000  				} else {
  4001  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  4002  				}
  4003  			}
  4004  			if yyr2 || yy2arr2 {
  4005  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  4006  				yym10 := z.EncBinary()
  4007  				_ = yym10
  4008  				if false {
  4009  				} else {
  4010  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  4011  				}
  4012  			} else {
  4013  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  4014  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  4015  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  4016  				yym11 := z.EncBinary()
  4017  				_ = yym11
  4018  				if false {
  4019  				} else {
  4020  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  4021  				}
  4022  			}
  4023  			if yyr2 || yy2arr2 {
  4024  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  4025  				yym13 := z.EncBinary()
  4026  				_ = yym13
  4027  				if false {
  4028  				} else {
  4029  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  4030  				}
  4031  			} else {
  4032  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  4033  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  4034  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  4035  				yym14 := z.EncBinary()
  4036  				_ = yym14
  4037  				if false {
  4038  				} else {
  4039  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  4040  				}
  4041  			}
  4042  			if yyr2 || yy2arr2 {
  4043  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  4044  				yym16 := z.EncBinary()
  4045  				_ = yym16
  4046  				if false {
  4047  				} else {
  4048  					r.EncodeBool(bool(x.Forwarded))
  4049  				}
  4050  			} else {
  4051  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  4052  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  4053  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  4054  				yym17 := z.EncBinary()
  4055  				_ = yym17
  4056  				if false {
  4057  				} else {
  4058  					r.EncodeBool(bool(x.Forwarded))
  4059  				}
  4060  			}
  4061  			if yyr2 || yy2arr2 {
  4062  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  4063  			} else {
  4064  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  4065  			}
  4066  		}
  4067  	}
  4068  }
  4069  
  4070  func (x *BatchNodeUpdateDrainRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  4071  	var h codecSelfer100
  4072  	z, r := codec1978.GenHelperDecoder(d)
  4073  	_, _, _ = h, z, r
  4074  	yym1 := z.DecBinary()
  4075  	_ = yym1
  4076  	if false {
  4077  	} else if z.HasExtensions() && z.DecExt(x) {
  4078  	} else {
  4079  		yyct2 := r.ContainerType()
  4080  		if yyct2 == codecSelferValueTypeMap100 {
  4081  			yyl2 := r.ReadMapStart()
  4082  			if yyl2 == 0 {
  4083  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  4084  			} else {
  4085  				x.codecDecodeSelfFromMap(yyl2, d)
  4086  			}
  4087  		} else if yyct2 == codecSelferValueTypeArray100 {
  4088  			yyl2 := r.ReadArrayStart()
  4089  			if yyl2 == 0 {
  4090  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4091  			} else {
  4092  				x.codecDecodeSelfFromArray(yyl2, d)
  4093  			}
  4094  		} else {
  4095  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  4096  		}
  4097  	}
  4098  }
  4099  
  4100  func (x *BatchNodeUpdateDrainRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  4101  	var h codecSelfer100
  4102  	z, r := codec1978.GenHelperDecoder(d)
  4103  	_, _, _ = h, z, r
  4104  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  4105  	_ = yys3Slc
  4106  	var yyhl3 bool = l >= 0
  4107  	for yyj3 := 0; ; yyj3++ {
  4108  		if yyhl3 {
  4109  			if yyj3 >= l {
  4110  				break
  4111  			}
  4112  		} else {
  4113  			if r.CheckBreak() {
  4114  				break
  4115  			}
  4116  		}
  4117  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  4118  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  4119  		yys3 := string(yys3Slc)
  4120  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  4121  		switch yys3 {
  4122  		case "Updates":
  4123  			if r.TryDecodeAsNil() {
  4124  				x.Updates = nil
  4125  			} else {
  4126  				yyv4 := &x.Updates
  4127  				yym5 := z.DecBinary()
  4128  				_ = yym5
  4129  				if false {
  4130  				} else {
  4131  					h.decMapstringPtrtoDrainUpdate((*map[string]*DrainUpdate)(yyv4), d)
  4132  				}
  4133  			}
  4134  		case "Region":
  4135  			if r.TryDecodeAsNil() {
  4136  				x.Region = ""
  4137  			} else {
  4138  				yyv6 := &x.Region
  4139  				yym7 := z.DecBinary()
  4140  				_ = yym7
  4141  				if false {
  4142  				} else {
  4143  					*((*string)(yyv6)) = r.DecodeString()
  4144  				}
  4145  			}
  4146  		case "Namespace":
  4147  			if r.TryDecodeAsNil() {
  4148  				x.Namespace = ""
  4149  			} else {
  4150  				yyv8 := &x.Namespace
  4151  				yym9 := z.DecBinary()
  4152  				_ = yym9
  4153  				if false {
  4154  				} else {
  4155  					*((*string)(yyv8)) = r.DecodeString()
  4156  				}
  4157  			}
  4158  		case "AuthToken":
  4159  			if r.TryDecodeAsNil() {
  4160  				x.AuthToken = ""
  4161  			} else {
  4162  				yyv10 := &x.AuthToken
  4163  				yym11 := z.DecBinary()
  4164  				_ = yym11
  4165  				if false {
  4166  				} else {
  4167  					*((*string)(yyv10)) = r.DecodeString()
  4168  				}
  4169  			}
  4170  		case "Forwarded":
  4171  			if r.TryDecodeAsNil() {
  4172  				x.Forwarded = false
  4173  			} else {
  4174  				yyv12 := &x.Forwarded
  4175  				yym13 := z.DecBinary()
  4176  				_ = yym13
  4177  				if false {
  4178  				} else {
  4179  					*((*bool)(yyv12)) = r.DecodeBool()
  4180  				}
  4181  			}
  4182  		default:
  4183  			z.DecStructFieldNotFound(-1, yys3)
  4184  		} // end switch yys3
  4185  	} // end for yyj3
  4186  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  4187  }
  4188  
  4189  func (x *BatchNodeUpdateDrainRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  4190  	var h codecSelfer100
  4191  	z, r := codec1978.GenHelperDecoder(d)
  4192  	_, _, _ = h, z, r
  4193  	var yyj14 int
  4194  	var yyb14 bool
  4195  	var yyhl14 bool = l >= 0
  4196  	yyj14++
  4197  	if yyhl14 {
  4198  		yyb14 = yyj14 > l
  4199  	} else {
  4200  		yyb14 = r.CheckBreak()
  4201  	}
  4202  	if yyb14 {
  4203  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4204  		return
  4205  	}
  4206  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4207  	if r.TryDecodeAsNil() {
  4208  		x.Updates = nil
  4209  	} else {
  4210  		yyv15 := &x.Updates
  4211  		yym16 := z.DecBinary()
  4212  		_ = yym16
  4213  		if false {
  4214  		} else {
  4215  			h.decMapstringPtrtoDrainUpdate((*map[string]*DrainUpdate)(yyv15), d)
  4216  		}
  4217  	}
  4218  	yyj14++
  4219  	if yyhl14 {
  4220  		yyb14 = yyj14 > l
  4221  	} else {
  4222  		yyb14 = r.CheckBreak()
  4223  	}
  4224  	if yyb14 {
  4225  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4226  		return
  4227  	}
  4228  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4229  	if r.TryDecodeAsNil() {
  4230  		x.Region = ""
  4231  	} else {
  4232  		yyv17 := &x.Region
  4233  		yym18 := z.DecBinary()
  4234  		_ = yym18
  4235  		if false {
  4236  		} else {
  4237  			*((*string)(yyv17)) = r.DecodeString()
  4238  		}
  4239  	}
  4240  	yyj14++
  4241  	if yyhl14 {
  4242  		yyb14 = yyj14 > l
  4243  	} else {
  4244  		yyb14 = r.CheckBreak()
  4245  	}
  4246  	if yyb14 {
  4247  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4248  		return
  4249  	}
  4250  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4251  	if r.TryDecodeAsNil() {
  4252  		x.Namespace = ""
  4253  	} else {
  4254  		yyv19 := &x.Namespace
  4255  		yym20 := z.DecBinary()
  4256  		_ = yym20
  4257  		if false {
  4258  		} else {
  4259  			*((*string)(yyv19)) = r.DecodeString()
  4260  		}
  4261  	}
  4262  	yyj14++
  4263  	if yyhl14 {
  4264  		yyb14 = yyj14 > l
  4265  	} else {
  4266  		yyb14 = r.CheckBreak()
  4267  	}
  4268  	if yyb14 {
  4269  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4270  		return
  4271  	}
  4272  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4273  	if r.TryDecodeAsNil() {
  4274  		x.AuthToken = ""
  4275  	} else {
  4276  		yyv21 := &x.AuthToken
  4277  		yym22 := z.DecBinary()
  4278  		_ = yym22
  4279  		if false {
  4280  		} else {
  4281  			*((*string)(yyv21)) = r.DecodeString()
  4282  		}
  4283  	}
  4284  	yyj14++
  4285  	if yyhl14 {
  4286  		yyb14 = yyj14 > l
  4287  	} else {
  4288  		yyb14 = r.CheckBreak()
  4289  	}
  4290  	if yyb14 {
  4291  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4292  		return
  4293  	}
  4294  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4295  	if r.TryDecodeAsNil() {
  4296  		x.Forwarded = false
  4297  	} else {
  4298  		yyv23 := &x.Forwarded
  4299  		yym24 := z.DecBinary()
  4300  		_ = yym24
  4301  		if false {
  4302  		} else {
  4303  			*((*bool)(yyv23)) = r.DecodeBool()
  4304  		}
  4305  	}
  4306  	for {
  4307  		yyj14++
  4308  		if yyhl14 {
  4309  			yyb14 = yyj14 > l
  4310  		} else {
  4311  			yyb14 = r.CheckBreak()
  4312  		}
  4313  		if yyb14 {
  4314  			break
  4315  		}
  4316  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4317  		z.DecStructFieldNotFound(yyj14-1, "")
  4318  	}
  4319  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4320  }
  4321  
  4322  func (x *DrainUpdate) CodecEncodeSelf(e *codec1978.Encoder) {
  4323  	var h codecSelfer100
  4324  	z, r := codec1978.GenHelperEncoder(e)
  4325  	_, _, _ = h, z, r
  4326  	if x == nil {
  4327  		r.EncodeNil()
  4328  	} else {
  4329  		yym1 := z.EncBinary()
  4330  		_ = yym1
  4331  		if false {
  4332  		} else if z.HasExtensions() && z.EncExt(x) {
  4333  		} else {
  4334  			yysep2 := !z.EncBinary()
  4335  			yy2arr2 := z.EncBasicHandle().StructToArray
  4336  			var yyq2 [2]bool
  4337  			_, _, _ = yysep2, yyq2, yy2arr2
  4338  			const yyr2 bool = false
  4339  			var yynn2 int
  4340  			if yyr2 || yy2arr2 {
  4341  				r.EncodeArrayStart(2)
  4342  			} else {
  4343  				yynn2 = 2
  4344  				for _, b := range yyq2 {
  4345  					if b {
  4346  						yynn2++
  4347  					}
  4348  				}
  4349  				r.EncodeMapStart(yynn2)
  4350  				yynn2 = 0
  4351  			}
  4352  			if yyr2 || yy2arr2 {
  4353  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  4354  				if x.DrainStrategy == nil {
  4355  					r.EncodeNil()
  4356  				} else {
  4357  					x.DrainStrategy.CodecEncodeSelf(e)
  4358  				}
  4359  			} else {
  4360  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  4361  				r.EncodeString(codecSelferC_UTF8100, string("DrainStrategy"))
  4362  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  4363  				if x.DrainStrategy == nil {
  4364  					r.EncodeNil()
  4365  				} else {
  4366  					x.DrainStrategy.CodecEncodeSelf(e)
  4367  				}
  4368  			}
  4369  			if yyr2 || yy2arr2 {
  4370  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  4371  				yym7 := z.EncBinary()
  4372  				_ = yym7
  4373  				if false {
  4374  				} else {
  4375  					r.EncodeBool(bool(x.MarkEligible))
  4376  				}
  4377  			} else {
  4378  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  4379  				r.EncodeString(codecSelferC_UTF8100, string("MarkEligible"))
  4380  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  4381  				yym8 := z.EncBinary()
  4382  				_ = yym8
  4383  				if false {
  4384  				} else {
  4385  					r.EncodeBool(bool(x.MarkEligible))
  4386  				}
  4387  			}
  4388  			if yyr2 || yy2arr2 {
  4389  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  4390  			} else {
  4391  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  4392  			}
  4393  		}
  4394  	}
  4395  }
  4396  
  4397  func (x *DrainUpdate) CodecDecodeSelf(d *codec1978.Decoder) {
  4398  	var h codecSelfer100
  4399  	z, r := codec1978.GenHelperDecoder(d)
  4400  	_, _, _ = h, z, r
  4401  	yym1 := z.DecBinary()
  4402  	_ = yym1
  4403  	if false {
  4404  	} else if z.HasExtensions() && z.DecExt(x) {
  4405  	} else {
  4406  		yyct2 := r.ContainerType()
  4407  		if yyct2 == codecSelferValueTypeMap100 {
  4408  			yyl2 := r.ReadMapStart()
  4409  			if yyl2 == 0 {
  4410  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  4411  			} else {
  4412  				x.codecDecodeSelfFromMap(yyl2, d)
  4413  			}
  4414  		} else if yyct2 == codecSelferValueTypeArray100 {
  4415  			yyl2 := r.ReadArrayStart()
  4416  			if yyl2 == 0 {
  4417  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4418  			} else {
  4419  				x.codecDecodeSelfFromArray(yyl2, d)
  4420  			}
  4421  		} else {
  4422  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  4423  		}
  4424  	}
  4425  }
  4426  
  4427  func (x *DrainUpdate) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  4428  	var h codecSelfer100
  4429  	z, r := codec1978.GenHelperDecoder(d)
  4430  	_, _, _ = h, z, r
  4431  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  4432  	_ = yys3Slc
  4433  	var yyhl3 bool = l >= 0
  4434  	for yyj3 := 0; ; yyj3++ {
  4435  		if yyhl3 {
  4436  			if yyj3 >= l {
  4437  				break
  4438  			}
  4439  		} else {
  4440  			if r.CheckBreak() {
  4441  				break
  4442  			}
  4443  		}
  4444  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  4445  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  4446  		yys3 := string(yys3Slc)
  4447  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  4448  		switch yys3 {
  4449  		case "DrainStrategy":
  4450  			if r.TryDecodeAsNil() {
  4451  				if x.DrainStrategy != nil {
  4452  					x.DrainStrategy = nil
  4453  				}
  4454  			} else {
  4455  				if x.DrainStrategy == nil {
  4456  					x.DrainStrategy = new(DrainStrategy)
  4457  				}
  4458  				x.DrainStrategy.CodecDecodeSelf(d)
  4459  			}
  4460  		case "MarkEligible":
  4461  			if r.TryDecodeAsNil() {
  4462  				x.MarkEligible = false
  4463  			} else {
  4464  				yyv5 := &x.MarkEligible
  4465  				yym6 := z.DecBinary()
  4466  				_ = yym6
  4467  				if false {
  4468  				} else {
  4469  					*((*bool)(yyv5)) = r.DecodeBool()
  4470  				}
  4471  			}
  4472  		default:
  4473  			z.DecStructFieldNotFound(-1, yys3)
  4474  		} // end switch yys3
  4475  	} // end for yyj3
  4476  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  4477  }
  4478  
  4479  func (x *DrainUpdate) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  4480  	var h codecSelfer100
  4481  	z, r := codec1978.GenHelperDecoder(d)
  4482  	_, _, _ = h, z, r
  4483  	var yyj7 int
  4484  	var yyb7 bool
  4485  	var yyhl7 bool = l >= 0
  4486  	yyj7++
  4487  	if yyhl7 {
  4488  		yyb7 = yyj7 > l
  4489  	} else {
  4490  		yyb7 = r.CheckBreak()
  4491  	}
  4492  	if yyb7 {
  4493  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4494  		return
  4495  	}
  4496  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4497  	if r.TryDecodeAsNil() {
  4498  		if x.DrainStrategy != nil {
  4499  			x.DrainStrategy = nil
  4500  		}
  4501  	} else {
  4502  		if x.DrainStrategy == nil {
  4503  			x.DrainStrategy = new(DrainStrategy)
  4504  		}
  4505  		x.DrainStrategy.CodecDecodeSelf(d)
  4506  	}
  4507  	yyj7++
  4508  	if yyhl7 {
  4509  		yyb7 = yyj7 > l
  4510  	} else {
  4511  		yyb7 = r.CheckBreak()
  4512  	}
  4513  	if yyb7 {
  4514  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4515  		return
  4516  	}
  4517  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4518  	if r.TryDecodeAsNil() {
  4519  		x.MarkEligible = false
  4520  	} else {
  4521  		yyv9 := &x.MarkEligible
  4522  		yym10 := z.DecBinary()
  4523  		_ = yym10
  4524  		if false {
  4525  		} else {
  4526  			*((*bool)(yyv9)) = r.DecodeBool()
  4527  		}
  4528  	}
  4529  	for {
  4530  		yyj7++
  4531  		if yyhl7 {
  4532  			yyb7 = yyj7 > l
  4533  		} else {
  4534  			yyb7 = r.CheckBreak()
  4535  		}
  4536  		if yyb7 {
  4537  			break
  4538  		}
  4539  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4540  		z.DecStructFieldNotFound(yyj7-1, "")
  4541  	}
  4542  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4543  }
  4544  
  4545  func (x *NodeUpdateEligibilityRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  4546  	var h codecSelfer100
  4547  	z, r := codec1978.GenHelperEncoder(e)
  4548  	_, _, _ = h, z, r
  4549  	if x == nil {
  4550  		r.EncodeNil()
  4551  	} else {
  4552  		yym1 := z.EncBinary()
  4553  		_ = yym1
  4554  		if false {
  4555  		} else if z.HasExtensions() && z.EncExt(x) {
  4556  		} else {
  4557  			yysep2 := !z.EncBinary()
  4558  			yy2arr2 := z.EncBasicHandle().StructToArray
  4559  			var yyq2 [6]bool
  4560  			_, _, _ = yysep2, yyq2, yy2arr2
  4561  			const yyr2 bool = false
  4562  			var yynn2 int
  4563  			if yyr2 || yy2arr2 {
  4564  				r.EncodeArrayStart(6)
  4565  			} else {
  4566  				yynn2 = 6
  4567  				for _, b := range yyq2 {
  4568  					if b {
  4569  						yynn2++
  4570  					}
  4571  				}
  4572  				r.EncodeMapStart(yynn2)
  4573  				yynn2 = 0
  4574  			}
  4575  			if yyr2 || yy2arr2 {
  4576  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  4577  				yym4 := z.EncBinary()
  4578  				_ = yym4
  4579  				if false {
  4580  				} else {
  4581  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
  4582  				}
  4583  			} else {
  4584  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  4585  				r.EncodeString(codecSelferC_UTF8100, string("NodeID"))
  4586  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  4587  				yym5 := z.EncBinary()
  4588  				_ = yym5
  4589  				if false {
  4590  				} else {
  4591  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
  4592  				}
  4593  			}
  4594  			if yyr2 || yy2arr2 {
  4595  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  4596  				yym7 := z.EncBinary()
  4597  				_ = yym7
  4598  				if false {
  4599  				} else {
  4600  					r.EncodeString(codecSelferC_UTF8100, string(x.Eligibility))
  4601  				}
  4602  			} else {
  4603  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  4604  				r.EncodeString(codecSelferC_UTF8100, string("Eligibility"))
  4605  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  4606  				yym8 := z.EncBinary()
  4607  				_ = yym8
  4608  				if false {
  4609  				} else {
  4610  					r.EncodeString(codecSelferC_UTF8100, string(x.Eligibility))
  4611  				}
  4612  			}
  4613  			if yyr2 || yy2arr2 {
  4614  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  4615  				yym10 := z.EncBinary()
  4616  				_ = yym10
  4617  				if false {
  4618  				} else {
  4619  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  4620  				}
  4621  			} else {
  4622  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  4623  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  4624  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  4625  				yym11 := z.EncBinary()
  4626  				_ = yym11
  4627  				if false {
  4628  				} else {
  4629  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  4630  				}
  4631  			}
  4632  			if yyr2 || yy2arr2 {
  4633  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  4634  				yym13 := z.EncBinary()
  4635  				_ = yym13
  4636  				if false {
  4637  				} else {
  4638  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  4639  				}
  4640  			} else {
  4641  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  4642  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  4643  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  4644  				yym14 := z.EncBinary()
  4645  				_ = yym14
  4646  				if false {
  4647  				} else {
  4648  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  4649  				}
  4650  			}
  4651  			if yyr2 || yy2arr2 {
  4652  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  4653  				yym16 := z.EncBinary()
  4654  				_ = yym16
  4655  				if false {
  4656  				} else {
  4657  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  4658  				}
  4659  			} else {
  4660  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  4661  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  4662  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  4663  				yym17 := z.EncBinary()
  4664  				_ = yym17
  4665  				if false {
  4666  				} else {
  4667  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  4668  				}
  4669  			}
  4670  			if yyr2 || yy2arr2 {
  4671  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  4672  				yym19 := z.EncBinary()
  4673  				_ = yym19
  4674  				if false {
  4675  				} else {
  4676  					r.EncodeBool(bool(x.Forwarded))
  4677  				}
  4678  			} else {
  4679  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  4680  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  4681  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  4682  				yym20 := z.EncBinary()
  4683  				_ = yym20
  4684  				if false {
  4685  				} else {
  4686  					r.EncodeBool(bool(x.Forwarded))
  4687  				}
  4688  			}
  4689  			if yyr2 || yy2arr2 {
  4690  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  4691  			} else {
  4692  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  4693  			}
  4694  		}
  4695  	}
  4696  }
  4697  
  4698  func (x *NodeUpdateEligibilityRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  4699  	var h codecSelfer100
  4700  	z, r := codec1978.GenHelperDecoder(d)
  4701  	_, _, _ = h, z, r
  4702  	yym1 := z.DecBinary()
  4703  	_ = yym1
  4704  	if false {
  4705  	} else if z.HasExtensions() && z.DecExt(x) {
  4706  	} else {
  4707  		yyct2 := r.ContainerType()
  4708  		if yyct2 == codecSelferValueTypeMap100 {
  4709  			yyl2 := r.ReadMapStart()
  4710  			if yyl2 == 0 {
  4711  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  4712  			} else {
  4713  				x.codecDecodeSelfFromMap(yyl2, d)
  4714  			}
  4715  		} else if yyct2 == codecSelferValueTypeArray100 {
  4716  			yyl2 := r.ReadArrayStart()
  4717  			if yyl2 == 0 {
  4718  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4719  			} else {
  4720  				x.codecDecodeSelfFromArray(yyl2, d)
  4721  			}
  4722  		} else {
  4723  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  4724  		}
  4725  	}
  4726  }
  4727  
  4728  func (x *NodeUpdateEligibilityRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  4729  	var h codecSelfer100
  4730  	z, r := codec1978.GenHelperDecoder(d)
  4731  	_, _, _ = h, z, r
  4732  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  4733  	_ = yys3Slc
  4734  	var yyhl3 bool = l >= 0
  4735  	for yyj3 := 0; ; yyj3++ {
  4736  		if yyhl3 {
  4737  			if yyj3 >= l {
  4738  				break
  4739  			}
  4740  		} else {
  4741  			if r.CheckBreak() {
  4742  				break
  4743  			}
  4744  		}
  4745  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  4746  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  4747  		yys3 := string(yys3Slc)
  4748  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  4749  		switch yys3 {
  4750  		case "NodeID":
  4751  			if r.TryDecodeAsNil() {
  4752  				x.NodeID = ""
  4753  			} else {
  4754  				yyv4 := &x.NodeID
  4755  				yym5 := z.DecBinary()
  4756  				_ = yym5
  4757  				if false {
  4758  				} else {
  4759  					*((*string)(yyv4)) = r.DecodeString()
  4760  				}
  4761  			}
  4762  		case "Eligibility":
  4763  			if r.TryDecodeAsNil() {
  4764  				x.Eligibility = ""
  4765  			} else {
  4766  				yyv6 := &x.Eligibility
  4767  				yym7 := z.DecBinary()
  4768  				_ = yym7
  4769  				if false {
  4770  				} else {
  4771  					*((*string)(yyv6)) = r.DecodeString()
  4772  				}
  4773  			}
  4774  		case "Region":
  4775  			if r.TryDecodeAsNil() {
  4776  				x.Region = ""
  4777  			} else {
  4778  				yyv8 := &x.Region
  4779  				yym9 := z.DecBinary()
  4780  				_ = yym9
  4781  				if false {
  4782  				} else {
  4783  					*((*string)(yyv8)) = r.DecodeString()
  4784  				}
  4785  			}
  4786  		case "Namespace":
  4787  			if r.TryDecodeAsNil() {
  4788  				x.Namespace = ""
  4789  			} else {
  4790  				yyv10 := &x.Namespace
  4791  				yym11 := z.DecBinary()
  4792  				_ = yym11
  4793  				if false {
  4794  				} else {
  4795  					*((*string)(yyv10)) = r.DecodeString()
  4796  				}
  4797  			}
  4798  		case "AuthToken":
  4799  			if r.TryDecodeAsNil() {
  4800  				x.AuthToken = ""
  4801  			} else {
  4802  				yyv12 := &x.AuthToken
  4803  				yym13 := z.DecBinary()
  4804  				_ = yym13
  4805  				if false {
  4806  				} else {
  4807  					*((*string)(yyv12)) = r.DecodeString()
  4808  				}
  4809  			}
  4810  		case "Forwarded":
  4811  			if r.TryDecodeAsNil() {
  4812  				x.Forwarded = false
  4813  			} else {
  4814  				yyv14 := &x.Forwarded
  4815  				yym15 := z.DecBinary()
  4816  				_ = yym15
  4817  				if false {
  4818  				} else {
  4819  					*((*bool)(yyv14)) = r.DecodeBool()
  4820  				}
  4821  			}
  4822  		default:
  4823  			z.DecStructFieldNotFound(-1, yys3)
  4824  		} // end switch yys3
  4825  	} // end for yyj3
  4826  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  4827  }
  4828  
  4829  func (x *NodeUpdateEligibilityRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  4830  	var h codecSelfer100
  4831  	z, r := codec1978.GenHelperDecoder(d)
  4832  	_, _, _ = h, z, r
  4833  	var yyj16 int
  4834  	var yyb16 bool
  4835  	var yyhl16 bool = l >= 0
  4836  	yyj16++
  4837  	if yyhl16 {
  4838  		yyb16 = yyj16 > l
  4839  	} else {
  4840  		yyb16 = r.CheckBreak()
  4841  	}
  4842  	if yyb16 {
  4843  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4844  		return
  4845  	}
  4846  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4847  	if r.TryDecodeAsNil() {
  4848  		x.NodeID = ""
  4849  	} else {
  4850  		yyv17 := &x.NodeID
  4851  		yym18 := z.DecBinary()
  4852  		_ = yym18
  4853  		if false {
  4854  		} else {
  4855  			*((*string)(yyv17)) = r.DecodeString()
  4856  		}
  4857  	}
  4858  	yyj16++
  4859  	if yyhl16 {
  4860  		yyb16 = yyj16 > l
  4861  	} else {
  4862  		yyb16 = r.CheckBreak()
  4863  	}
  4864  	if yyb16 {
  4865  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4866  		return
  4867  	}
  4868  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4869  	if r.TryDecodeAsNil() {
  4870  		x.Eligibility = ""
  4871  	} else {
  4872  		yyv19 := &x.Eligibility
  4873  		yym20 := z.DecBinary()
  4874  		_ = yym20
  4875  		if false {
  4876  		} else {
  4877  			*((*string)(yyv19)) = r.DecodeString()
  4878  		}
  4879  	}
  4880  	yyj16++
  4881  	if yyhl16 {
  4882  		yyb16 = yyj16 > l
  4883  	} else {
  4884  		yyb16 = r.CheckBreak()
  4885  	}
  4886  	if yyb16 {
  4887  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4888  		return
  4889  	}
  4890  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4891  	if r.TryDecodeAsNil() {
  4892  		x.Region = ""
  4893  	} else {
  4894  		yyv21 := &x.Region
  4895  		yym22 := z.DecBinary()
  4896  		_ = yym22
  4897  		if false {
  4898  		} else {
  4899  			*((*string)(yyv21)) = r.DecodeString()
  4900  		}
  4901  	}
  4902  	yyj16++
  4903  	if yyhl16 {
  4904  		yyb16 = yyj16 > l
  4905  	} else {
  4906  		yyb16 = r.CheckBreak()
  4907  	}
  4908  	if yyb16 {
  4909  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4910  		return
  4911  	}
  4912  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4913  	if r.TryDecodeAsNil() {
  4914  		x.Namespace = ""
  4915  	} else {
  4916  		yyv23 := &x.Namespace
  4917  		yym24 := z.DecBinary()
  4918  		_ = yym24
  4919  		if false {
  4920  		} else {
  4921  			*((*string)(yyv23)) = r.DecodeString()
  4922  		}
  4923  	}
  4924  	yyj16++
  4925  	if yyhl16 {
  4926  		yyb16 = yyj16 > l
  4927  	} else {
  4928  		yyb16 = r.CheckBreak()
  4929  	}
  4930  	if yyb16 {
  4931  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4932  		return
  4933  	}
  4934  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4935  	if r.TryDecodeAsNil() {
  4936  		x.AuthToken = ""
  4937  	} else {
  4938  		yyv25 := &x.AuthToken
  4939  		yym26 := z.DecBinary()
  4940  		_ = yym26
  4941  		if false {
  4942  		} else {
  4943  			*((*string)(yyv25)) = r.DecodeString()
  4944  		}
  4945  	}
  4946  	yyj16++
  4947  	if yyhl16 {
  4948  		yyb16 = yyj16 > l
  4949  	} else {
  4950  		yyb16 = r.CheckBreak()
  4951  	}
  4952  	if yyb16 {
  4953  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4954  		return
  4955  	}
  4956  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4957  	if r.TryDecodeAsNil() {
  4958  		x.Forwarded = false
  4959  	} else {
  4960  		yyv27 := &x.Forwarded
  4961  		yym28 := z.DecBinary()
  4962  		_ = yym28
  4963  		if false {
  4964  		} else {
  4965  			*((*bool)(yyv27)) = r.DecodeBool()
  4966  		}
  4967  	}
  4968  	for {
  4969  		yyj16++
  4970  		if yyhl16 {
  4971  			yyb16 = yyj16 > l
  4972  		} else {
  4973  			yyb16 = r.CheckBreak()
  4974  		}
  4975  		if yyb16 {
  4976  			break
  4977  		}
  4978  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  4979  		z.DecStructFieldNotFound(yyj16-1, "")
  4980  	}
  4981  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  4982  }
  4983  
  4984  func (x *NodeEvaluateRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  4985  	var h codecSelfer100
  4986  	z, r := codec1978.GenHelperEncoder(e)
  4987  	_, _, _ = h, z, r
  4988  	if x == nil {
  4989  		r.EncodeNil()
  4990  	} else {
  4991  		yym1 := z.EncBinary()
  4992  		_ = yym1
  4993  		if false {
  4994  		} else if z.HasExtensions() && z.EncExt(x) {
  4995  		} else {
  4996  			yysep2 := !z.EncBinary()
  4997  			yy2arr2 := z.EncBasicHandle().StructToArray
  4998  			var yyq2 [5]bool
  4999  			_, _, _ = yysep2, yyq2, yy2arr2
  5000  			const yyr2 bool = false
  5001  			var yynn2 int
  5002  			if yyr2 || yy2arr2 {
  5003  				r.EncodeArrayStart(5)
  5004  			} else {
  5005  				yynn2 = 5
  5006  				for _, b := range yyq2 {
  5007  					if b {
  5008  						yynn2++
  5009  					}
  5010  				}
  5011  				r.EncodeMapStart(yynn2)
  5012  				yynn2 = 0
  5013  			}
  5014  			if yyr2 || yy2arr2 {
  5015  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  5016  				yym4 := z.EncBinary()
  5017  				_ = yym4
  5018  				if false {
  5019  				} else {
  5020  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
  5021  				}
  5022  			} else {
  5023  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  5024  				r.EncodeString(codecSelferC_UTF8100, string("NodeID"))
  5025  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  5026  				yym5 := z.EncBinary()
  5027  				_ = yym5
  5028  				if false {
  5029  				} else {
  5030  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
  5031  				}
  5032  			}
  5033  			if yyr2 || yy2arr2 {
  5034  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  5035  				yym7 := z.EncBinary()
  5036  				_ = yym7
  5037  				if false {
  5038  				} else {
  5039  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  5040  				}
  5041  			} else {
  5042  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  5043  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  5044  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  5045  				yym8 := z.EncBinary()
  5046  				_ = yym8
  5047  				if false {
  5048  				} else {
  5049  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  5050  				}
  5051  			}
  5052  			if yyr2 || yy2arr2 {
  5053  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  5054  				yym10 := z.EncBinary()
  5055  				_ = yym10
  5056  				if false {
  5057  				} else {
  5058  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  5059  				}
  5060  			} else {
  5061  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  5062  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  5063  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  5064  				yym11 := z.EncBinary()
  5065  				_ = yym11
  5066  				if false {
  5067  				} else {
  5068  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  5069  				}
  5070  			}
  5071  			if yyr2 || yy2arr2 {
  5072  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  5073  				yym13 := z.EncBinary()
  5074  				_ = yym13
  5075  				if false {
  5076  				} else {
  5077  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  5078  				}
  5079  			} else {
  5080  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  5081  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  5082  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  5083  				yym14 := z.EncBinary()
  5084  				_ = yym14
  5085  				if false {
  5086  				} else {
  5087  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  5088  				}
  5089  			}
  5090  			if yyr2 || yy2arr2 {
  5091  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  5092  				yym16 := z.EncBinary()
  5093  				_ = yym16
  5094  				if false {
  5095  				} else {
  5096  					r.EncodeBool(bool(x.Forwarded))
  5097  				}
  5098  			} else {
  5099  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  5100  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  5101  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  5102  				yym17 := z.EncBinary()
  5103  				_ = yym17
  5104  				if false {
  5105  				} else {
  5106  					r.EncodeBool(bool(x.Forwarded))
  5107  				}
  5108  			}
  5109  			if yyr2 || yy2arr2 {
  5110  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  5111  			} else {
  5112  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  5113  			}
  5114  		}
  5115  	}
  5116  }
  5117  
  5118  func (x *NodeEvaluateRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  5119  	var h codecSelfer100
  5120  	z, r := codec1978.GenHelperDecoder(d)
  5121  	_, _, _ = h, z, r
  5122  	yym1 := z.DecBinary()
  5123  	_ = yym1
  5124  	if false {
  5125  	} else if z.HasExtensions() && z.DecExt(x) {
  5126  	} else {
  5127  		yyct2 := r.ContainerType()
  5128  		if yyct2 == codecSelferValueTypeMap100 {
  5129  			yyl2 := r.ReadMapStart()
  5130  			if yyl2 == 0 {
  5131  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  5132  			} else {
  5133  				x.codecDecodeSelfFromMap(yyl2, d)
  5134  			}
  5135  		} else if yyct2 == codecSelferValueTypeArray100 {
  5136  			yyl2 := r.ReadArrayStart()
  5137  			if yyl2 == 0 {
  5138  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5139  			} else {
  5140  				x.codecDecodeSelfFromArray(yyl2, d)
  5141  			}
  5142  		} else {
  5143  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  5144  		}
  5145  	}
  5146  }
  5147  
  5148  func (x *NodeEvaluateRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  5149  	var h codecSelfer100
  5150  	z, r := codec1978.GenHelperDecoder(d)
  5151  	_, _, _ = h, z, r
  5152  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  5153  	_ = yys3Slc
  5154  	var yyhl3 bool = l >= 0
  5155  	for yyj3 := 0; ; yyj3++ {
  5156  		if yyhl3 {
  5157  			if yyj3 >= l {
  5158  				break
  5159  			}
  5160  		} else {
  5161  			if r.CheckBreak() {
  5162  				break
  5163  			}
  5164  		}
  5165  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  5166  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  5167  		yys3 := string(yys3Slc)
  5168  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  5169  		switch yys3 {
  5170  		case "NodeID":
  5171  			if r.TryDecodeAsNil() {
  5172  				x.NodeID = ""
  5173  			} else {
  5174  				yyv4 := &x.NodeID
  5175  				yym5 := z.DecBinary()
  5176  				_ = yym5
  5177  				if false {
  5178  				} else {
  5179  					*((*string)(yyv4)) = r.DecodeString()
  5180  				}
  5181  			}
  5182  		case "Region":
  5183  			if r.TryDecodeAsNil() {
  5184  				x.Region = ""
  5185  			} else {
  5186  				yyv6 := &x.Region
  5187  				yym7 := z.DecBinary()
  5188  				_ = yym7
  5189  				if false {
  5190  				} else {
  5191  					*((*string)(yyv6)) = r.DecodeString()
  5192  				}
  5193  			}
  5194  		case "Namespace":
  5195  			if r.TryDecodeAsNil() {
  5196  				x.Namespace = ""
  5197  			} else {
  5198  				yyv8 := &x.Namespace
  5199  				yym9 := z.DecBinary()
  5200  				_ = yym9
  5201  				if false {
  5202  				} else {
  5203  					*((*string)(yyv8)) = r.DecodeString()
  5204  				}
  5205  			}
  5206  		case "AuthToken":
  5207  			if r.TryDecodeAsNil() {
  5208  				x.AuthToken = ""
  5209  			} else {
  5210  				yyv10 := &x.AuthToken
  5211  				yym11 := z.DecBinary()
  5212  				_ = yym11
  5213  				if false {
  5214  				} else {
  5215  					*((*string)(yyv10)) = r.DecodeString()
  5216  				}
  5217  			}
  5218  		case "Forwarded":
  5219  			if r.TryDecodeAsNil() {
  5220  				x.Forwarded = false
  5221  			} else {
  5222  				yyv12 := &x.Forwarded
  5223  				yym13 := z.DecBinary()
  5224  				_ = yym13
  5225  				if false {
  5226  				} else {
  5227  					*((*bool)(yyv12)) = r.DecodeBool()
  5228  				}
  5229  			}
  5230  		default:
  5231  			z.DecStructFieldNotFound(-1, yys3)
  5232  		} // end switch yys3
  5233  	} // end for yyj3
  5234  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  5235  }
  5236  
  5237  func (x *NodeEvaluateRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  5238  	var h codecSelfer100
  5239  	z, r := codec1978.GenHelperDecoder(d)
  5240  	_, _, _ = h, z, r
  5241  	var yyj14 int
  5242  	var yyb14 bool
  5243  	var yyhl14 bool = l >= 0
  5244  	yyj14++
  5245  	if yyhl14 {
  5246  		yyb14 = yyj14 > l
  5247  	} else {
  5248  		yyb14 = r.CheckBreak()
  5249  	}
  5250  	if yyb14 {
  5251  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5252  		return
  5253  	}
  5254  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5255  	if r.TryDecodeAsNil() {
  5256  		x.NodeID = ""
  5257  	} else {
  5258  		yyv15 := &x.NodeID
  5259  		yym16 := z.DecBinary()
  5260  		_ = yym16
  5261  		if false {
  5262  		} else {
  5263  			*((*string)(yyv15)) = r.DecodeString()
  5264  		}
  5265  	}
  5266  	yyj14++
  5267  	if yyhl14 {
  5268  		yyb14 = yyj14 > l
  5269  	} else {
  5270  		yyb14 = r.CheckBreak()
  5271  	}
  5272  	if yyb14 {
  5273  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5274  		return
  5275  	}
  5276  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5277  	if r.TryDecodeAsNil() {
  5278  		x.Region = ""
  5279  	} else {
  5280  		yyv17 := &x.Region
  5281  		yym18 := z.DecBinary()
  5282  		_ = yym18
  5283  		if false {
  5284  		} else {
  5285  			*((*string)(yyv17)) = r.DecodeString()
  5286  		}
  5287  	}
  5288  	yyj14++
  5289  	if yyhl14 {
  5290  		yyb14 = yyj14 > l
  5291  	} else {
  5292  		yyb14 = r.CheckBreak()
  5293  	}
  5294  	if yyb14 {
  5295  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5296  		return
  5297  	}
  5298  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5299  	if r.TryDecodeAsNil() {
  5300  		x.Namespace = ""
  5301  	} else {
  5302  		yyv19 := &x.Namespace
  5303  		yym20 := z.DecBinary()
  5304  		_ = yym20
  5305  		if false {
  5306  		} else {
  5307  			*((*string)(yyv19)) = r.DecodeString()
  5308  		}
  5309  	}
  5310  	yyj14++
  5311  	if yyhl14 {
  5312  		yyb14 = yyj14 > l
  5313  	} else {
  5314  		yyb14 = r.CheckBreak()
  5315  	}
  5316  	if yyb14 {
  5317  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5318  		return
  5319  	}
  5320  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5321  	if r.TryDecodeAsNil() {
  5322  		x.AuthToken = ""
  5323  	} else {
  5324  		yyv21 := &x.AuthToken
  5325  		yym22 := z.DecBinary()
  5326  		_ = yym22
  5327  		if false {
  5328  		} else {
  5329  			*((*string)(yyv21)) = r.DecodeString()
  5330  		}
  5331  	}
  5332  	yyj14++
  5333  	if yyhl14 {
  5334  		yyb14 = yyj14 > l
  5335  	} else {
  5336  		yyb14 = r.CheckBreak()
  5337  	}
  5338  	if yyb14 {
  5339  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5340  		return
  5341  	}
  5342  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5343  	if r.TryDecodeAsNil() {
  5344  		x.Forwarded = false
  5345  	} else {
  5346  		yyv23 := &x.Forwarded
  5347  		yym24 := z.DecBinary()
  5348  		_ = yym24
  5349  		if false {
  5350  		} else {
  5351  			*((*bool)(yyv23)) = r.DecodeBool()
  5352  		}
  5353  	}
  5354  	for {
  5355  		yyj14++
  5356  		if yyhl14 {
  5357  			yyb14 = yyj14 > l
  5358  		} else {
  5359  			yyb14 = r.CheckBreak()
  5360  		}
  5361  		if yyb14 {
  5362  			break
  5363  		}
  5364  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5365  		z.DecStructFieldNotFound(yyj14-1, "")
  5366  	}
  5367  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5368  }
  5369  
  5370  func (x *NodeSpecificRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  5371  	var h codecSelfer100
  5372  	z, r := codec1978.GenHelperEncoder(e)
  5373  	_, _, _ = h, z, r
  5374  	if x == nil {
  5375  		r.EncodeNil()
  5376  	} else {
  5377  		yym1 := z.EncBinary()
  5378  		_ = yym1
  5379  		if false {
  5380  		} else if z.HasExtensions() && z.EncExt(x) {
  5381  		} else {
  5382  			yysep2 := !z.EncBinary()
  5383  			yy2arr2 := z.EncBasicHandle().StructToArray
  5384  			var yyq2 [10]bool
  5385  			_, _, _ = yysep2, yyq2, yy2arr2
  5386  			const yyr2 bool = false
  5387  			var yynn2 int
  5388  			if yyr2 || yy2arr2 {
  5389  				r.EncodeArrayStart(10)
  5390  			} else {
  5391  				yynn2 = 10
  5392  				for _, b := range yyq2 {
  5393  					if b {
  5394  						yynn2++
  5395  					}
  5396  				}
  5397  				r.EncodeMapStart(yynn2)
  5398  				yynn2 = 0
  5399  			}
  5400  			if yyr2 || yy2arr2 {
  5401  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  5402  				yym4 := z.EncBinary()
  5403  				_ = yym4
  5404  				if false {
  5405  				} else {
  5406  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
  5407  				}
  5408  			} else {
  5409  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  5410  				r.EncodeString(codecSelferC_UTF8100, string("NodeID"))
  5411  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  5412  				yym5 := z.EncBinary()
  5413  				_ = yym5
  5414  				if false {
  5415  				} else {
  5416  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
  5417  				}
  5418  			}
  5419  			if yyr2 || yy2arr2 {
  5420  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  5421  				yym7 := z.EncBinary()
  5422  				_ = yym7
  5423  				if false {
  5424  				} else {
  5425  					r.EncodeString(codecSelferC_UTF8100, string(x.SecretID))
  5426  				}
  5427  			} else {
  5428  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  5429  				r.EncodeString(codecSelferC_UTF8100, string("SecretID"))
  5430  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  5431  				yym8 := z.EncBinary()
  5432  				_ = yym8
  5433  				if false {
  5434  				} else {
  5435  					r.EncodeString(codecSelferC_UTF8100, string(x.SecretID))
  5436  				}
  5437  			}
  5438  			if yyr2 || yy2arr2 {
  5439  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  5440  				yym10 := z.EncBinary()
  5441  				_ = yym10
  5442  				if false {
  5443  				} else {
  5444  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  5445  				}
  5446  			} else {
  5447  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  5448  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  5449  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  5450  				yym11 := z.EncBinary()
  5451  				_ = yym11
  5452  				if false {
  5453  				} else {
  5454  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  5455  				}
  5456  			}
  5457  			if yyr2 || yy2arr2 {
  5458  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  5459  				yym13 := z.EncBinary()
  5460  				_ = yym13
  5461  				if false {
  5462  				} else {
  5463  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  5464  				}
  5465  			} else {
  5466  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  5467  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  5468  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  5469  				yym14 := z.EncBinary()
  5470  				_ = yym14
  5471  				if false {
  5472  				} else {
  5473  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  5474  				}
  5475  			}
  5476  			if yyr2 || yy2arr2 {
  5477  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  5478  				yym16 := z.EncBinary()
  5479  				_ = yym16
  5480  				if false {
  5481  				} else {
  5482  					r.EncodeUint(uint64(x.MinQueryIndex))
  5483  				}
  5484  			} else {
  5485  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  5486  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
  5487  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  5488  				yym17 := z.EncBinary()
  5489  				_ = yym17
  5490  				if false {
  5491  				} else {
  5492  					r.EncodeUint(uint64(x.MinQueryIndex))
  5493  				}
  5494  			}
  5495  			if yyr2 || yy2arr2 {
  5496  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  5497  				yym19 := z.EncBinary()
  5498  				_ = yym19
  5499  				if false {
  5500  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
  5501  				} else {
  5502  					r.EncodeInt(int64(x.MaxQueryTime))
  5503  				}
  5504  			} else {
  5505  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  5506  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
  5507  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  5508  				yym20 := z.EncBinary()
  5509  				_ = yym20
  5510  				if false {
  5511  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
  5512  				} else {
  5513  					r.EncodeInt(int64(x.MaxQueryTime))
  5514  				}
  5515  			}
  5516  			if yyr2 || yy2arr2 {
  5517  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  5518  				yym22 := z.EncBinary()
  5519  				_ = yym22
  5520  				if false {
  5521  				} else {
  5522  					r.EncodeBool(bool(x.AllowStale))
  5523  				}
  5524  			} else {
  5525  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  5526  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
  5527  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  5528  				yym23 := z.EncBinary()
  5529  				_ = yym23
  5530  				if false {
  5531  				} else {
  5532  					r.EncodeBool(bool(x.AllowStale))
  5533  				}
  5534  			}
  5535  			if yyr2 || yy2arr2 {
  5536  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  5537  				yym25 := z.EncBinary()
  5538  				_ = yym25
  5539  				if false {
  5540  				} else {
  5541  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
  5542  				}
  5543  			} else {
  5544  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  5545  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
  5546  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  5547  				yym26 := z.EncBinary()
  5548  				_ = yym26
  5549  				if false {
  5550  				} else {
  5551  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
  5552  				}
  5553  			}
  5554  			if yyr2 || yy2arr2 {
  5555  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  5556  				yym28 := z.EncBinary()
  5557  				_ = yym28
  5558  				if false {
  5559  				} else {
  5560  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  5561  				}
  5562  			} else {
  5563  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  5564  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  5565  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  5566  				yym29 := z.EncBinary()
  5567  				_ = yym29
  5568  				if false {
  5569  				} else {
  5570  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  5571  				}
  5572  			}
  5573  			if yyr2 || yy2arr2 {
  5574  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  5575  				yym31 := z.EncBinary()
  5576  				_ = yym31
  5577  				if false {
  5578  				} else {
  5579  					r.EncodeBool(bool(x.Forwarded))
  5580  				}
  5581  			} else {
  5582  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  5583  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  5584  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  5585  				yym32 := z.EncBinary()
  5586  				_ = yym32
  5587  				if false {
  5588  				} else {
  5589  					r.EncodeBool(bool(x.Forwarded))
  5590  				}
  5591  			}
  5592  			if yyr2 || yy2arr2 {
  5593  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  5594  			} else {
  5595  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  5596  			}
  5597  		}
  5598  	}
  5599  }
  5600  
  5601  func (x *NodeSpecificRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  5602  	var h codecSelfer100
  5603  	z, r := codec1978.GenHelperDecoder(d)
  5604  	_, _, _ = h, z, r
  5605  	yym1 := z.DecBinary()
  5606  	_ = yym1
  5607  	if false {
  5608  	} else if z.HasExtensions() && z.DecExt(x) {
  5609  	} else {
  5610  		yyct2 := r.ContainerType()
  5611  		if yyct2 == codecSelferValueTypeMap100 {
  5612  			yyl2 := r.ReadMapStart()
  5613  			if yyl2 == 0 {
  5614  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  5615  			} else {
  5616  				x.codecDecodeSelfFromMap(yyl2, d)
  5617  			}
  5618  		} else if yyct2 == codecSelferValueTypeArray100 {
  5619  			yyl2 := r.ReadArrayStart()
  5620  			if yyl2 == 0 {
  5621  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5622  			} else {
  5623  				x.codecDecodeSelfFromArray(yyl2, d)
  5624  			}
  5625  		} else {
  5626  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  5627  		}
  5628  	}
  5629  }
  5630  
  5631  func (x *NodeSpecificRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  5632  	var h codecSelfer100
  5633  	z, r := codec1978.GenHelperDecoder(d)
  5634  	_, _, _ = h, z, r
  5635  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  5636  	_ = yys3Slc
  5637  	var yyhl3 bool = l >= 0
  5638  	for yyj3 := 0; ; yyj3++ {
  5639  		if yyhl3 {
  5640  			if yyj3 >= l {
  5641  				break
  5642  			}
  5643  		} else {
  5644  			if r.CheckBreak() {
  5645  				break
  5646  			}
  5647  		}
  5648  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  5649  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  5650  		yys3 := string(yys3Slc)
  5651  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  5652  		switch yys3 {
  5653  		case "NodeID":
  5654  			if r.TryDecodeAsNil() {
  5655  				x.NodeID = ""
  5656  			} else {
  5657  				yyv4 := &x.NodeID
  5658  				yym5 := z.DecBinary()
  5659  				_ = yym5
  5660  				if false {
  5661  				} else {
  5662  					*((*string)(yyv4)) = r.DecodeString()
  5663  				}
  5664  			}
  5665  		case "SecretID":
  5666  			if r.TryDecodeAsNil() {
  5667  				x.SecretID = ""
  5668  			} else {
  5669  				yyv6 := &x.SecretID
  5670  				yym7 := z.DecBinary()
  5671  				_ = yym7
  5672  				if false {
  5673  				} else {
  5674  					*((*string)(yyv6)) = r.DecodeString()
  5675  				}
  5676  			}
  5677  		case "Region":
  5678  			if r.TryDecodeAsNil() {
  5679  				x.Region = ""
  5680  			} else {
  5681  				yyv8 := &x.Region
  5682  				yym9 := z.DecBinary()
  5683  				_ = yym9
  5684  				if false {
  5685  				} else {
  5686  					*((*string)(yyv8)) = r.DecodeString()
  5687  				}
  5688  			}
  5689  		case "Namespace":
  5690  			if r.TryDecodeAsNil() {
  5691  				x.Namespace = ""
  5692  			} else {
  5693  				yyv10 := &x.Namespace
  5694  				yym11 := z.DecBinary()
  5695  				_ = yym11
  5696  				if false {
  5697  				} else {
  5698  					*((*string)(yyv10)) = r.DecodeString()
  5699  				}
  5700  			}
  5701  		case "MinQueryIndex":
  5702  			if r.TryDecodeAsNil() {
  5703  				x.MinQueryIndex = 0
  5704  			} else {
  5705  				yyv12 := &x.MinQueryIndex
  5706  				yym13 := z.DecBinary()
  5707  				_ = yym13
  5708  				if false {
  5709  				} else {
  5710  					*((*uint64)(yyv12)) = uint64(r.DecodeUint(64))
  5711  				}
  5712  			}
  5713  		case "MaxQueryTime":
  5714  			if r.TryDecodeAsNil() {
  5715  				x.MaxQueryTime = 0
  5716  			} else {
  5717  				yyv14 := &x.MaxQueryTime
  5718  				yym15 := z.DecBinary()
  5719  				_ = yym15
  5720  				if false {
  5721  				} else if z.HasExtensions() && z.DecExt(yyv14) {
  5722  				} else {
  5723  					*((*int64)(yyv14)) = int64(r.DecodeInt(64))
  5724  				}
  5725  			}
  5726  		case "AllowStale":
  5727  			if r.TryDecodeAsNil() {
  5728  				x.AllowStale = false
  5729  			} else {
  5730  				yyv16 := &x.AllowStale
  5731  				yym17 := z.DecBinary()
  5732  				_ = yym17
  5733  				if false {
  5734  				} else {
  5735  					*((*bool)(yyv16)) = r.DecodeBool()
  5736  				}
  5737  			}
  5738  		case "Prefix":
  5739  			if r.TryDecodeAsNil() {
  5740  				x.Prefix = ""
  5741  			} else {
  5742  				yyv18 := &x.Prefix
  5743  				yym19 := z.DecBinary()
  5744  				_ = yym19
  5745  				if false {
  5746  				} else {
  5747  					*((*string)(yyv18)) = r.DecodeString()
  5748  				}
  5749  			}
  5750  		case "AuthToken":
  5751  			if r.TryDecodeAsNil() {
  5752  				x.AuthToken = ""
  5753  			} else {
  5754  				yyv20 := &x.AuthToken
  5755  				yym21 := z.DecBinary()
  5756  				_ = yym21
  5757  				if false {
  5758  				} else {
  5759  					*((*string)(yyv20)) = r.DecodeString()
  5760  				}
  5761  			}
  5762  		case "Forwarded":
  5763  			if r.TryDecodeAsNil() {
  5764  				x.Forwarded = false
  5765  			} else {
  5766  				yyv22 := &x.Forwarded
  5767  				yym23 := z.DecBinary()
  5768  				_ = yym23
  5769  				if false {
  5770  				} else {
  5771  					*((*bool)(yyv22)) = r.DecodeBool()
  5772  				}
  5773  			}
  5774  		default:
  5775  			z.DecStructFieldNotFound(-1, yys3)
  5776  		} // end switch yys3
  5777  	} // end for yyj3
  5778  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  5779  }
  5780  
  5781  func (x *NodeSpecificRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  5782  	var h codecSelfer100
  5783  	z, r := codec1978.GenHelperDecoder(d)
  5784  	_, _, _ = h, z, r
  5785  	var yyj24 int
  5786  	var yyb24 bool
  5787  	var yyhl24 bool = l >= 0
  5788  	yyj24++
  5789  	if yyhl24 {
  5790  		yyb24 = yyj24 > l
  5791  	} else {
  5792  		yyb24 = r.CheckBreak()
  5793  	}
  5794  	if yyb24 {
  5795  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5796  		return
  5797  	}
  5798  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5799  	if r.TryDecodeAsNil() {
  5800  		x.NodeID = ""
  5801  	} else {
  5802  		yyv25 := &x.NodeID
  5803  		yym26 := z.DecBinary()
  5804  		_ = yym26
  5805  		if false {
  5806  		} else {
  5807  			*((*string)(yyv25)) = r.DecodeString()
  5808  		}
  5809  	}
  5810  	yyj24++
  5811  	if yyhl24 {
  5812  		yyb24 = yyj24 > l
  5813  	} else {
  5814  		yyb24 = r.CheckBreak()
  5815  	}
  5816  	if yyb24 {
  5817  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5818  		return
  5819  	}
  5820  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5821  	if r.TryDecodeAsNil() {
  5822  		x.SecretID = ""
  5823  	} else {
  5824  		yyv27 := &x.SecretID
  5825  		yym28 := z.DecBinary()
  5826  		_ = yym28
  5827  		if false {
  5828  		} else {
  5829  			*((*string)(yyv27)) = r.DecodeString()
  5830  		}
  5831  	}
  5832  	yyj24++
  5833  	if yyhl24 {
  5834  		yyb24 = yyj24 > l
  5835  	} else {
  5836  		yyb24 = r.CheckBreak()
  5837  	}
  5838  	if yyb24 {
  5839  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5840  		return
  5841  	}
  5842  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5843  	if r.TryDecodeAsNil() {
  5844  		x.Region = ""
  5845  	} else {
  5846  		yyv29 := &x.Region
  5847  		yym30 := z.DecBinary()
  5848  		_ = yym30
  5849  		if false {
  5850  		} else {
  5851  			*((*string)(yyv29)) = r.DecodeString()
  5852  		}
  5853  	}
  5854  	yyj24++
  5855  	if yyhl24 {
  5856  		yyb24 = yyj24 > l
  5857  	} else {
  5858  		yyb24 = r.CheckBreak()
  5859  	}
  5860  	if yyb24 {
  5861  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5862  		return
  5863  	}
  5864  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5865  	if r.TryDecodeAsNil() {
  5866  		x.Namespace = ""
  5867  	} else {
  5868  		yyv31 := &x.Namespace
  5869  		yym32 := z.DecBinary()
  5870  		_ = yym32
  5871  		if false {
  5872  		} else {
  5873  			*((*string)(yyv31)) = r.DecodeString()
  5874  		}
  5875  	}
  5876  	yyj24++
  5877  	if yyhl24 {
  5878  		yyb24 = yyj24 > l
  5879  	} else {
  5880  		yyb24 = r.CheckBreak()
  5881  	}
  5882  	if yyb24 {
  5883  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5884  		return
  5885  	}
  5886  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5887  	if r.TryDecodeAsNil() {
  5888  		x.MinQueryIndex = 0
  5889  	} else {
  5890  		yyv33 := &x.MinQueryIndex
  5891  		yym34 := z.DecBinary()
  5892  		_ = yym34
  5893  		if false {
  5894  		} else {
  5895  			*((*uint64)(yyv33)) = uint64(r.DecodeUint(64))
  5896  		}
  5897  	}
  5898  	yyj24++
  5899  	if yyhl24 {
  5900  		yyb24 = yyj24 > l
  5901  	} else {
  5902  		yyb24 = r.CheckBreak()
  5903  	}
  5904  	if yyb24 {
  5905  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5906  		return
  5907  	}
  5908  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5909  	if r.TryDecodeAsNil() {
  5910  		x.MaxQueryTime = 0
  5911  	} else {
  5912  		yyv35 := &x.MaxQueryTime
  5913  		yym36 := z.DecBinary()
  5914  		_ = yym36
  5915  		if false {
  5916  		} else if z.HasExtensions() && z.DecExt(yyv35) {
  5917  		} else {
  5918  			*((*int64)(yyv35)) = int64(r.DecodeInt(64))
  5919  		}
  5920  	}
  5921  	yyj24++
  5922  	if yyhl24 {
  5923  		yyb24 = yyj24 > l
  5924  	} else {
  5925  		yyb24 = r.CheckBreak()
  5926  	}
  5927  	if yyb24 {
  5928  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5929  		return
  5930  	}
  5931  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5932  	if r.TryDecodeAsNil() {
  5933  		x.AllowStale = false
  5934  	} else {
  5935  		yyv37 := &x.AllowStale
  5936  		yym38 := z.DecBinary()
  5937  		_ = yym38
  5938  		if false {
  5939  		} else {
  5940  			*((*bool)(yyv37)) = r.DecodeBool()
  5941  		}
  5942  	}
  5943  	yyj24++
  5944  	if yyhl24 {
  5945  		yyb24 = yyj24 > l
  5946  	} else {
  5947  		yyb24 = r.CheckBreak()
  5948  	}
  5949  	if yyb24 {
  5950  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5951  		return
  5952  	}
  5953  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5954  	if r.TryDecodeAsNil() {
  5955  		x.Prefix = ""
  5956  	} else {
  5957  		yyv39 := &x.Prefix
  5958  		yym40 := z.DecBinary()
  5959  		_ = yym40
  5960  		if false {
  5961  		} else {
  5962  			*((*string)(yyv39)) = r.DecodeString()
  5963  		}
  5964  	}
  5965  	yyj24++
  5966  	if yyhl24 {
  5967  		yyb24 = yyj24 > l
  5968  	} else {
  5969  		yyb24 = r.CheckBreak()
  5970  	}
  5971  	if yyb24 {
  5972  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5973  		return
  5974  	}
  5975  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5976  	if r.TryDecodeAsNil() {
  5977  		x.AuthToken = ""
  5978  	} else {
  5979  		yyv41 := &x.AuthToken
  5980  		yym42 := z.DecBinary()
  5981  		_ = yym42
  5982  		if false {
  5983  		} else {
  5984  			*((*string)(yyv41)) = r.DecodeString()
  5985  		}
  5986  	}
  5987  	yyj24++
  5988  	if yyhl24 {
  5989  		yyb24 = yyj24 > l
  5990  	} else {
  5991  		yyb24 = r.CheckBreak()
  5992  	}
  5993  	if yyb24 {
  5994  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  5995  		return
  5996  	}
  5997  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  5998  	if r.TryDecodeAsNil() {
  5999  		x.Forwarded = false
  6000  	} else {
  6001  		yyv43 := &x.Forwarded
  6002  		yym44 := z.DecBinary()
  6003  		_ = yym44
  6004  		if false {
  6005  		} else {
  6006  			*((*bool)(yyv43)) = r.DecodeBool()
  6007  		}
  6008  	}
  6009  	for {
  6010  		yyj24++
  6011  		if yyhl24 {
  6012  			yyb24 = yyj24 > l
  6013  		} else {
  6014  			yyb24 = r.CheckBreak()
  6015  		}
  6016  		if yyb24 {
  6017  			break
  6018  		}
  6019  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6020  		z.DecStructFieldNotFound(yyj24-1, "")
  6021  	}
  6022  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6023  }
  6024  
  6025  func (x *SearchResponse) CodecEncodeSelf(e *codec1978.Encoder) {
  6026  	var h codecSelfer100
  6027  	z, r := codec1978.GenHelperEncoder(e)
  6028  	_, _, _ = h, z, r
  6029  	if x == nil {
  6030  		r.EncodeNil()
  6031  	} else {
  6032  		yym1 := z.EncBinary()
  6033  		_ = yym1
  6034  		if false {
  6035  		} else if z.HasExtensions() && z.EncExt(x) {
  6036  		} else {
  6037  			yysep2 := !z.EncBinary()
  6038  			yy2arr2 := z.EncBasicHandle().StructToArray
  6039  			var yyq2 [5]bool
  6040  			_, _, _ = yysep2, yyq2, yy2arr2
  6041  			const yyr2 bool = false
  6042  			var yynn2 int
  6043  			if yyr2 || yy2arr2 {
  6044  				r.EncodeArrayStart(5)
  6045  			} else {
  6046  				yynn2 = 5
  6047  				for _, b := range yyq2 {
  6048  					if b {
  6049  						yynn2++
  6050  					}
  6051  				}
  6052  				r.EncodeMapStart(yynn2)
  6053  				yynn2 = 0
  6054  			}
  6055  			if yyr2 || yy2arr2 {
  6056  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  6057  				if x.Matches == nil {
  6058  					r.EncodeNil()
  6059  				} else {
  6060  					yym4 := z.EncBinary()
  6061  					_ = yym4
  6062  					if false {
  6063  					} else {
  6064  						h.encMapContextSlicestring((map[Context][]string)(x.Matches), e)
  6065  					}
  6066  				}
  6067  			} else {
  6068  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  6069  				r.EncodeString(codecSelferC_UTF8100, string("Matches"))
  6070  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  6071  				if x.Matches == nil {
  6072  					r.EncodeNil()
  6073  				} else {
  6074  					yym5 := z.EncBinary()
  6075  					_ = yym5
  6076  					if false {
  6077  					} else {
  6078  						h.encMapContextSlicestring((map[Context][]string)(x.Matches), e)
  6079  					}
  6080  				}
  6081  			}
  6082  			if yyr2 || yy2arr2 {
  6083  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  6084  				if x.Truncations == nil {
  6085  					r.EncodeNil()
  6086  				} else {
  6087  					yym7 := z.EncBinary()
  6088  					_ = yym7
  6089  					if false {
  6090  					} else {
  6091  						h.encMapContextbool((map[Context]bool)(x.Truncations), e)
  6092  					}
  6093  				}
  6094  			} else {
  6095  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  6096  				r.EncodeString(codecSelferC_UTF8100, string("Truncations"))
  6097  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  6098  				if x.Truncations == nil {
  6099  					r.EncodeNil()
  6100  				} else {
  6101  					yym8 := z.EncBinary()
  6102  					_ = yym8
  6103  					if false {
  6104  					} else {
  6105  						h.encMapContextbool((map[Context]bool)(x.Truncations), e)
  6106  					}
  6107  				}
  6108  			}
  6109  			if yyr2 || yy2arr2 {
  6110  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  6111  				yym10 := z.EncBinary()
  6112  				_ = yym10
  6113  				if false {
  6114  				} else {
  6115  					r.EncodeUint(uint64(x.Index))
  6116  				}
  6117  			} else {
  6118  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  6119  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
  6120  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  6121  				yym11 := z.EncBinary()
  6122  				_ = yym11
  6123  				if false {
  6124  				} else {
  6125  					r.EncodeUint(uint64(x.Index))
  6126  				}
  6127  			}
  6128  			if yyr2 || yy2arr2 {
  6129  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  6130  				yym13 := z.EncBinary()
  6131  				_ = yym13
  6132  				if false {
  6133  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
  6134  				} else {
  6135  					r.EncodeInt(int64(x.LastContact))
  6136  				}
  6137  			} else {
  6138  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  6139  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
  6140  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  6141  				yym14 := z.EncBinary()
  6142  				_ = yym14
  6143  				if false {
  6144  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
  6145  				} else {
  6146  					r.EncodeInt(int64(x.LastContact))
  6147  				}
  6148  			}
  6149  			if yyr2 || yy2arr2 {
  6150  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  6151  				yym16 := z.EncBinary()
  6152  				_ = yym16
  6153  				if false {
  6154  				} else {
  6155  					r.EncodeBool(bool(x.KnownLeader))
  6156  				}
  6157  			} else {
  6158  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  6159  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
  6160  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  6161  				yym17 := z.EncBinary()
  6162  				_ = yym17
  6163  				if false {
  6164  				} else {
  6165  					r.EncodeBool(bool(x.KnownLeader))
  6166  				}
  6167  			}
  6168  			if yyr2 || yy2arr2 {
  6169  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  6170  			} else {
  6171  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  6172  			}
  6173  		}
  6174  	}
  6175  }
  6176  
  6177  func (x *SearchResponse) CodecDecodeSelf(d *codec1978.Decoder) {
  6178  	var h codecSelfer100
  6179  	z, r := codec1978.GenHelperDecoder(d)
  6180  	_, _, _ = h, z, r
  6181  	yym1 := z.DecBinary()
  6182  	_ = yym1
  6183  	if false {
  6184  	} else if z.HasExtensions() && z.DecExt(x) {
  6185  	} else {
  6186  		yyct2 := r.ContainerType()
  6187  		if yyct2 == codecSelferValueTypeMap100 {
  6188  			yyl2 := r.ReadMapStart()
  6189  			if yyl2 == 0 {
  6190  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  6191  			} else {
  6192  				x.codecDecodeSelfFromMap(yyl2, d)
  6193  			}
  6194  		} else if yyct2 == codecSelferValueTypeArray100 {
  6195  			yyl2 := r.ReadArrayStart()
  6196  			if yyl2 == 0 {
  6197  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6198  			} else {
  6199  				x.codecDecodeSelfFromArray(yyl2, d)
  6200  			}
  6201  		} else {
  6202  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  6203  		}
  6204  	}
  6205  }
  6206  
  6207  func (x *SearchResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  6208  	var h codecSelfer100
  6209  	z, r := codec1978.GenHelperDecoder(d)
  6210  	_, _, _ = h, z, r
  6211  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  6212  	_ = yys3Slc
  6213  	var yyhl3 bool = l >= 0
  6214  	for yyj3 := 0; ; yyj3++ {
  6215  		if yyhl3 {
  6216  			if yyj3 >= l {
  6217  				break
  6218  			}
  6219  		} else {
  6220  			if r.CheckBreak() {
  6221  				break
  6222  			}
  6223  		}
  6224  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  6225  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  6226  		yys3 := string(yys3Slc)
  6227  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  6228  		switch yys3 {
  6229  		case "Matches":
  6230  			if r.TryDecodeAsNil() {
  6231  				x.Matches = nil
  6232  			} else {
  6233  				yyv4 := &x.Matches
  6234  				yym5 := z.DecBinary()
  6235  				_ = yym5
  6236  				if false {
  6237  				} else {
  6238  					h.decMapContextSlicestring((*map[Context][]string)(yyv4), d)
  6239  				}
  6240  			}
  6241  		case "Truncations":
  6242  			if r.TryDecodeAsNil() {
  6243  				x.Truncations = nil
  6244  			} else {
  6245  				yyv6 := &x.Truncations
  6246  				yym7 := z.DecBinary()
  6247  				_ = yym7
  6248  				if false {
  6249  				} else {
  6250  					h.decMapContextbool((*map[Context]bool)(yyv6), d)
  6251  				}
  6252  			}
  6253  		case "Index":
  6254  			if r.TryDecodeAsNil() {
  6255  				x.Index = 0
  6256  			} else {
  6257  				yyv8 := &x.Index
  6258  				yym9 := z.DecBinary()
  6259  				_ = yym9
  6260  				if false {
  6261  				} else {
  6262  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
  6263  				}
  6264  			}
  6265  		case "LastContact":
  6266  			if r.TryDecodeAsNil() {
  6267  				x.LastContact = 0
  6268  			} else {
  6269  				yyv10 := &x.LastContact
  6270  				yym11 := z.DecBinary()
  6271  				_ = yym11
  6272  				if false {
  6273  				} else if z.HasExtensions() && z.DecExt(yyv10) {
  6274  				} else {
  6275  					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
  6276  				}
  6277  			}
  6278  		case "KnownLeader":
  6279  			if r.TryDecodeAsNil() {
  6280  				x.KnownLeader = false
  6281  			} else {
  6282  				yyv12 := &x.KnownLeader
  6283  				yym13 := z.DecBinary()
  6284  				_ = yym13
  6285  				if false {
  6286  				} else {
  6287  					*((*bool)(yyv12)) = r.DecodeBool()
  6288  				}
  6289  			}
  6290  		default:
  6291  			z.DecStructFieldNotFound(-1, yys3)
  6292  		} // end switch yys3
  6293  	} // end for yyj3
  6294  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  6295  }
  6296  
  6297  func (x *SearchResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  6298  	var h codecSelfer100
  6299  	z, r := codec1978.GenHelperDecoder(d)
  6300  	_, _, _ = h, z, r
  6301  	var yyj14 int
  6302  	var yyb14 bool
  6303  	var yyhl14 bool = l >= 0
  6304  	yyj14++
  6305  	if yyhl14 {
  6306  		yyb14 = yyj14 > l
  6307  	} else {
  6308  		yyb14 = r.CheckBreak()
  6309  	}
  6310  	if yyb14 {
  6311  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6312  		return
  6313  	}
  6314  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6315  	if r.TryDecodeAsNil() {
  6316  		x.Matches = nil
  6317  	} else {
  6318  		yyv15 := &x.Matches
  6319  		yym16 := z.DecBinary()
  6320  		_ = yym16
  6321  		if false {
  6322  		} else {
  6323  			h.decMapContextSlicestring((*map[Context][]string)(yyv15), d)
  6324  		}
  6325  	}
  6326  	yyj14++
  6327  	if yyhl14 {
  6328  		yyb14 = yyj14 > l
  6329  	} else {
  6330  		yyb14 = r.CheckBreak()
  6331  	}
  6332  	if yyb14 {
  6333  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6334  		return
  6335  	}
  6336  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6337  	if r.TryDecodeAsNil() {
  6338  		x.Truncations = nil
  6339  	} else {
  6340  		yyv17 := &x.Truncations
  6341  		yym18 := z.DecBinary()
  6342  		_ = yym18
  6343  		if false {
  6344  		} else {
  6345  			h.decMapContextbool((*map[Context]bool)(yyv17), d)
  6346  		}
  6347  	}
  6348  	yyj14++
  6349  	if yyhl14 {
  6350  		yyb14 = yyj14 > l
  6351  	} else {
  6352  		yyb14 = r.CheckBreak()
  6353  	}
  6354  	if yyb14 {
  6355  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6356  		return
  6357  	}
  6358  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6359  	if r.TryDecodeAsNil() {
  6360  		x.Index = 0
  6361  	} else {
  6362  		yyv19 := &x.Index
  6363  		yym20 := z.DecBinary()
  6364  		_ = yym20
  6365  		if false {
  6366  		} else {
  6367  			*((*uint64)(yyv19)) = uint64(r.DecodeUint(64))
  6368  		}
  6369  	}
  6370  	yyj14++
  6371  	if yyhl14 {
  6372  		yyb14 = yyj14 > l
  6373  	} else {
  6374  		yyb14 = r.CheckBreak()
  6375  	}
  6376  	if yyb14 {
  6377  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6378  		return
  6379  	}
  6380  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6381  	if r.TryDecodeAsNil() {
  6382  		x.LastContact = 0
  6383  	} else {
  6384  		yyv21 := &x.LastContact
  6385  		yym22 := z.DecBinary()
  6386  		_ = yym22
  6387  		if false {
  6388  		} else if z.HasExtensions() && z.DecExt(yyv21) {
  6389  		} else {
  6390  			*((*int64)(yyv21)) = int64(r.DecodeInt(64))
  6391  		}
  6392  	}
  6393  	yyj14++
  6394  	if yyhl14 {
  6395  		yyb14 = yyj14 > l
  6396  	} else {
  6397  		yyb14 = r.CheckBreak()
  6398  	}
  6399  	if yyb14 {
  6400  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6401  		return
  6402  	}
  6403  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6404  	if r.TryDecodeAsNil() {
  6405  		x.KnownLeader = false
  6406  	} else {
  6407  		yyv23 := &x.KnownLeader
  6408  		yym24 := z.DecBinary()
  6409  		_ = yym24
  6410  		if false {
  6411  		} else {
  6412  			*((*bool)(yyv23)) = r.DecodeBool()
  6413  		}
  6414  	}
  6415  	for {
  6416  		yyj14++
  6417  		if yyhl14 {
  6418  			yyb14 = yyj14 > l
  6419  		} else {
  6420  			yyb14 = r.CheckBreak()
  6421  		}
  6422  		if yyb14 {
  6423  			break
  6424  		}
  6425  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6426  		z.DecStructFieldNotFound(yyj14-1, "")
  6427  	}
  6428  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6429  }
  6430  
  6431  func (x *SearchRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  6432  	var h codecSelfer100
  6433  	z, r := codec1978.GenHelperEncoder(e)
  6434  	_, _, _ = h, z, r
  6435  	if x == nil {
  6436  		r.EncodeNil()
  6437  	} else {
  6438  		yym1 := z.EncBinary()
  6439  		_ = yym1
  6440  		if false {
  6441  		} else if z.HasExtensions() && z.EncExt(x) {
  6442  		} else {
  6443  			yysep2 := !z.EncBinary()
  6444  			yy2arr2 := z.EncBasicHandle().StructToArray
  6445  			var yyq2 [9]bool
  6446  			_, _, _ = yysep2, yyq2, yy2arr2
  6447  			const yyr2 bool = false
  6448  			var yynn2 int
  6449  			if yyr2 || yy2arr2 {
  6450  				r.EncodeArrayStart(9)
  6451  			} else {
  6452  				yynn2 = 9
  6453  				for _, b := range yyq2 {
  6454  					if b {
  6455  						yynn2++
  6456  					}
  6457  				}
  6458  				r.EncodeMapStart(yynn2)
  6459  				yynn2 = 0
  6460  			}
  6461  			if yyr2 || yy2arr2 {
  6462  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  6463  				yym4 := z.EncBinary()
  6464  				_ = yym4
  6465  				if false {
  6466  				} else {
  6467  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
  6468  				}
  6469  			} else {
  6470  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  6471  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
  6472  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  6473  				yym5 := z.EncBinary()
  6474  				_ = yym5
  6475  				if false {
  6476  				} else {
  6477  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
  6478  				}
  6479  			}
  6480  			if yyr2 || yy2arr2 {
  6481  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  6482  				x.Context.CodecEncodeSelf(e)
  6483  			} else {
  6484  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  6485  				r.EncodeString(codecSelferC_UTF8100, string("Context"))
  6486  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  6487  				x.Context.CodecEncodeSelf(e)
  6488  			}
  6489  			if yyr2 || yy2arr2 {
  6490  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  6491  				yym10 := z.EncBinary()
  6492  				_ = yym10
  6493  				if false {
  6494  				} else {
  6495  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  6496  				}
  6497  			} else {
  6498  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  6499  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  6500  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  6501  				yym11 := z.EncBinary()
  6502  				_ = yym11
  6503  				if false {
  6504  				} else {
  6505  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  6506  				}
  6507  			}
  6508  			if yyr2 || yy2arr2 {
  6509  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  6510  				yym13 := z.EncBinary()
  6511  				_ = yym13
  6512  				if false {
  6513  				} else {
  6514  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  6515  				}
  6516  			} else {
  6517  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  6518  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  6519  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  6520  				yym14 := z.EncBinary()
  6521  				_ = yym14
  6522  				if false {
  6523  				} else {
  6524  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  6525  				}
  6526  			}
  6527  			if yyr2 || yy2arr2 {
  6528  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  6529  				yym16 := z.EncBinary()
  6530  				_ = yym16
  6531  				if false {
  6532  				} else {
  6533  					r.EncodeUint(uint64(x.MinQueryIndex))
  6534  				}
  6535  			} else {
  6536  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  6537  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
  6538  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  6539  				yym17 := z.EncBinary()
  6540  				_ = yym17
  6541  				if false {
  6542  				} else {
  6543  					r.EncodeUint(uint64(x.MinQueryIndex))
  6544  				}
  6545  			}
  6546  			if yyr2 || yy2arr2 {
  6547  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  6548  				yym19 := z.EncBinary()
  6549  				_ = yym19
  6550  				if false {
  6551  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
  6552  				} else {
  6553  					r.EncodeInt(int64(x.MaxQueryTime))
  6554  				}
  6555  			} else {
  6556  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  6557  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
  6558  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  6559  				yym20 := z.EncBinary()
  6560  				_ = yym20
  6561  				if false {
  6562  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
  6563  				} else {
  6564  					r.EncodeInt(int64(x.MaxQueryTime))
  6565  				}
  6566  			}
  6567  			if yyr2 || yy2arr2 {
  6568  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  6569  				yym22 := z.EncBinary()
  6570  				_ = yym22
  6571  				if false {
  6572  				} else {
  6573  					r.EncodeBool(bool(x.AllowStale))
  6574  				}
  6575  			} else {
  6576  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  6577  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
  6578  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  6579  				yym23 := z.EncBinary()
  6580  				_ = yym23
  6581  				if false {
  6582  				} else {
  6583  					r.EncodeBool(bool(x.AllowStale))
  6584  				}
  6585  			}
  6586  			if yyr2 || yy2arr2 {
  6587  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  6588  				yym25 := z.EncBinary()
  6589  				_ = yym25
  6590  				if false {
  6591  				} else {
  6592  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  6593  				}
  6594  			} else {
  6595  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  6596  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  6597  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  6598  				yym26 := z.EncBinary()
  6599  				_ = yym26
  6600  				if false {
  6601  				} else {
  6602  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  6603  				}
  6604  			}
  6605  			if yyr2 || yy2arr2 {
  6606  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  6607  				yym28 := z.EncBinary()
  6608  				_ = yym28
  6609  				if false {
  6610  				} else {
  6611  					r.EncodeBool(bool(x.Forwarded))
  6612  				}
  6613  			} else {
  6614  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  6615  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  6616  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  6617  				yym29 := z.EncBinary()
  6618  				_ = yym29
  6619  				if false {
  6620  				} else {
  6621  					r.EncodeBool(bool(x.Forwarded))
  6622  				}
  6623  			}
  6624  			if yyr2 || yy2arr2 {
  6625  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  6626  			} else {
  6627  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  6628  			}
  6629  		}
  6630  	}
  6631  }
  6632  
  6633  func (x *SearchRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  6634  	var h codecSelfer100
  6635  	z, r := codec1978.GenHelperDecoder(d)
  6636  	_, _, _ = h, z, r
  6637  	yym1 := z.DecBinary()
  6638  	_ = yym1
  6639  	if false {
  6640  	} else if z.HasExtensions() && z.DecExt(x) {
  6641  	} else {
  6642  		yyct2 := r.ContainerType()
  6643  		if yyct2 == codecSelferValueTypeMap100 {
  6644  			yyl2 := r.ReadMapStart()
  6645  			if yyl2 == 0 {
  6646  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  6647  			} else {
  6648  				x.codecDecodeSelfFromMap(yyl2, d)
  6649  			}
  6650  		} else if yyct2 == codecSelferValueTypeArray100 {
  6651  			yyl2 := r.ReadArrayStart()
  6652  			if yyl2 == 0 {
  6653  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6654  			} else {
  6655  				x.codecDecodeSelfFromArray(yyl2, d)
  6656  			}
  6657  		} else {
  6658  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  6659  		}
  6660  	}
  6661  }
  6662  
  6663  func (x *SearchRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  6664  	var h codecSelfer100
  6665  	z, r := codec1978.GenHelperDecoder(d)
  6666  	_, _, _ = h, z, r
  6667  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  6668  	_ = yys3Slc
  6669  	var yyhl3 bool = l >= 0
  6670  	for yyj3 := 0; ; yyj3++ {
  6671  		if yyhl3 {
  6672  			if yyj3 >= l {
  6673  				break
  6674  			}
  6675  		} else {
  6676  			if r.CheckBreak() {
  6677  				break
  6678  			}
  6679  		}
  6680  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  6681  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  6682  		yys3 := string(yys3Slc)
  6683  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  6684  		switch yys3 {
  6685  		case "Prefix":
  6686  			if r.TryDecodeAsNil() {
  6687  				x.Prefix = ""
  6688  			} else {
  6689  				yyv4 := &x.Prefix
  6690  				yym5 := z.DecBinary()
  6691  				_ = yym5
  6692  				if false {
  6693  				} else {
  6694  					*((*string)(yyv4)) = r.DecodeString()
  6695  				}
  6696  			}
  6697  		case "Context":
  6698  			if r.TryDecodeAsNil() {
  6699  				x.Context = ""
  6700  			} else {
  6701  				yyv6 := &x.Context
  6702  				yyv6.CodecDecodeSelf(d)
  6703  			}
  6704  		case "Region":
  6705  			if r.TryDecodeAsNil() {
  6706  				x.Region = ""
  6707  			} else {
  6708  				yyv7 := &x.Region
  6709  				yym8 := z.DecBinary()
  6710  				_ = yym8
  6711  				if false {
  6712  				} else {
  6713  					*((*string)(yyv7)) = r.DecodeString()
  6714  				}
  6715  			}
  6716  		case "Namespace":
  6717  			if r.TryDecodeAsNil() {
  6718  				x.Namespace = ""
  6719  			} else {
  6720  				yyv9 := &x.Namespace
  6721  				yym10 := z.DecBinary()
  6722  				_ = yym10
  6723  				if false {
  6724  				} else {
  6725  					*((*string)(yyv9)) = r.DecodeString()
  6726  				}
  6727  			}
  6728  		case "MinQueryIndex":
  6729  			if r.TryDecodeAsNil() {
  6730  				x.MinQueryIndex = 0
  6731  			} else {
  6732  				yyv11 := &x.MinQueryIndex
  6733  				yym12 := z.DecBinary()
  6734  				_ = yym12
  6735  				if false {
  6736  				} else {
  6737  					*((*uint64)(yyv11)) = uint64(r.DecodeUint(64))
  6738  				}
  6739  			}
  6740  		case "MaxQueryTime":
  6741  			if r.TryDecodeAsNil() {
  6742  				x.MaxQueryTime = 0
  6743  			} else {
  6744  				yyv13 := &x.MaxQueryTime
  6745  				yym14 := z.DecBinary()
  6746  				_ = yym14
  6747  				if false {
  6748  				} else if z.HasExtensions() && z.DecExt(yyv13) {
  6749  				} else {
  6750  					*((*int64)(yyv13)) = int64(r.DecodeInt(64))
  6751  				}
  6752  			}
  6753  		case "AllowStale":
  6754  			if r.TryDecodeAsNil() {
  6755  				x.AllowStale = false
  6756  			} else {
  6757  				yyv15 := &x.AllowStale
  6758  				yym16 := z.DecBinary()
  6759  				_ = yym16
  6760  				if false {
  6761  				} else {
  6762  					*((*bool)(yyv15)) = r.DecodeBool()
  6763  				}
  6764  			}
  6765  		case "AuthToken":
  6766  			if r.TryDecodeAsNil() {
  6767  				x.AuthToken = ""
  6768  			} else {
  6769  				yyv17 := &x.AuthToken
  6770  				yym18 := z.DecBinary()
  6771  				_ = yym18
  6772  				if false {
  6773  				} else {
  6774  					*((*string)(yyv17)) = r.DecodeString()
  6775  				}
  6776  			}
  6777  		case "Forwarded":
  6778  			if r.TryDecodeAsNil() {
  6779  				x.Forwarded = false
  6780  			} else {
  6781  				yyv19 := &x.Forwarded
  6782  				yym20 := z.DecBinary()
  6783  				_ = yym20
  6784  				if false {
  6785  				} else {
  6786  					*((*bool)(yyv19)) = r.DecodeBool()
  6787  				}
  6788  			}
  6789  		default:
  6790  			z.DecStructFieldNotFound(-1, yys3)
  6791  		} // end switch yys3
  6792  	} // end for yyj3
  6793  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  6794  }
  6795  
  6796  func (x *SearchRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  6797  	var h codecSelfer100
  6798  	z, r := codec1978.GenHelperDecoder(d)
  6799  	_, _, _ = h, z, r
  6800  	var yyj21 int
  6801  	var yyb21 bool
  6802  	var yyhl21 bool = l >= 0
  6803  	yyj21++
  6804  	if yyhl21 {
  6805  		yyb21 = yyj21 > l
  6806  	} else {
  6807  		yyb21 = r.CheckBreak()
  6808  	}
  6809  	if yyb21 {
  6810  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6811  		return
  6812  	}
  6813  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6814  	if r.TryDecodeAsNil() {
  6815  		x.Prefix = ""
  6816  	} else {
  6817  		yyv22 := &x.Prefix
  6818  		yym23 := z.DecBinary()
  6819  		_ = yym23
  6820  		if false {
  6821  		} else {
  6822  			*((*string)(yyv22)) = r.DecodeString()
  6823  		}
  6824  	}
  6825  	yyj21++
  6826  	if yyhl21 {
  6827  		yyb21 = yyj21 > l
  6828  	} else {
  6829  		yyb21 = r.CheckBreak()
  6830  	}
  6831  	if yyb21 {
  6832  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6833  		return
  6834  	}
  6835  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6836  	if r.TryDecodeAsNil() {
  6837  		x.Context = ""
  6838  	} else {
  6839  		yyv24 := &x.Context
  6840  		yyv24.CodecDecodeSelf(d)
  6841  	}
  6842  	yyj21++
  6843  	if yyhl21 {
  6844  		yyb21 = yyj21 > l
  6845  	} else {
  6846  		yyb21 = r.CheckBreak()
  6847  	}
  6848  	if yyb21 {
  6849  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6850  		return
  6851  	}
  6852  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6853  	if r.TryDecodeAsNil() {
  6854  		x.Region = ""
  6855  	} else {
  6856  		yyv25 := &x.Region
  6857  		yym26 := z.DecBinary()
  6858  		_ = yym26
  6859  		if false {
  6860  		} else {
  6861  			*((*string)(yyv25)) = r.DecodeString()
  6862  		}
  6863  	}
  6864  	yyj21++
  6865  	if yyhl21 {
  6866  		yyb21 = yyj21 > l
  6867  	} else {
  6868  		yyb21 = r.CheckBreak()
  6869  	}
  6870  	if yyb21 {
  6871  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6872  		return
  6873  	}
  6874  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6875  	if r.TryDecodeAsNil() {
  6876  		x.Namespace = ""
  6877  	} else {
  6878  		yyv27 := &x.Namespace
  6879  		yym28 := z.DecBinary()
  6880  		_ = yym28
  6881  		if false {
  6882  		} else {
  6883  			*((*string)(yyv27)) = r.DecodeString()
  6884  		}
  6885  	}
  6886  	yyj21++
  6887  	if yyhl21 {
  6888  		yyb21 = yyj21 > l
  6889  	} else {
  6890  		yyb21 = r.CheckBreak()
  6891  	}
  6892  	if yyb21 {
  6893  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6894  		return
  6895  	}
  6896  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6897  	if r.TryDecodeAsNil() {
  6898  		x.MinQueryIndex = 0
  6899  	} else {
  6900  		yyv29 := &x.MinQueryIndex
  6901  		yym30 := z.DecBinary()
  6902  		_ = yym30
  6903  		if false {
  6904  		} else {
  6905  			*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
  6906  		}
  6907  	}
  6908  	yyj21++
  6909  	if yyhl21 {
  6910  		yyb21 = yyj21 > l
  6911  	} else {
  6912  		yyb21 = r.CheckBreak()
  6913  	}
  6914  	if yyb21 {
  6915  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6916  		return
  6917  	}
  6918  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6919  	if r.TryDecodeAsNil() {
  6920  		x.MaxQueryTime = 0
  6921  	} else {
  6922  		yyv31 := &x.MaxQueryTime
  6923  		yym32 := z.DecBinary()
  6924  		_ = yym32
  6925  		if false {
  6926  		} else if z.HasExtensions() && z.DecExt(yyv31) {
  6927  		} else {
  6928  			*((*int64)(yyv31)) = int64(r.DecodeInt(64))
  6929  		}
  6930  	}
  6931  	yyj21++
  6932  	if yyhl21 {
  6933  		yyb21 = yyj21 > l
  6934  	} else {
  6935  		yyb21 = r.CheckBreak()
  6936  	}
  6937  	if yyb21 {
  6938  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6939  		return
  6940  	}
  6941  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6942  	if r.TryDecodeAsNil() {
  6943  		x.AllowStale = false
  6944  	} else {
  6945  		yyv33 := &x.AllowStale
  6946  		yym34 := z.DecBinary()
  6947  		_ = yym34
  6948  		if false {
  6949  		} else {
  6950  			*((*bool)(yyv33)) = r.DecodeBool()
  6951  		}
  6952  	}
  6953  	yyj21++
  6954  	if yyhl21 {
  6955  		yyb21 = yyj21 > l
  6956  	} else {
  6957  		yyb21 = r.CheckBreak()
  6958  	}
  6959  	if yyb21 {
  6960  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6961  		return
  6962  	}
  6963  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6964  	if r.TryDecodeAsNil() {
  6965  		x.AuthToken = ""
  6966  	} else {
  6967  		yyv35 := &x.AuthToken
  6968  		yym36 := z.DecBinary()
  6969  		_ = yym36
  6970  		if false {
  6971  		} else {
  6972  			*((*string)(yyv35)) = r.DecodeString()
  6973  		}
  6974  	}
  6975  	yyj21++
  6976  	if yyhl21 {
  6977  		yyb21 = yyj21 > l
  6978  	} else {
  6979  		yyb21 = r.CheckBreak()
  6980  	}
  6981  	if yyb21 {
  6982  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  6983  		return
  6984  	}
  6985  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  6986  	if r.TryDecodeAsNil() {
  6987  		x.Forwarded = false
  6988  	} else {
  6989  		yyv37 := &x.Forwarded
  6990  		yym38 := z.DecBinary()
  6991  		_ = yym38
  6992  		if false {
  6993  		} else {
  6994  			*((*bool)(yyv37)) = r.DecodeBool()
  6995  		}
  6996  	}
  6997  	for {
  6998  		yyj21++
  6999  		if yyhl21 {
  7000  			yyb21 = yyj21 > l
  7001  		} else {
  7002  			yyb21 = r.CheckBreak()
  7003  		}
  7004  		if yyb21 {
  7005  			break
  7006  		}
  7007  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7008  		z.DecStructFieldNotFound(yyj21-1, "")
  7009  	}
  7010  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7011  }
  7012  
  7013  func (x *JobRegisterRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  7014  	var h codecSelfer100
  7015  	z, r := codec1978.GenHelperEncoder(e)
  7016  	_, _, _ = h, z, r
  7017  	if x == nil {
  7018  		r.EncodeNil()
  7019  	} else {
  7020  		yym1 := z.EncBinary()
  7021  		_ = yym1
  7022  		if false {
  7023  		} else if z.HasExtensions() && z.EncExt(x) {
  7024  		} else {
  7025  			yysep2 := !z.EncBinary()
  7026  			yy2arr2 := z.EncBasicHandle().StructToArray
  7027  			var yyq2 [8]bool
  7028  			_, _, _ = yysep2, yyq2, yy2arr2
  7029  			const yyr2 bool = false
  7030  			var yynn2 int
  7031  			if yyr2 || yy2arr2 {
  7032  				r.EncodeArrayStart(8)
  7033  			} else {
  7034  				yynn2 = 8
  7035  				for _, b := range yyq2 {
  7036  					if b {
  7037  						yynn2++
  7038  					}
  7039  				}
  7040  				r.EncodeMapStart(yynn2)
  7041  				yynn2 = 0
  7042  			}
  7043  			if yyr2 || yy2arr2 {
  7044  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  7045  				if x.Job == nil {
  7046  					r.EncodeNil()
  7047  				} else {
  7048  					x.Job.CodecEncodeSelf(e)
  7049  				}
  7050  			} else {
  7051  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  7052  				r.EncodeString(codecSelferC_UTF8100, string("Job"))
  7053  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  7054  				if x.Job == nil {
  7055  					r.EncodeNil()
  7056  				} else {
  7057  					x.Job.CodecEncodeSelf(e)
  7058  				}
  7059  			}
  7060  			if yyr2 || yy2arr2 {
  7061  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  7062  				yym7 := z.EncBinary()
  7063  				_ = yym7
  7064  				if false {
  7065  				} else {
  7066  					r.EncodeBool(bool(x.EnforceIndex))
  7067  				}
  7068  			} else {
  7069  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  7070  				r.EncodeString(codecSelferC_UTF8100, string("EnforceIndex"))
  7071  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  7072  				yym8 := z.EncBinary()
  7073  				_ = yym8
  7074  				if false {
  7075  				} else {
  7076  					r.EncodeBool(bool(x.EnforceIndex))
  7077  				}
  7078  			}
  7079  			if yyr2 || yy2arr2 {
  7080  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  7081  				yym10 := z.EncBinary()
  7082  				_ = yym10
  7083  				if false {
  7084  				} else {
  7085  					r.EncodeUint(uint64(x.JobModifyIndex))
  7086  				}
  7087  			} else {
  7088  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  7089  				r.EncodeString(codecSelferC_UTF8100, string("JobModifyIndex"))
  7090  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  7091  				yym11 := z.EncBinary()
  7092  				_ = yym11
  7093  				if false {
  7094  				} else {
  7095  					r.EncodeUint(uint64(x.JobModifyIndex))
  7096  				}
  7097  			}
  7098  			if yyr2 || yy2arr2 {
  7099  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  7100  				yym13 := z.EncBinary()
  7101  				_ = yym13
  7102  				if false {
  7103  				} else {
  7104  					r.EncodeBool(bool(x.PolicyOverride))
  7105  				}
  7106  			} else {
  7107  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  7108  				r.EncodeString(codecSelferC_UTF8100, string("PolicyOverride"))
  7109  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  7110  				yym14 := z.EncBinary()
  7111  				_ = yym14
  7112  				if false {
  7113  				} else {
  7114  					r.EncodeBool(bool(x.PolicyOverride))
  7115  				}
  7116  			}
  7117  			if yyr2 || yy2arr2 {
  7118  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  7119  				yym16 := z.EncBinary()
  7120  				_ = yym16
  7121  				if false {
  7122  				} else {
  7123  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  7124  				}
  7125  			} else {
  7126  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  7127  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  7128  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  7129  				yym17 := z.EncBinary()
  7130  				_ = yym17
  7131  				if false {
  7132  				} else {
  7133  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  7134  				}
  7135  			}
  7136  			if yyr2 || yy2arr2 {
  7137  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  7138  				yym19 := z.EncBinary()
  7139  				_ = yym19
  7140  				if false {
  7141  				} else {
  7142  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  7143  				}
  7144  			} else {
  7145  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  7146  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  7147  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  7148  				yym20 := z.EncBinary()
  7149  				_ = yym20
  7150  				if false {
  7151  				} else {
  7152  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  7153  				}
  7154  			}
  7155  			if yyr2 || yy2arr2 {
  7156  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  7157  				yym22 := z.EncBinary()
  7158  				_ = yym22
  7159  				if false {
  7160  				} else {
  7161  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  7162  				}
  7163  			} else {
  7164  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  7165  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  7166  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  7167  				yym23 := z.EncBinary()
  7168  				_ = yym23
  7169  				if false {
  7170  				} else {
  7171  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  7172  				}
  7173  			}
  7174  			if yyr2 || yy2arr2 {
  7175  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  7176  				yym25 := z.EncBinary()
  7177  				_ = yym25
  7178  				if false {
  7179  				} else {
  7180  					r.EncodeBool(bool(x.Forwarded))
  7181  				}
  7182  			} else {
  7183  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  7184  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  7185  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  7186  				yym26 := z.EncBinary()
  7187  				_ = yym26
  7188  				if false {
  7189  				} else {
  7190  					r.EncodeBool(bool(x.Forwarded))
  7191  				}
  7192  			}
  7193  			if yyr2 || yy2arr2 {
  7194  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  7195  			} else {
  7196  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  7197  			}
  7198  		}
  7199  	}
  7200  }
  7201  
  7202  func (x *JobRegisterRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  7203  	var h codecSelfer100
  7204  	z, r := codec1978.GenHelperDecoder(d)
  7205  	_, _, _ = h, z, r
  7206  	yym1 := z.DecBinary()
  7207  	_ = yym1
  7208  	if false {
  7209  	} else if z.HasExtensions() && z.DecExt(x) {
  7210  	} else {
  7211  		yyct2 := r.ContainerType()
  7212  		if yyct2 == codecSelferValueTypeMap100 {
  7213  			yyl2 := r.ReadMapStart()
  7214  			if yyl2 == 0 {
  7215  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  7216  			} else {
  7217  				x.codecDecodeSelfFromMap(yyl2, d)
  7218  			}
  7219  		} else if yyct2 == codecSelferValueTypeArray100 {
  7220  			yyl2 := r.ReadArrayStart()
  7221  			if yyl2 == 0 {
  7222  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7223  			} else {
  7224  				x.codecDecodeSelfFromArray(yyl2, d)
  7225  			}
  7226  		} else {
  7227  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  7228  		}
  7229  	}
  7230  }
  7231  
  7232  func (x *JobRegisterRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  7233  	var h codecSelfer100
  7234  	z, r := codec1978.GenHelperDecoder(d)
  7235  	_, _, _ = h, z, r
  7236  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  7237  	_ = yys3Slc
  7238  	var yyhl3 bool = l >= 0
  7239  	for yyj3 := 0; ; yyj3++ {
  7240  		if yyhl3 {
  7241  			if yyj3 >= l {
  7242  				break
  7243  			}
  7244  		} else {
  7245  			if r.CheckBreak() {
  7246  				break
  7247  			}
  7248  		}
  7249  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  7250  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  7251  		yys3 := string(yys3Slc)
  7252  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  7253  		switch yys3 {
  7254  		case "Job":
  7255  			if r.TryDecodeAsNil() {
  7256  				if x.Job != nil {
  7257  					x.Job = nil
  7258  				}
  7259  			} else {
  7260  				if x.Job == nil {
  7261  					x.Job = new(Job)
  7262  				}
  7263  				x.Job.CodecDecodeSelf(d)
  7264  			}
  7265  		case "EnforceIndex":
  7266  			if r.TryDecodeAsNil() {
  7267  				x.EnforceIndex = false
  7268  			} else {
  7269  				yyv5 := &x.EnforceIndex
  7270  				yym6 := z.DecBinary()
  7271  				_ = yym6
  7272  				if false {
  7273  				} else {
  7274  					*((*bool)(yyv5)) = r.DecodeBool()
  7275  				}
  7276  			}
  7277  		case "JobModifyIndex":
  7278  			if r.TryDecodeAsNil() {
  7279  				x.JobModifyIndex = 0
  7280  			} else {
  7281  				yyv7 := &x.JobModifyIndex
  7282  				yym8 := z.DecBinary()
  7283  				_ = yym8
  7284  				if false {
  7285  				} else {
  7286  					*((*uint64)(yyv7)) = uint64(r.DecodeUint(64))
  7287  				}
  7288  			}
  7289  		case "PolicyOverride":
  7290  			if r.TryDecodeAsNil() {
  7291  				x.PolicyOverride = false
  7292  			} else {
  7293  				yyv9 := &x.PolicyOverride
  7294  				yym10 := z.DecBinary()
  7295  				_ = yym10
  7296  				if false {
  7297  				} else {
  7298  					*((*bool)(yyv9)) = r.DecodeBool()
  7299  				}
  7300  			}
  7301  		case "Region":
  7302  			if r.TryDecodeAsNil() {
  7303  				x.Region = ""
  7304  			} else {
  7305  				yyv11 := &x.Region
  7306  				yym12 := z.DecBinary()
  7307  				_ = yym12
  7308  				if false {
  7309  				} else {
  7310  					*((*string)(yyv11)) = r.DecodeString()
  7311  				}
  7312  			}
  7313  		case "Namespace":
  7314  			if r.TryDecodeAsNil() {
  7315  				x.Namespace = ""
  7316  			} else {
  7317  				yyv13 := &x.Namespace
  7318  				yym14 := z.DecBinary()
  7319  				_ = yym14
  7320  				if false {
  7321  				} else {
  7322  					*((*string)(yyv13)) = r.DecodeString()
  7323  				}
  7324  			}
  7325  		case "AuthToken":
  7326  			if r.TryDecodeAsNil() {
  7327  				x.AuthToken = ""
  7328  			} else {
  7329  				yyv15 := &x.AuthToken
  7330  				yym16 := z.DecBinary()
  7331  				_ = yym16
  7332  				if false {
  7333  				} else {
  7334  					*((*string)(yyv15)) = r.DecodeString()
  7335  				}
  7336  			}
  7337  		case "Forwarded":
  7338  			if r.TryDecodeAsNil() {
  7339  				x.Forwarded = false
  7340  			} else {
  7341  				yyv17 := &x.Forwarded
  7342  				yym18 := z.DecBinary()
  7343  				_ = yym18
  7344  				if false {
  7345  				} else {
  7346  					*((*bool)(yyv17)) = r.DecodeBool()
  7347  				}
  7348  			}
  7349  		default:
  7350  			z.DecStructFieldNotFound(-1, yys3)
  7351  		} // end switch yys3
  7352  	} // end for yyj3
  7353  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  7354  }
  7355  
  7356  func (x *JobRegisterRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  7357  	var h codecSelfer100
  7358  	z, r := codec1978.GenHelperDecoder(d)
  7359  	_, _, _ = h, z, r
  7360  	var yyj19 int
  7361  	var yyb19 bool
  7362  	var yyhl19 bool = l >= 0
  7363  	yyj19++
  7364  	if yyhl19 {
  7365  		yyb19 = yyj19 > l
  7366  	} else {
  7367  		yyb19 = r.CheckBreak()
  7368  	}
  7369  	if yyb19 {
  7370  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7371  		return
  7372  	}
  7373  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7374  	if r.TryDecodeAsNil() {
  7375  		if x.Job != nil {
  7376  			x.Job = nil
  7377  		}
  7378  	} else {
  7379  		if x.Job == nil {
  7380  			x.Job = new(Job)
  7381  		}
  7382  		x.Job.CodecDecodeSelf(d)
  7383  	}
  7384  	yyj19++
  7385  	if yyhl19 {
  7386  		yyb19 = yyj19 > l
  7387  	} else {
  7388  		yyb19 = r.CheckBreak()
  7389  	}
  7390  	if yyb19 {
  7391  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7392  		return
  7393  	}
  7394  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7395  	if r.TryDecodeAsNil() {
  7396  		x.EnforceIndex = false
  7397  	} else {
  7398  		yyv21 := &x.EnforceIndex
  7399  		yym22 := z.DecBinary()
  7400  		_ = yym22
  7401  		if false {
  7402  		} else {
  7403  			*((*bool)(yyv21)) = r.DecodeBool()
  7404  		}
  7405  	}
  7406  	yyj19++
  7407  	if yyhl19 {
  7408  		yyb19 = yyj19 > l
  7409  	} else {
  7410  		yyb19 = r.CheckBreak()
  7411  	}
  7412  	if yyb19 {
  7413  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7414  		return
  7415  	}
  7416  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7417  	if r.TryDecodeAsNil() {
  7418  		x.JobModifyIndex = 0
  7419  	} else {
  7420  		yyv23 := &x.JobModifyIndex
  7421  		yym24 := z.DecBinary()
  7422  		_ = yym24
  7423  		if false {
  7424  		} else {
  7425  			*((*uint64)(yyv23)) = uint64(r.DecodeUint(64))
  7426  		}
  7427  	}
  7428  	yyj19++
  7429  	if yyhl19 {
  7430  		yyb19 = yyj19 > l
  7431  	} else {
  7432  		yyb19 = r.CheckBreak()
  7433  	}
  7434  	if yyb19 {
  7435  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7436  		return
  7437  	}
  7438  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7439  	if r.TryDecodeAsNil() {
  7440  		x.PolicyOverride = false
  7441  	} else {
  7442  		yyv25 := &x.PolicyOverride
  7443  		yym26 := z.DecBinary()
  7444  		_ = yym26
  7445  		if false {
  7446  		} else {
  7447  			*((*bool)(yyv25)) = r.DecodeBool()
  7448  		}
  7449  	}
  7450  	yyj19++
  7451  	if yyhl19 {
  7452  		yyb19 = yyj19 > l
  7453  	} else {
  7454  		yyb19 = r.CheckBreak()
  7455  	}
  7456  	if yyb19 {
  7457  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7458  		return
  7459  	}
  7460  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7461  	if r.TryDecodeAsNil() {
  7462  		x.Region = ""
  7463  	} else {
  7464  		yyv27 := &x.Region
  7465  		yym28 := z.DecBinary()
  7466  		_ = yym28
  7467  		if false {
  7468  		} else {
  7469  			*((*string)(yyv27)) = r.DecodeString()
  7470  		}
  7471  	}
  7472  	yyj19++
  7473  	if yyhl19 {
  7474  		yyb19 = yyj19 > l
  7475  	} else {
  7476  		yyb19 = r.CheckBreak()
  7477  	}
  7478  	if yyb19 {
  7479  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7480  		return
  7481  	}
  7482  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7483  	if r.TryDecodeAsNil() {
  7484  		x.Namespace = ""
  7485  	} else {
  7486  		yyv29 := &x.Namespace
  7487  		yym30 := z.DecBinary()
  7488  		_ = yym30
  7489  		if false {
  7490  		} else {
  7491  			*((*string)(yyv29)) = r.DecodeString()
  7492  		}
  7493  	}
  7494  	yyj19++
  7495  	if yyhl19 {
  7496  		yyb19 = yyj19 > l
  7497  	} else {
  7498  		yyb19 = r.CheckBreak()
  7499  	}
  7500  	if yyb19 {
  7501  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7502  		return
  7503  	}
  7504  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7505  	if r.TryDecodeAsNil() {
  7506  		x.AuthToken = ""
  7507  	} else {
  7508  		yyv31 := &x.AuthToken
  7509  		yym32 := z.DecBinary()
  7510  		_ = yym32
  7511  		if false {
  7512  		} else {
  7513  			*((*string)(yyv31)) = r.DecodeString()
  7514  		}
  7515  	}
  7516  	yyj19++
  7517  	if yyhl19 {
  7518  		yyb19 = yyj19 > l
  7519  	} else {
  7520  		yyb19 = r.CheckBreak()
  7521  	}
  7522  	if yyb19 {
  7523  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7524  		return
  7525  	}
  7526  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7527  	if r.TryDecodeAsNil() {
  7528  		x.Forwarded = false
  7529  	} else {
  7530  		yyv33 := &x.Forwarded
  7531  		yym34 := z.DecBinary()
  7532  		_ = yym34
  7533  		if false {
  7534  		} else {
  7535  			*((*bool)(yyv33)) = r.DecodeBool()
  7536  		}
  7537  	}
  7538  	for {
  7539  		yyj19++
  7540  		if yyhl19 {
  7541  			yyb19 = yyj19 > l
  7542  		} else {
  7543  			yyb19 = r.CheckBreak()
  7544  		}
  7545  		if yyb19 {
  7546  			break
  7547  		}
  7548  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7549  		z.DecStructFieldNotFound(yyj19-1, "")
  7550  	}
  7551  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7552  }
  7553  
  7554  func (x *JobDeregisterRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  7555  	var h codecSelfer100
  7556  	z, r := codec1978.GenHelperEncoder(e)
  7557  	_, _, _ = h, z, r
  7558  	if x == nil {
  7559  		r.EncodeNil()
  7560  	} else {
  7561  		yym1 := z.EncBinary()
  7562  		_ = yym1
  7563  		if false {
  7564  		} else if z.HasExtensions() && z.EncExt(x) {
  7565  		} else {
  7566  			yysep2 := !z.EncBinary()
  7567  			yy2arr2 := z.EncBasicHandle().StructToArray
  7568  			var yyq2 [6]bool
  7569  			_, _, _ = yysep2, yyq2, yy2arr2
  7570  			const yyr2 bool = false
  7571  			var yynn2 int
  7572  			if yyr2 || yy2arr2 {
  7573  				r.EncodeArrayStart(6)
  7574  			} else {
  7575  				yynn2 = 6
  7576  				for _, b := range yyq2 {
  7577  					if b {
  7578  						yynn2++
  7579  					}
  7580  				}
  7581  				r.EncodeMapStart(yynn2)
  7582  				yynn2 = 0
  7583  			}
  7584  			if yyr2 || yy2arr2 {
  7585  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  7586  				yym4 := z.EncBinary()
  7587  				_ = yym4
  7588  				if false {
  7589  				} else {
  7590  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
  7591  				}
  7592  			} else {
  7593  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  7594  				r.EncodeString(codecSelferC_UTF8100, string("JobID"))
  7595  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  7596  				yym5 := z.EncBinary()
  7597  				_ = yym5
  7598  				if false {
  7599  				} else {
  7600  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
  7601  				}
  7602  			}
  7603  			if yyr2 || yy2arr2 {
  7604  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  7605  				yym7 := z.EncBinary()
  7606  				_ = yym7
  7607  				if false {
  7608  				} else {
  7609  					r.EncodeBool(bool(x.Purge))
  7610  				}
  7611  			} else {
  7612  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  7613  				r.EncodeString(codecSelferC_UTF8100, string("Purge"))
  7614  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  7615  				yym8 := z.EncBinary()
  7616  				_ = yym8
  7617  				if false {
  7618  				} else {
  7619  					r.EncodeBool(bool(x.Purge))
  7620  				}
  7621  			}
  7622  			if yyr2 || yy2arr2 {
  7623  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  7624  				yym10 := z.EncBinary()
  7625  				_ = yym10
  7626  				if false {
  7627  				} else {
  7628  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  7629  				}
  7630  			} else {
  7631  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  7632  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  7633  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  7634  				yym11 := z.EncBinary()
  7635  				_ = yym11
  7636  				if false {
  7637  				} else {
  7638  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  7639  				}
  7640  			}
  7641  			if yyr2 || yy2arr2 {
  7642  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  7643  				yym13 := z.EncBinary()
  7644  				_ = yym13
  7645  				if false {
  7646  				} else {
  7647  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  7648  				}
  7649  			} else {
  7650  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  7651  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  7652  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  7653  				yym14 := z.EncBinary()
  7654  				_ = yym14
  7655  				if false {
  7656  				} else {
  7657  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  7658  				}
  7659  			}
  7660  			if yyr2 || yy2arr2 {
  7661  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  7662  				yym16 := z.EncBinary()
  7663  				_ = yym16
  7664  				if false {
  7665  				} else {
  7666  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  7667  				}
  7668  			} else {
  7669  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  7670  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  7671  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  7672  				yym17 := z.EncBinary()
  7673  				_ = yym17
  7674  				if false {
  7675  				} else {
  7676  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  7677  				}
  7678  			}
  7679  			if yyr2 || yy2arr2 {
  7680  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  7681  				yym19 := z.EncBinary()
  7682  				_ = yym19
  7683  				if false {
  7684  				} else {
  7685  					r.EncodeBool(bool(x.Forwarded))
  7686  				}
  7687  			} else {
  7688  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  7689  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  7690  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  7691  				yym20 := z.EncBinary()
  7692  				_ = yym20
  7693  				if false {
  7694  				} else {
  7695  					r.EncodeBool(bool(x.Forwarded))
  7696  				}
  7697  			}
  7698  			if yyr2 || yy2arr2 {
  7699  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  7700  			} else {
  7701  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  7702  			}
  7703  		}
  7704  	}
  7705  }
  7706  
  7707  func (x *JobDeregisterRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  7708  	var h codecSelfer100
  7709  	z, r := codec1978.GenHelperDecoder(d)
  7710  	_, _, _ = h, z, r
  7711  	yym1 := z.DecBinary()
  7712  	_ = yym1
  7713  	if false {
  7714  	} else if z.HasExtensions() && z.DecExt(x) {
  7715  	} else {
  7716  		yyct2 := r.ContainerType()
  7717  		if yyct2 == codecSelferValueTypeMap100 {
  7718  			yyl2 := r.ReadMapStart()
  7719  			if yyl2 == 0 {
  7720  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  7721  			} else {
  7722  				x.codecDecodeSelfFromMap(yyl2, d)
  7723  			}
  7724  		} else if yyct2 == codecSelferValueTypeArray100 {
  7725  			yyl2 := r.ReadArrayStart()
  7726  			if yyl2 == 0 {
  7727  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7728  			} else {
  7729  				x.codecDecodeSelfFromArray(yyl2, d)
  7730  			}
  7731  		} else {
  7732  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  7733  		}
  7734  	}
  7735  }
  7736  
  7737  func (x *JobDeregisterRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  7738  	var h codecSelfer100
  7739  	z, r := codec1978.GenHelperDecoder(d)
  7740  	_, _, _ = h, z, r
  7741  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  7742  	_ = yys3Slc
  7743  	var yyhl3 bool = l >= 0
  7744  	for yyj3 := 0; ; yyj3++ {
  7745  		if yyhl3 {
  7746  			if yyj3 >= l {
  7747  				break
  7748  			}
  7749  		} else {
  7750  			if r.CheckBreak() {
  7751  				break
  7752  			}
  7753  		}
  7754  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  7755  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  7756  		yys3 := string(yys3Slc)
  7757  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  7758  		switch yys3 {
  7759  		case "JobID":
  7760  			if r.TryDecodeAsNil() {
  7761  				x.JobID = ""
  7762  			} else {
  7763  				yyv4 := &x.JobID
  7764  				yym5 := z.DecBinary()
  7765  				_ = yym5
  7766  				if false {
  7767  				} else {
  7768  					*((*string)(yyv4)) = r.DecodeString()
  7769  				}
  7770  			}
  7771  		case "Purge":
  7772  			if r.TryDecodeAsNil() {
  7773  				x.Purge = false
  7774  			} else {
  7775  				yyv6 := &x.Purge
  7776  				yym7 := z.DecBinary()
  7777  				_ = yym7
  7778  				if false {
  7779  				} else {
  7780  					*((*bool)(yyv6)) = r.DecodeBool()
  7781  				}
  7782  			}
  7783  		case "Region":
  7784  			if r.TryDecodeAsNil() {
  7785  				x.Region = ""
  7786  			} else {
  7787  				yyv8 := &x.Region
  7788  				yym9 := z.DecBinary()
  7789  				_ = yym9
  7790  				if false {
  7791  				} else {
  7792  					*((*string)(yyv8)) = r.DecodeString()
  7793  				}
  7794  			}
  7795  		case "Namespace":
  7796  			if r.TryDecodeAsNil() {
  7797  				x.Namespace = ""
  7798  			} else {
  7799  				yyv10 := &x.Namespace
  7800  				yym11 := z.DecBinary()
  7801  				_ = yym11
  7802  				if false {
  7803  				} else {
  7804  					*((*string)(yyv10)) = r.DecodeString()
  7805  				}
  7806  			}
  7807  		case "AuthToken":
  7808  			if r.TryDecodeAsNil() {
  7809  				x.AuthToken = ""
  7810  			} else {
  7811  				yyv12 := &x.AuthToken
  7812  				yym13 := z.DecBinary()
  7813  				_ = yym13
  7814  				if false {
  7815  				} else {
  7816  					*((*string)(yyv12)) = r.DecodeString()
  7817  				}
  7818  			}
  7819  		case "Forwarded":
  7820  			if r.TryDecodeAsNil() {
  7821  				x.Forwarded = false
  7822  			} else {
  7823  				yyv14 := &x.Forwarded
  7824  				yym15 := z.DecBinary()
  7825  				_ = yym15
  7826  				if false {
  7827  				} else {
  7828  					*((*bool)(yyv14)) = r.DecodeBool()
  7829  				}
  7830  			}
  7831  		default:
  7832  			z.DecStructFieldNotFound(-1, yys3)
  7833  		} // end switch yys3
  7834  	} // end for yyj3
  7835  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  7836  }
  7837  
  7838  func (x *JobDeregisterRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  7839  	var h codecSelfer100
  7840  	z, r := codec1978.GenHelperDecoder(d)
  7841  	_, _, _ = h, z, r
  7842  	var yyj16 int
  7843  	var yyb16 bool
  7844  	var yyhl16 bool = l >= 0
  7845  	yyj16++
  7846  	if yyhl16 {
  7847  		yyb16 = yyj16 > l
  7848  	} else {
  7849  		yyb16 = r.CheckBreak()
  7850  	}
  7851  	if yyb16 {
  7852  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7853  		return
  7854  	}
  7855  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7856  	if r.TryDecodeAsNil() {
  7857  		x.JobID = ""
  7858  	} else {
  7859  		yyv17 := &x.JobID
  7860  		yym18 := z.DecBinary()
  7861  		_ = yym18
  7862  		if false {
  7863  		} else {
  7864  			*((*string)(yyv17)) = r.DecodeString()
  7865  		}
  7866  	}
  7867  	yyj16++
  7868  	if yyhl16 {
  7869  		yyb16 = yyj16 > l
  7870  	} else {
  7871  		yyb16 = r.CheckBreak()
  7872  	}
  7873  	if yyb16 {
  7874  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7875  		return
  7876  	}
  7877  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7878  	if r.TryDecodeAsNil() {
  7879  		x.Purge = false
  7880  	} else {
  7881  		yyv19 := &x.Purge
  7882  		yym20 := z.DecBinary()
  7883  		_ = yym20
  7884  		if false {
  7885  		} else {
  7886  			*((*bool)(yyv19)) = r.DecodeBool()
  7887  		}
  7888  	}
  7889  	yyj16++
  7890  	if yyhl16 {
  7891  		yyb16 = yyj16 > l
  7892  	} else {
  7893  		yyb16 = r.CheckBreak()
  7894  	}
  7895  	if yyb16 {
  7896  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7897  		return
  7898  	}
  7899  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7900  	if r.TryDecodeAsNil() {
  7901  		x.Region = ""
  7902  	} else {
  7903  		yyv21 := &x.Region
  7904  		yym22 := z.DecBinary()
  7905  		_ = yym22
  7906  		if false {
  7907  		} else {
  7908  			*((*string)(yyv21)) = r.DecodeString()
  7909  		}
  7910  	}
  7911  	yyj16++
  7912  	if yyhl16 {
  7913  		yyb16 = yyj16 > l
  7914  	} else {
  7915  		yyb16 = r.CheckBreak()
  7916  	}
  7917  	if yyb16 {
  7918  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7919  		return
  7920  	}
  7921  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7922  	if r.TryDecodeAsNil() {
  7923  		x.Namespace = ""
  7924  	} else {
  7925  		yyv23 := &x.Namespace
  7926  		yym24 := z.DecBinary()
  7927  		_ = yym24
  7928  		if false {
  7929  		} else {
  7930  			*((*string)(yyv23)) = r.DecodeString()
  7931  		}
  7932  	}
  7933  	yyj16++
  7934  	if yyhl16 {
  7935  		yyb16 = yyj16 > l
  7936  	} else {
  7937  		yyb16 = r.CheckBreak()
  7938  	}
  7939  	if yyb16 {
  7940  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7941  		return
  7942  	}
  7943  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7944  	if r.TryDecodeAsNil() {
  7945  		x.AuthToken = ""
  7946  	} else {
  7947  		yyv25 := &x.AuthToken
  7948  		yym26 := z.DecBinary()
  7949  		_ = yym26
  7950  		if false {
  7951  		} else {
  7952  			*((*string)(yyv25)) = r.DecodeString()
  7953  		}
  7954  	}
  7955  	yyj16++
  7956  	if yyhl16 {
  7957  		yyb16 = yyj16 > l
  7958  	} else {
  7959  		yyb16 = r.CheckBreak()
  7960  	}
  7961  	if yyb16 {
  7962  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7963  		return
  7964  	}
  7965  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7966  	if r.TryDecodeAsNil() {
  7967  		x.Forwarded = false
  7968  	} else {
  7969  		yyv27 := &x.Forwarded
  7970  		yym28 := z.DecBinary()
  7971  		_ = yym28
  7972  		if false {
  7973  		} else {
  7974  			*((*bool)(yyv27)) = r.DecodeBool()
  7975  		}
  7976  	}
  7977  	for {
  7978  		yyj16++
  7979  		if yyhl16 {
  7980  			yyb16 = yyj16 > l
  7981  		} else {
  7982  			yyb16 = r.CheckBreak()
  7983  		}
  7984  		if yyb16 {
  7985  			break
  7986  		}
  7987  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  7988  		z.DecStructFieldNotFound(yyj16-1, "")
  7989  	}
  7990  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  7991  }
  7992  
  7993  func (x *JobBatchDeregisterRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  7994  	var h codecSelfer100
  7995  	z, r := codec1978.GenHelperEncoder(e)
  7996  	_, _, _ = h, z, r
  7997  	if x == nil {
  7998  		r.EncodeNil()
  7999  	} else {
  8000  		yym1 := z.EncBinary()
  8001  		_ = yym1
  8002  		if false {
  8003  		} else if z.HasExtensions() && z.EncExt(x) {
  8004  		} else {
  8005  			yysep2 := !z.EncBinary()
  8006  			yy2arr2 := z.EncBasicHandle().StructToArray
  8007  			var yyq2 [6]bool
  8008  			_, _, _ = yysep2, yyq2, yy2arr2
  8009  			const yyr2 bool = false
  8010  			var yynn2 int
  8011  			if yyr2 || yy2arr2 {
  8012  				r.EncodeArrayStart(6)
  8013  			} else {
  8014  				yynn2 = 6
  8015  				for _, b := range yyq2 {
  8016  					if b {
  8017  						yynn2++
  8018  					}
  8019  				}
  8020  				r.EncodeMapStart(yynn2)
  8021  				yynn2 = 0
  8022  			}
  8023  			if yyr2 || yy2arr2 {
  8024  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  8025  				if x.Jobs == nil {
  8026  					r.EncodeNil()
  8027  				} else {
  8028  					yym4 := z.EncBinary()
  8029  					_ = yym4
  8030  					if false {
  8031  					} else {
  8032  						h.encMapNamespacedIDPtrtoJobDeregisterOptions((map[NamespacedID]*JobDeregisterOptions)(x.Jobs), e)
  8033  					}
  8034  				}
  8035  			} else {
  8036  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  8037  				r.EncodeString(codecSelferC_UTF8100, string("Jobs"))
  8038  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  8039  				if x.Jobs == nil {
  8040  					r.EncodeNil()
  8041  				} else {
  8042  					yym5 := z.EncBinary()
  8043  					_ = yym5
  8044  					if false {
  8045  					} else {
  8046  						h.encMapNamespacedIDPtrtoJobDeregisterOptions((map[NamespacedID]*JobDeregisterOptions)(x.Jobs), e)
  8047  					}
  8048  				}
  8049  			}
  8050  			if yyr2 || yy2arr2 {
  8051  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  8052  				if x.Evals == nil {
  8053  					r.EncodeNil()
  8054  				} else {
  8055  					yym7 := z.EncBinary()
  8056  					_ = yym7
  8057  					if false {
  8058  					} else {
  8059  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.Evals), e)
  8060  					}
  8061  				}
  8062  			} else {
  8063  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  8064  				r.EncodeString(codecSelferC_UTF8100, string("Evals"))
  8065  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  8066  				if x.Evals == nil {
  8067  					r.EncodeNil()
  8068  				} else {
  8069  					yym8 := z.EncBinary()
  8070  					_ = yym8
  8071  					if false {
  8072  					} else {
  8073  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.Evals), e)
  8074  					}
  8075  				}
  8076  			}
  8077  			if yyr2 || yy2arr2 {
  8078  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  8079  				yym10 := z.EncBinary()
  8080  				_ = yym10
  8081  				if false {
  8082  				} else {
  8083  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  8084  				}
  8085  			} else {
  8086  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  8087  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  8088  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  8089  				yym11 := z.EncBinary()
  8090  				_ = yym11
  8091  				if false {
  8092  				} else {
  8093  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  8094  				}
  8095  			}
  8096  			if yyr2 || yy2arr2 {
  8097  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  8098  				yym13 := z.EncBinary()
  8099  				_ = yym13
  8100  				if false {
  8101  				} else {
  8102  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  8103  				}
  8104  			} else {
  8105  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  8106  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  8107  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  8108  				yym14 := z.EncBinary()
  8109  				_ = yym14
  8110  				if false {
  8111  				} else {
  8112  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  8113  				}
  8114  			}
  8115  			if yyr2 || yy2arr2 {
  8116  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  8117  				yym16 := z.EncBinary()
  8118  				_ = yym16
  8119  				if false {
  8120  				} else {
  8121  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  8122  				}
  8123  			} else {
  8124  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  8125  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  8126  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  8127  				yym17 := z.EncBinary()
  8128  				_ = yym17
  8129  				if false {
  8130  				} else {
  8131  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  8132  				}
  8133  			}
  8134  			if yyr2 || yy2arr2 {
  8135  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  8136  				yym19 := z.EncBinary()
  8137  				_ = yym19
  8138  				if false {
  8139  				} else {
  8140  					r.EncodeBool(bool(x.Forwarded))
  8141  				}
  8142  			} else {
  8143  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  8144  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  8145  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  8146  				yym20 := z.EncBinary()
  8147  				_ = yym20
  8148  				if false {
  8149  				} else {
  8150  					r.EncodeBool(bool(x.Forwarded))
  8151  				}
  8152  			}
  8153  			if yyr2 || yy2arr2 {
  8154  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  8155  			} else {
  8156  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  8157  			}
  8158  		}
  8159  	}
  8160  }
  8161  
  8162  func (x *JobBatchDeregisterRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  8163  	var h codecSelfer100
  8164  	z, r := codec1978.GenHelperDecoder(d)
  8165  	_, _, _ = h, z, r
  8166  	yym1 := z.DecBinary()
  8167  	_ = yym1
  8168  	if false {
  8169  	} else if z.HasExtensions() && z.DecExt(x) {
  8170  	} else {
  8171  		yyct2 := r.ContainerType()
  8172  		if yyct2 == codecSelferValueTypeMap100 {
  8173  			yyl2 := r.ReadMapStart()
  8174  			if yyl2 == 0 {
  8175  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  8176  			} else {
  8177  				x.codecDecodeSelfFromMap(yyl2, d)
  8178  			}
  8179  		} else if yyct2 == codecSelferValueTypeArray100 {
  8180  			yyl2 := r.ReadArrayStart()
  8181  			if yyl2 == 0 {
  8182  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8183  			} else {
  8184  				x.codecDecodeSelfFromArray(yyl2, d)
  8185  			}
  8186  		} else {
  8187  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  8188  		}
  8189  	}
  8190  }
  8191  
  8192  func (x *JobBatchDeregisterRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  8193  	var h codecSelfer100
  8194  	z, r := codec1978.GenHelperDecoder(d)
  8195  	_, _, _ = h, z, r
  8196  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  8197  	_ = yys3Slc
  8198  	var yyhl3 bool = l >= 0
  8199  	for yyj3 := 0; ; yyj3++ {
  8200  		if yyhl3 {
  8201  			if yyj3 >= l {
  8202  				break
  8203  			}
  8204  		} else {
  8205  			if r.CheckBreak() {
  8206  				break
  8207  			}
  8208  		}
  8209  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  8210  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  8211  		yys3 := string(yys3Slc)
  8212  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  8213  		switch yys3 {
  8214  		case "Jobs":
  8215  			if r.TryDecodeAsNil() {
  8216  				x.Jobs = nil
  8217  			} else {
  8218  				yyv4 := &x.Jobs
  8219  				yym5 := z.DecBinary()
  8220  				_ = yym5
  8221  				if false {
  8222  				} else {
  8223  					h.decMapNamespacedIDPtrtoJobDeregisterOptions((*map[NamespacedID]*JobDeregisterOptions)(yyv4), d)
  8224  				}
  8225  			}
  8226  		case "Evals":
  8227  			if r.TryDecodeAsNil() {
  8228  				x.Evals = nil
  8229  			} else {
  8230  				yyv6 := &x.Evals
  8231  				yym7 := z.DecBinary()
  8232  				_ = yym7
  8233  				if false {
  8234  				} else {
  8235  					h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv6), d)
  8236  				}
  8237  			}
  8238  		case "Region":
  8239  			if r.TryDecodeAsNil() {
  8240  				x.Region = ""
  8241  			} else {
  8242  				yyv8 := &x.Region
  8243  				yym9 := z.DecBinary()
  8244  				_ = yym9
  8245  				if false {
  8246  				} else {
  8247  					*((*string)(yyv8)) = r.DecodeString()
  8248  				}
  8249  			}
  8250  		case "Namespace":
  8251  			if r.TryDecodeAsNil() {
  8252  				x.Namespace = ""
  8253  			} else {
  8254  				yyv10 := &x.Namespace
  8255  				yym11 := z.DecBinary()
  8256  				_ = yym11
  8257  				if false {
  8258  				} else {
  8259  					*((*string)(yyv10)) = r.DecodeString()
  8260  				}
  8261  			}
  8262  		case "AuthToken":
  8263  			if r.TryDecodeAsNil() {
  8264  				x.AuthToken = ""
  8265  			} else {
  8266  				yyv12 := &x.AuthToken
  8267  				yym13 := z.DecBinary()
  8268  				_ = yym13
  8269  				if false {
  8270  				} else {
  8271  					*((*string)(yyv12)) = r.DecodeString()
  8272  				}
  8273  			}
  8274  		case "Forwarded":
  8275  			if r.TryDecodeAsNil() {
  8276  				x.Forwarded = false
  8277  			} else {
  8278  				yyv14 := &x.Forwarded
  8279  				yym15 := z.DecBinary()
  8280  				_ = yym15
  8281  				if false {
  8282  				} else {
  8283  					*((*bool)(yyv14)) = r.DecodeBool()
  8284  				}
  8285  			}
  8286  		default:
  8287  			z.DecStructFieldNotFound(-1, yys3)
  8288  		} // end switch yys3
  8289  	} // end for yyj3
  8290  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  8291  }
  8292  
  8293  func (x *JobBatchDeregisterRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  8294  	var h codecSelfer100
  8295  	z, r := codec1978.GenHelperDecoder(d)
  8296  	_, _, _ = h, z, r
  8297  	var yyj16 int
  8298  	var yyb16 bool
  8299  	var yyhl16 bool = l >= 0
  8300  	yyj16++
  8301  	if yyhl16 {
  8302  		yyb16 = yyj16 > l
  8303  	} else {
  8304  		yyb16 = r.CheckBreak()
  8305  	}
  8306  	if yyb16 {
  8307  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8308  		return
  8309  	}
  8310  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  8311  	if r.TryDecodeAsNil() {
  8312  		x.Jobs = nil
  8313  	} else {
  8314  		yyv17 := &x.Jobs
  8315  		yym18 := z.DecBinary()
  8316  		_ = yym18
  8317  		if false {
  8318  		} else {
  8319  			h.decMapNamespacedIDPtrtoJobDeregisterOptions((*map[NamespacedID]*JobDeregisterOptions)(yyv17), d)
  8320  		}
  8321  	}
  8322  	yyj16++
  8323  	if yyhl16 {
  8324  		yyb16 = yyj16 > l
  8325  	} else {
  8326  		yyb16 = r.CheckBreak()
  8327  	}
  8328  	if yyb16 {
  8329  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8330  		return
  8331  	}
  8332  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  8333  	if r.TryDecodeAsNil() {
  8334  		x.Evals = nil
  8335  	} else {
  8336  		yyv19 := &x.Evals
  8337  		yym20 := z.DecBinary()
  8338  		_ = yym20
  8339  		if false {
  8340  		} else {
  8341  			h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv19), d)
  8342  		}
  8343  	}
  8344  	yyj16++
  8345  	if yyhl16 {
  8346  		yyb16 = yyj16 > l
  8347  	} else {
  8348  		yyb16 = r.CheckBreak()
  8349  	}
  8350  	if yyb16 {
  8351  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8352  		return
  8353  	}
  8354  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  8355  	if r.TryDecodeAsNil() {
  8356  		x.Region = ""
  8357  	} else {
  8358  		yyv21 := &x.Region
  8359  		yym22 := z.DecBinary()
  8360  		_ = yym22
  8361  		if false {
  8362  		} else {
  8363  			*((*string)(yyv21)) = r.DecodeString()
  8364  		}
  8365  	}
  8366  	yyj16++
  8367  	if yyhl16 {
  8368  		yyb16 = yyj16 > l
  8369  	} else {
  8370  		yyb16 = r.CheckBreak()
  8371  	}
  8372  	if yyb16 {
  8373  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8374  		return
  8375  	}
  8376  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  8377  	if r.TryDecodeAsNil() {
  8378  		x.Namespace = ""
  8379  	} else {
  8380  		yyv23 := &x.Namespace
  8381  		yym24 := z.DecBinary()
  8382  		_ = yym24
  8383  		if false {
  8384  		} else {
  8385  			*((*string)(yyv23)) = r.DecodeString()
  8386  		}
  8387  	}
  8388  	yyj16++
  8389  	if yyhl16 {
  8390  		yyb16 = yyj16 > l
  8391  	} else {
  8392  		yyb16 = r.CheckBreak()
  8393  	}
  8394  	if yyb16 {
  8395  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8396  		return
  8397  	}
  8398  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  8399  	if r.TryDecodeAsNil() {
  8400  		x.AuthToken = ""
  8401  	} else {
  8402  		yyv25 := &x.AuthToken
  8403  		yym26 := z.DecBinary()
  8404  		_ = yym26
  8405  		if false {
  8406  		} else {
  8407  			*((*string)(yyv25)) = r.DecodeString()
  8408  		}
  8409  	}
  8410  	yyj16++
  8411  	if yyhl16 {
  8412  		yyb16 = yyj16 > l
  8413  	} else {
  8414  		yyb16 = r.CheckBreak()
  8415  	}
  8416  	if yyb16 {
  8417  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8418  		return
  8419  	}
  8420  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  8421  	if r.TryDecodeAsNil() {
  8422  		x.Forwarded = false
  8423  	} else {
  8424  		yyv27 := &x.Forwarded
  8425  		yym28 := z.DecBinary()
  8426  		_ = yym28
  8427  		if false {
  8428  		} else {
  8429  			*((*bool)(yyv27)) = r.DecodeBool()
  8430  		}
  8431  	}
  8432  	for {
  8433  		yyj16++
  8434  		if yyhl16 {
  8435  			yyb16 = yyj16 > l
  8436  		} else {
  8437  			yyb16 = r.CheckBreak()
  8438  		}
  8439  		if yyb16 {
  8440  			break
  8441  		}
  8442  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  8443  		z.DecStructFieldNotFound(yyj16-1, "")
  8444  	}
  8445  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8446  }
  8447  
  8448  func (x *JobDeregisterOptions) CodecEncodeSelf(e *codec1978.Encoder) {
  8449  	var h codecSelfer100
  8450  	z, r := codec1978.GenHelperEncoder(e)
  8451  	_, _, _ = h, z, r
  8452  	if x == nil {
  8453  		r.EncodeNil()
  8454  	} else {
  8455  		yym1 := z.EncBinary()
  8456  		_ = yym1
  8457  		if false {
  8458  		} else if z.HasExtensions() && z.EncExt(x) {
  8459  		} else {
  8460  			yysep2 := !z.EncBinary()
  8461  			yy2arr2 := z.EncBasicHandle().StructToArray
  8462  			var yyq2 [1]bool
  8463  			_, _, _ = yysep2, yyq2, yy2arr2
  8464  			const yyr2 bool = false
  8465  			var yynn2 int
  8466  			if yyr2 || yy2arr2 {
  8467  				r.EncodeArrayStart(1)
  8468  			} else {
  8469  				yynn2 = 1
  8470  				for _, b := range yyq2 {
  8471  					if b {
  8472  						yynn2++
  8473  					}
  8474  				}
  8475  				r.EncodeMapStart(yynn2)
  8476  				yynn2 = 0
  8477  			}
  8478  			if yyr2 || yy2arr2 {
  8479  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  8480  				yym4 := z.EncBinary()
  8481  				_ = yym4
  8482  				if false {
  8483  				} else {
  8484  					r.EncodeBool(bool(x.Purge))
  8485  				}
  8486  			} else {
  8487  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  8488  				r.EncodeString(codecSelferC_UTF8100, string("Purge"))
  8489  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  8490  				yym5 := z.EncBinary()
  8491  				_ = yym5
  8492  				if false {
  8493  				} else {
  8494  					r.EncodeBool(bool(x.Purge))
  8495  				}
  8496  			}
  8497  			if yyr2 || yy2arr2 {
  8498  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  8499  			} else {
  8500  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  8501  			}
  8502  		}
  8503  	}
  8504  }
  8505  
  8506  func (x *JobDeregisterOptions) CodecDecodeSelf(d *codec1978.Decoder) {
  8507  	var h codecSelfer100
  8508  	z, r := codec1978.GenHelperDecoder(d)
  8509  	_, _, _ = h, z, r
  8510  	yym1 := z.DecBinary()
  8511  	_ = yym1
  8512  	if false {
  8513  	} else if z.HasExtensions() && z.DecExt(x) {
  8514  	} else {
  8515  		yyct2 := r.ContainerType()
  8516  		if yyct2 == codecSelferValueTypeMap100 {
  8517  			yyl2 := r.ReadMapStart()
  8518  			if yyl2 == 0 {
  8519  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  8520  			} else {
  8521  				x.codecDecodeSelfFromMap(yyl2, d)
  8522  			}
  8523  		} else if yyct2 == codecSelferValueTypeArray100 {
  8524  			yyl2 := r.ReadArrayStart()
  8525  			if yyl2 == 0 {
  8526  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8527  			} else {
  8528  				x.codecDecodeSelfFromArray(yyl2, d)
  8529  			}
  8530  		} else {
  8531  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  8532  		}
  8533  	}
  8534  }
  8535  
  8536  func (x *JobDeregisterOptions) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  8537  	var h codecSelfer100
  8538  	z, r := codec1978.GenHelperDecoder(d)
  8539  	_, _, _ = h, z, r
  8540  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  8541  	_ = yys3Slc
  8542  	var yyhl3 bool = l >= 0
  8543  	for yyj3 := 0; ; yyj3++ {
  8544  		if yyhl3 {
  8545  			if yyj3 >= l {
  8546  				break
  8547  			}
  8548  		} else {
  8549  			if r.CheckBreak() {
  8550  				break
  8551  			}
  8552  		}
  8553  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  8554  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  8555  		yys3 := string(yys3Slc)
  8556  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  8557  		switch yys3 {
  8558  		case "Purge":
  8559  			if r.TryDecodeAsNil() {
  8560  				x.Purge = false
  8561  			} else {
  8562  				yyv4 := &x.Purge
  8563  				yym5 := z.DecBinary()
  8564  				_ = yym5
  8565  				if false {
  8566  				} else {
  8567  					*((*bool)(yyv4)) = r.DecodeBool()
  8568  				}
  8569  			}
  8570  		default:
  8571  			z.DecStructFieldNotFound(-1, yys3)
  8572  		} // end switch yys3
  8573  	} // end for yyj3
  8574  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  8575  }
  8576  
  8577  func (x *JobDeregisterOptions) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  8578  	var h codecSelfer100
  8579  	z, r := codec1978.GenHelperDecoder(d)
  8580  	_, _, _ = h, z, r
  8581  	var yyj6 int
  8582  	var yyb6 bool
  8583  	var yyhl6 bool = l >= 0
  8584  	yyj6++
  8585  	if yyhl6 {
  8586  		yyb6 = yyj6 > l
  8587  	} else {
  8588  		yyb6 = r.CheckBreak()
  8589  	}
  8590  	if yyb6 {
  8591  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8592  		return
  8593  	}
  8594  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  8595  	if r.TryDecodeAsNil() {
  8596  		x.Purge = false
  8597  	} else {
  8598  		yyv7 := &x.Purge
  8599  		yym8 := z.DecBinary()
  8600  		_ = yym8
  8601  		if false {
  8602  		} else {
  8603  			*((*bool)(yyv7)) = r.DecodeBool()
  8604  		}
  8605  	}
  8606  	for {
  8607  		yyj6++
  8608  		if yyhl6 {
  8609  			yyb6 = yyj6 > l
  8610  		} else {
  8611  			yyb6 = r.CheckBreak()
  8612  		}
  8613  		if yyb6 {
  8614  			break
  8615  		}
  8616  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  8617  		z.DecStructFieldNotFound(yyj6-1, "")
  8618  	}
  8619  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8620  }
  8621  
  8622  func (x *JobEvaluateRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  8623  	var h codecSelfer100
  8624  	z, r := codec1978.GenHelperEncoder(e)
  8625  	_, _, _ = h, z, r
  8626  	if x == nil {
  8627  		r.EncodeNil()
  8628  	} else {
  8629  		yym1 := z.EncBinary()
  8630  		_ = yym1
  8631  		if false {
  8632  		} else if z.HasExtensions() && z.EncExt(x) {
  8633  		} else {
  8634  			yysep2 := !z.EncBinary()
  8635  			yy2arr2 := z.EncBasicHandle().StructToArray
  8636  			var yyq2 [5]bool
  8637  			_, _, _ = yysep2, yyq2, yy2arr2
  8638  			const yyr2 bool = false
  8639  			var yynn2 int
  8640  			if yyr2 || yy2arr2 {
  8641  				r.EncodeArrayStart(5)
  8642  			} else {
  8643  				yynn2 = 5
  8644  				for _, b := range yyq2 {
  8645  					if b {
  8646  						yynn2++
  8647  					}
  8648  				}
  8649  				r.EncodeMapStart(yynn2)
  8650  				yynn2 = 0
  8651  			}
  8652  			if yyr2 || yy2arr2 {
  8653  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  8654  				yym4 := z.EncBinary()
  8655  				_ = yym4
  8656  				if false {
  8657  				} else {
  8658  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
  8659  				}
  8660  			} else {
  8661  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  8662  				r.EncodeString(codecSelferC_UTF8100, string("JobID"))
  8663  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  8664  				yym5 := z.EncBinary()
  8665  				_ = yym5
  8666  				if false {
  8667  				} else {
  8668  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
  8669  				}
  8670  			}
  8671  			if yyr2 || yy2arr2 {
  8672  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  8673  				yym7 := z.EncBinary()
  8674  				_ = yym7
  8675  				if false {
  8676  				} else {
  8677  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  8678  				}
  8679  			} else {
  8680  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  8681  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  8682  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  8683  				yym8 := z.EncBinary()
  8684  				_ = yym8
  8685  				if false {
  8686  				} else {
  8687  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  8688  				}
  8689  			}
  8690  			if yyr2 || yy2arr2 {
  8691  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  8692  				yym10 := z.EncBinary()
  8693  				_ = yym10
  8694  				if false {
  8695  				} else {
  8696  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  8697  				}
  8698  			} else {
  8699  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  8700  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  8701  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  8702  				yym11 := z.EncBinary()
  8703  				_ = yym11
  8704  				if false {
  8705  				} else {
  8706  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  8707  				}
  8708  			}
  8709  			if yyr2 || yy2arr2 {
  8710  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  8711  				yym13 := z.EncBinary()
  8712  				_ = yym13
  8713  				if false {
  8714  				} else {
  8715  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  8716  				}
  8717  			} else {
  8718  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  8719  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  8720  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  8721  				yym14 := z.EncBinary()
  8722  				_ = yym14
  8723  				if false {
  8724  				} else {
  8725  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  8726  				}
  8727  			}
  8728  			if yyr2 || yy2arr2 {
  8729  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  8730  				yym16 := z.EncBinary()
  8731  				_ = yym16
  8732  				if false {
  8733  				} else {
  8734  					r.EncodeBool(bool(x.Forwarded))
  8735  				}
  8736  			} else {
  8737  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  8738  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  8739  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  8740  				yym17 := z.EncBinary()
  8741  				_ = yym17
  8742  				if false {
  8743  				} else {
  8744  					r.EncodeBool(bool(x.Forwarded))
  8745  				}
  8746  			}
  8747  			if yyr2 || yy2arr2 {
  8748  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  8749  			} else {
  8750  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  8751  			}
  8752  		}
  8753  	}
  8754  }
  8755  
  8756  func (x *JobEvaluateRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  8757  	var h codecSelfer100
  8758  	z, r := codec1978.GenHelperDecoder(d)
  8759  	_, _, _ = h, z, r
  8760  	yym1 := z.DecBinary()
  8761  	_ = yym1
  8762  	if false {
  8763  	} else if z.HasExtensions() && z.DecExt(x) {
  8764  	} else {
  8765  		yyct2 := r.ContainerType()
  8766  		if yyct2 == codecSelferValueTypeMap100 {
  8767  			yyl2 := r.ReadMapStart()
  8768  			if yyl2 == 0 {
  8769  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  8770  			} else {
  8771  				x.codecDecodeSelfFromMap(yyl2, d)
  8772  			}
  8773  		} else if yyct2 == codecSelferValueTypeArray100 {
  8774  			yyl2 := r.ReadArrayStart()
  8775  			if yyl2 == 0 {
  8776  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8777  			} else {
  8778  				x.codecDecodeSelfFromArray(yyl2, d)
  8779  			}
  8780  		} else {
  8781  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  8782  		}
  8783  	}
  8784  }
  8785  
  8786  func (x *JobEvaluateRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  8787  	var h codecSelfer100
  8788  	z, r := codec1978.GenHelperDecoder(d)
  8789  	_, _, _ = h, z, r
  8790  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  8791  	_ = yys3Slc
  8792  	var yyhl3 bool = l >= 0
  8793  	for yyj3 := 0; ; yyj3++ {
  8794  		if yyhl3 {
  8795  			if yyj3 >= l {
  8796  				break
  8797  			}
  8798  		} else {
  8799  			if r.CheckBreak() {
  8800  				break
  8801  			}
  8802  		}
  8803  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  8804  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  8805  		yys3 := string(yys3Slc)
  8806  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  8807  		switch yys3 {
  8808  		case "JobID":
  8809  			if r.TryDecodeAsNil() {
  8810  				x.JobID = ""
  8811  			} else {
  8812  				yyv4 := &x.JobID
  8813  				yym5 := z.DecBinary()
  8814  				_ = yym5
  8815  				if false {
  8816  				} else {
  8817  					*((*string)(yyv4)) = r.DecodeString()
  8818  				}
  8819  			}
  8820  		case "Region":
  8821  			if r.TryDecodeAsNil() {
  8822  				x.Region = ""
  8823  			} else {
  8824  				yyv6 := &x.Region
  8825  				yym7 := z.DecBinary()
  8826  				_ = yym7
  8827  				if false {
  8828  				} else {
  8829  					*((*string)(yyv6)) = r.DecodeString()
  8830  				}
  8831  			}
  8832  		case "Namespace":
  8833  			if r.TryDecodeAsNil() {
  8834  				x.Namespace = ""
  8835  			} else {
  8836  				yyv8 := &x.Namespace
  8837  				yym9 := z.DecBinary()
  8838  				_ = yym9
  8839  				if false {
  8840  				} else {
  8841  					*((*string)(yyv8)) = r.DecodeString()
  8842  				}
  8843  			}
  8844  		case "AuthToken":
  8845  			if r.TryDecodeAsNil() {
  8846  				x.AuthToken = ""
  8847  			} else {
  8848  				yyv10 := &x.AuthToken
  8849  				yym11 := z.DecBinary()
  8850  				_ = yym11
  8851  				if false {
  8852  				} else {
  8853  					*((*string)(yyv10)) = r.DecodeString()
  8854  				}
  8855  			}
  8856  		case "Forwarded":
  8857  			if r.TryDecodeAsNil() {
  8858  				x.Forwarded = false
  8859  			} else {
  8860  				yyv12 := &x.Forwarded
  8861  				yym13 := z.DecBinary()
  8862  				_ = yym13
  8863  				if false {
  8864  				} else {
  8865  					*((*bool)(yyv12)) = r.DecodeBool()
  8866  				}
  8867  			}
  8868  		default:
  8869  			z.DecStructFieldNotFound(-1, yys3)
  8870  		} // end switch yys3
  8871  	} // end for yyj3
  8872  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  8873  }
  8874  
  8875  func (x *JobEvaluateRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  8876  	var h codecSelfer100
  8877  	z, r := codec1978.GenHelperDecoder(d)
  8878  	_, _, _ = h, z, r
  8879  	var yyj14 int
  8880  	var yyb14 bool
  8881  	var yyhl14 bool = l >= 0
  8882  	yyj14++
  8883  	if yyhl14 {
  8884  		yyb14 = yyj14 > l
  8885  	} else {
  8886  		yyb14 = r.CheckBreak()
  8887  	}
  8888  	if yyb14 {
  8889  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8890  		return
  8891  	}
  8892  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  8893  	if r.TryDecodeAsNil() {
  8894  		x.JobID = ""
  8895  	} else {
  8896  		yyv15 := &x.JobID
  8897  		yym16 := z.DecBinary()
  8898  		_ = yym16
  8899  		if false {
  8900  		} else {
  8901  			*((*string)(yyv15)) = r.DecodeString()
  8902  		}
  8903  	}
  8904  	yyj14++
  8905  	if yyhl14 {
  8906  		yyb14 = yyj14 > l
  8907  	} else {
  8908  		yyb14 = r.CheckBreak()
  8909  	}
  8910  	if yyb14 {
  8911  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8912  		return
  8913  	}
  8914  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  8915  	if r.TryDecodeAsNil() {
  8916  		x.Region = ""
  8917  	} else {
  8918  		yyv17 := &x.Region
  8919  		yym18 := z.DecBinary()
  8920  		_ = yym18
  8921  		if false {
  8922  		} else {
  8923  			*((*string)(yyv17)) = r.DecodeString()
  8924  		}
  8925  	}
  8926  	yyj14++
  8927  	if yyhl14 {
  8928  		yyb14 = yyj14 > l
  8929  	} else {
  8930  		yyb14 = r.CheckBreak()
  8931  	}
  8932  	if yyb14 {
  8933  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8934  		return
  8935  	}
  8936  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  8937  	if r.TryDecodeAsNil() {
  8938  		x.Namespace = ""
  8939  	} else {
  8940  		yyv19 := &x.Namespace
  8941  		yym20 := z.DecBinary()
  8942  		_ = yym20
  8943  		if false {
  8944  		} else {
  8945  			*((*string)(yyv19)) = r.DecodeString()
  8946  		}
  8947  	}
  8948  	yyj14++
  8949  	if yyhl14 {
  8950  		yyb14 = yyj14 > l
  8951  	} else {
  8952  		yyb14 = r.CheckBreak()
  8953  	}
  8954  	if yyb14 {
  8955  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8956  		return
  8957  	}
  8958  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  8959  	if r.TryDecodeAsNil() {
  8960  		x.AuthToken = ""
  8961  	} else {
  8962  		yyv21 := &x.AuthToken
  8963  		yym22 := z.DecBinary()
  8964  		_ = yym22
  8965  		if false {
  8966  		} else {
  8967  			*((*string)(yyv21)) = r.DecodeString()
  8968  		}
  8969  	}
  8970  	yyj14++
  8971  	if yyhl14 {
  8972  		yyb14 = yyj14 > l
  8973  	} else {
  8974  		yyb14 = r.CheckBreak()
  8975  	}
  8976  	if yyb14 {
  8977  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  8978  		return
  8979  	}
  8980  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  8981  	if r.TryDecodeAsNil() {
  8982  		x.Forwarded = false
  8983  	} else {
  8984  		yyv23 := &x.Forwarded
  8985  		yym24 := z.DecBinary()
  8986  		_ = yym24
  8987  		if false {
  8988  		} else {
  8989  			*((*bool)(yyv23)) = r.DecodeBool()
  8990  		}
  8991  	}
  8992  	for {
  8993  		yyj14++
  8994  		if yyhl14 {
  8995  			yyb14 = yyj14 > l
  8996  		} else {
  8997  			yyb14 = r.CheckBreak()
  8998  		}
  8999  		if yyb14 {
  9000  			break
  9001  		}
  9002  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  9003  		z.DecStructFieldNotFound(yyj14-1, "")
  9004  	}
  9005  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  9006  }
  9007  
  9008  func (x *JobSpecificRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  9009  	var h codecSelfer100
  9010  	z, r := codec1978.GenHelperEncoder(e)
  9011  	_, _, _ = h, z, r
  9012  	if x == nil {
  9013  		r.EncodeNil()
  9014  	} else {
  9015  		yym1 := z.EncBinary()
  9016  		_ = yym1
  9017  		if false {
  9018  		} else if z.HasExtensions() && z.EncExt(x) {
  9019  		} else {
  9020  			yysep2 := !z.EncBinary()
  9021  			yy2arr2 := z.EncBasicHandle().StructToArray
  9022  			var yyq2 [10]bool
  9023  			_, _, _ = yysep2, yyq2, yy2arr2
  9024  			const yyr2 bool = false
  9025  			var yynn2 int
  9026  			if yyr2 || yy2arr2 {
  9027  				r.EncodeArrayStart(10)
  9028  			} else {
  9029  				yynn2 = 10
  9030  				for _, b := range yyq2 {
  9031  					if b {
  9032  						yynn2++
  9033  					}
  9034  				}
  9035  				r.EncodeMapStart(yynn2)
  9036  				yynn2 = 0
  9037  			}
  9038  			if yyr2 || yy2arr2 {
  9039  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9040  				yym4 := z.EncBinary()
  9041  				_ = yym4
  9042  				if false {
  9043  				} else {
  9044  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
  9045  				}
  9046  			} else {
  9047  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9048  				r.EncodeString(codecSelferC_UTF8100, string("JobID"))
  9049  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9050  				yym5 := z.EncBinary()
  9051  				_ = yym5
  9052  				if false {
  9053  				} else {
  9054  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
  9055  				}
  9056  			}
  9057  			if yyr2 || yy2arr2 {
  9058  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9059  				yym7 := z.EncBinary()
  9060  				_ = yym7
  9061  				if false {
  9062  				} else {
  9063  					r.EncodeBool(bool(x.AllAllocs))
  9064  				}
  9065  			} else {
  9066  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9067  				r.EncodeString(codecSelferC_UTF8100, string("AllAllocs"))
  9068  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9069  				yym8 := z.EncBinary()
  9070  				_ = yym8
  9071  				if false {
  9072  				} else {
  9073  					r.EncodeBool(bool(x.AllAllocs))
  9074  				}
  9075  			}
  9076  			if yyr2 || yy2arr2 {
  9077  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9078  				yym10 := z.EncBinary()
  9079  				_ = yym10
  9080  				if false {
  9081  				} else {
  9082  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  9083  				}
  9084  			} else {
  9085  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9086  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  9087  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9088  				yym11 := z.EncBinary()
  9089  				_ = yym11
  9090  				if false {
  9091  				} else {
  9092  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  9093  				}
  9094  			}
  9095  			if yyr2 || yy2arr2 {
  9096  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9097  				yym13 := z.EncBinary()
  9098  				_ = yym13
  9099  				if false {
  9100  				} else {
  9101  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  9102  				}
  9103  			} else {
  9104  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9105  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  9106  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9107  				yym14 := z.EncBinary()
  9108  				_ = yym14
  9109  				if false {
  9110  				} else {
  9111  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  9112  				}
  9113  			}
  9114  			if yyr2 || yy2arr2 {
  9115  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9116  				yym16 := z.EncBinary()
  9117  				_ = yym16
  9118  				if false {
  9119  				} else {
  9120  					r.EncodeUint(uint64(x.MinQueryIndex))
  9121  				}
  9122  			} else {
  9123  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9124  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
  9125  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9126  				yym17 := z.EncBinary()
  9127  				_ = yym17
  9128  				if false {
  9129  				} else {
  9130  					r.EncodeUint(uint64(x.MinQueryIndex))
  9131  				}
  9132  			}
  9133  			if yyr2 || yy2arr2 {
  9134  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9135  				yym19 := z.EncBinary()
  9136  				_ = yym19
  9137  				if false {
  9138  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
  9139  				} else {
  9140  					r.EncodeInt(int64(x.MaxQueryTime))
  9141  				}
  9142  			} else {
  9143  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9144  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
  9145  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9146  				yym20 := z.EncBinary()
  9147  				_ = yym20
  9148  				if false {
  9149  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
  9150  				} else {
  9151  					r.EncodeInt(int64(x.MaxQueryTime))
  9152  				}
  9153  			}
  9154  			if yyr2 || yy2arr2 {
  9155  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9156  				yym22 := z.EncBinary()
  9157  				_ = yym22
  9158  				if false {
  9159  				} else {
  9160  					r.EncodeBool(bool(x.AllowStale))
  9161  				}
  9162  			} else {
  9163  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9164  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
  9165  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9166  				yym23 := z.EncBinary()
  9167  				_ = yym23
  9168  				if false {
  9169  				} else {
  9170  					r.EncodeBool(bool(x.AllowStale))
  9171  				}
  9172  			}
  9173  			if yyr2 || yy2arr2 {
  9174  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9175  				yym25 := z.EncBinary()
  9176  				_ = yym25
  9177  				if false {
  9178  				} else {
  9179  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
  9180  				}
  9181  			} else {
  9182  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9183  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
  9184  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9185  				yym26 := z.EncBinary()
  9186  				_ = yym26
  9187  				if false {
  9188  				} else {
  9189  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
  9190  				}
  9191  			}
  9192  			if yyr2 || yy2arr2 {
  9193  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9194  				yym28 := z.EncBinary()
  9195  				_ = yym28
  9196  				if false {
  9197  				} else {
  9198  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  9199  				}
  9200  			} else {
  9201  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9202  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  9203  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9204  				yym29 := z.EncBinary()
  9205  				_ = yym29
  9206  				if false {
  9207  				} else {
  9208  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  9209  				}
  9210  			}
  9211  			if yyr2 || yy2arr2 {
  9212  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9213  				yym31 := z.EncBinary()
  9214  				_ = yym31
  9215  				if false {
  9216  				} else {
  9217  					r.EncodeBool(bool(x.Forwarded))
  9218  				}
  9219  			} else {
  9220  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9221  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  9222  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9223  				yym32 := z.EncBinary()
  9224  				_ = yym32
  9225  				if false {
  9226  				} else {
  9227  					r.EncodeBool(bool(x.Forwarded))
  9228  				}
  9229  			}
  9230  			if yyr2 || yy2arr2 {
  9231  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  9232  			} else {
  9233  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  9234  			}
  9235  		}
  9236  	}
  9237  }
  9238  
  9239  func (x *JobSpecificRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  9240  	var h codecSelfer100
  9241  	z, r := codec1978.GenHelperDecoder(d)
  9242  	_, _, _ = h, z, r
  9243  	yym1 := z.DecBinary()
  9244  	_ = yym1
  9245  	if false {
  9246  	} else if z.HasExtensions() && z.DecExt(x) {
  9247  	} else {
  9248  		yyct2 := r.ContainerType()
  9249  		if yyct2 == codecSelferValueTypeMap100 {
  9250  			yyl2 := r.ReadMapStart()
  9251  			if yyl2 == 0 {
  9252  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  9253  			} else {
  9254  				x.codecDecodeSelfFromMap(yyl2, d)
  9255  			}
  9256  		} else if yyct2 == codecSelferValueTypeArray100 {
  9257  			yyl2 := r.ReadArrayStart()
  9258  			if yyl2 == 0 {
  9259  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  9260  			} else {
  9261  				x.codecDecodeSelfFromArray(yyl2, d)
  9262  			}
  9263  		} else {
  9264  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  9265  		}
  9266  	}
  9267  }
  9268  
  9269  func (x *JobSpecificRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  9270  	var h codecSelfer100
  9271  	z, r := codec1978.GenHelperDecoder(d)
  9272  	_, _, _ = h, z, r
  9273  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  9274  	_ = yys3Slc
  9275  	var yyhl3 bool = l >= 0
  9276  	for yyj3 := 0; ; yyj3++ {
  9277  		if yyhl3 {
  9278  			if yyj3 >= l {
  9279  				break
  9280  			}
  9281  		} else {
  9282  			if r.CheckBreak() {
  9283  				break
  9284  			}
  9285  		}
  9286  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  9287  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  9288  		yys3 := string(yys3Slc)
  9289  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  9290  		switch yys3 {
  9291  		case "JobID":
  9292  			if r.TryDecodeAsNil() {
  9293  				x.JobID = ""
  9294  			} else {
  9295  				yyv4 := &x.JobID
  9296  				yym5 := z.DecBinary()
  9297  				_ = yym5
  9298  				if false {
  9299  				} else {
  9300  					*((*string)(yyv4)) = r.DecodeString()
  9301  				}
  9302  			}
  9303  		case "AllAllocs":
  9304  			if r.TryDecodeAsNil() {
  9305  				x.AllAllocs = false
  9306  			} else {
  9307  				yyv6 := &x.AllAllocs
  9308  				yym7 := z.DecBinary()
  9309  				_ = yym7
  9310  				if false {
  9311  				} else {
  9312  					*((*bool)(yyv6)) = r.DecodeBool()
  9313  				}
  9314  			}
  9315  		case "Region":
  9316  			if r.TryDecodeAsNil() {
  9317  				x.Region = ""
  9318  			} else {
  9319  				yyv8 := &x.Region
  9320  				yym9 := z.DecBinary()
  9321  				_ = yym9
  9322  				if false {
  9323  				} else {
  9324  					*((*string)(yyv8)) = r.DecodeString()
  9325  				}
  9326  			}
  9327  		case "Namespace":
  9328  			if r.TryDecodeAsNil() {
  9329  				x.Namespace = ""
  9330  			} else {
  9331  				yyv10 := &x.Namespace
  9332  				yym11 := z.DecBinary()
  9333  				_ = yym11
  9334  				if false {
  9335  				} else {
  9336  					*((*string)(yyv10)) = r.DecodeString()
  9337  				}
  9338  			}
  9339  		case "MinQueryIndex":
  9340  			if r.TryDecodeAsNil() {
  9341  				x.MinQueryIndex = 0
  9342  			} else {
  9343  				yyv12 := &x.MinQueryIndex
  9344  				yym13 := z.DecBinary()
  9345  				_ = yym13
  9346  				if false {
  9347  				} else {
  9348  					*((*uint64)(yyv12)) = uint64(r.DecodeUint(64))
  9349  				}
  9350  			}
  9351  		case "MaxQueryTime":
  9352  			if r.TryDecodeAsNil() {
  9353  				x.MaxQueryTime = 0
  9354  			} else {
  9355  				yyv14 := &x.MaxQueryTime
  9356  				yym15 := z.DecBinary()
  9357  				_ = yym15
  9358  				if false {
  9359  				} else if z.HasExtensions() && z.DecExt(yyv14) {
  9360  				} else {
  9361  					*((*int64)(yyv14)) = int64(r.DecodeInt(64))
  9362  				}
  9363  			}
  9364  		case "AllowStale":
  9365  			if r.TryDecodeAsNil() {
  9366  				x.AllowStale = false
  9367  			} else {
  9368  				yyv16 := &x.AllowStale
  9369  				yym17 := z.DecBinary()
  9370  				_ = yym17
  9371  				if false {
  9372  				} else {
  9373  					*((*bool)(yyv16)) = r.DecodeBool()
  9374  				}
  9375  			}
  9376  		case "Prefix":
  9377  			if r.TryDecodeAsNil() {
  9378  				x.Prefix = ""
  9379  			} else {
  9380  				yyv18 := &x.Prefix
  9381  				yym19 := z.DecBinary()
  9382  				_ = yym19
  9383  				if false {
  9384  				} else {
  9385  					*((*string)(yyv18)) = r.DecodeString()
  9386  				}
  9387  			}
  9388  		case "AuthToken":
  9389  			if r.TryDecodeAsNil() {
  9390  				x.AuthToken = ""
  9391  			} else {
  9392  				yyv20 := &x.AuthToken
  9393  				yym21 := z.DecBinary()
  9394  				_ = yym21
  9395  				if false {
  9396  				} else {
  9397  					*((*string)(yyv20)) = r.DecodeString()
  9398  				}
  9399  			}
  9400  		case "Forwarded":
  9401  			if r.TryDecodeAsNil() {
  9402  				x.Forwarded = false
  9403  			} else {
  9404  				yyv22 := &x.Forwarded
  9405  				yym23 := z.DecBinary()
  9406  				_ = yym23
  9407  				if false {
  9408  				} else {
  9409  					*((*bool)(yyv22)) = r.DecodeBool()
  9410  				}
  9411  			}
  9412  		default:
  9413  			z.DecStructFieldNotFound(-1, yys3)
  9414  		} // end switch yys3
  9415  	} // end for yyj3
  9416  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
  9417  }
  9418  
  9419  func (x *JobSpecificRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
  9420  	var h codecSelfer100
  9421  	z, r := codec1978.GenHelperDecoder(d)
  9422  	_, _, _ = h, z, r
  9423  	var yyj24 int
  9424  	var yyb24 bool
  9425  	var yyhl24 bool = l >= 0
  9426  	yyj24++
  9427  	if yyhl24 {
  9428  		yyb24 = yyj24 > l
  9429  	} else {
  9430  		yyb24 = r.CheckBreak()
  9431  	}
  9432  	if yyb24 {
  9433  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  9434  		return
  9435  	}
  9436  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  9437  	if r.TryDecodeAsNil() {
  9438  		x.JobID = ""
  9439  	} else {
  9440  		yyv25 := &x.JobID
  9441  		yym26 := z.DecBinary()
  9442  		_ = yym26
  9443  		if false {
  9444  		} else {
  9445  			*((*string)(yyv25)) = r.DecodeString()
  9446  		}
  9447  	}
  9448  	yyj24++
  9449  	if yyhl24 {
  9450  		yyb24 = yyj24 > l
  9451  	} else {
  9452  		yyb24 = r.CheckBreak()
  9453  	}
  9454  	if yyb24 {
  9455  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  9456  		return
  9457  	}
  9458  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  9459  	if r.TryDecodeAsNil() {
  9460  		x.AllAllocs = false
  9461  	} else {
  9462  		yyv27 := &x.AllAllocs
  9463  		yym28 := z.DecBinary()
  9464  		_ = yym28
  9465  		if false {
  9466  		} else {
  9467  			*((*bool)(yyv27)) = r.DecodeBool()
  9468  		}
  9469  	}
  9470  	yyj24++
  9471  	if yyhl24 {
  9472  		yyb24 = yyj24 > l
  9473  	} else {
  9474  		yyb24 = r.CheckBreak()
  9475  	}
  9476  	if yyb24 {
  9477  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  9478  		return
  9479  	}
  9480  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  9481  	if r.TryDecodeAsNil() {
  9482  		x.Region = ""
  9483  	} else {
  9484  		yyv29 := &x.Region
  9485  		yym30 := z.DecBinary()
  9486  		_ = yym30
  9487  		if false {
  9488  		} else {
  9489  			*((*string)(yyv29)) = r.DecodeString()
  9490  		}
  9491  	}
  9492  	yyj24++
  9493  	if yyhl24 {
  9494  		yyb24 = yyj24 > l
  9495  	} else {
  9496  		yyb24 = r.CheckBreak()
  9497  	}
  9498  	if yyb24 {
  9499  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  9500  		return
  9501  	}
  9502  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  9503  	if r.TryDecodeAsNil() {
  9504  		x.Namespace = ""
  9505  	} else {
  9506  		yyv31 := &x.Namespace
  9507  		yym32 := z.DecBinary()
  9508  		_ = yym32
  9509  		if false {
  9510  		} else {
  9511  			*((*string)(yyv31)) = r.DecodeString()
  9512  		}
  9513  	}
  9514  	yyj24++
  9515  	if yyhl24 {
  9516  		yyb24 = yyj24 > l
  9517  	} else {
  9518  		yyb24 = r.CheckBreak()
  9519  	}
  9520  	if yyb24 {
  9521  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  9522  		return
  9523  	}
  9524  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  9525  	if r.TryDecodeAsNil() {
  9526  		x.MinQueryIndex = 0
  9527  	} else {
  9528  		yyv33 := &x.MinQueryIndex
  9529  		yym34 := z.DecBinary()
  9530  		_ = yym34
  9531  		if false {
  9532  		} else {
  9533  			*((*uint64)(yyv33)) = uint64(r.DecodeUint(64))
  9534  		}
  9535  	}
  9536  	yyj24++
  9537  	if yyhl24 {
  9538  		yyb24 = yyj24 > l
  9539  	} else {
  9540  		yyb24 = r.CheckBreak()
  9541  	}
  9542  	if yyb24 {
  9543  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  9544  		return
  9545  	}
  9546  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  9547  	if r.TryDecodeAsNil() {
  9548  		x.MaxQueryTime = 0
  9549  	} else {
  9550  		yyv35 := &x.MaxQueryTime
  9551  		yym36 := z.DecBinary()
  9552  		_ = yym36
  9553  		if false {
  9554  		} else if z.HasExtensions() && z.DecExt(yyv35) {
  9555  		} else {
  9556  			*((*int64)(yyv35)) = int64(r.DecodeInt(64))
  9557  		}
  9558  	}
  9559  	yyj24++
  9560  	if yyhl24 {
  9561  		yyb24 = yyj24 > l
  9562  	} else {
  9563  		yyb24 = r.CheckBreak()
  9564  	}
  9565  	if yyb24 {
  9566  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  9567  		return
  9568  	}
  9569  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  9570  	if r.TryDecodeAsNil() {
  9571  		x.AllowStale = false
  9572  	} else {
  9573  		yyv37 := &x.AllowStale
  9574  		yym38 := z.DecBinary()
  9575  		_ = yym38
  9576  		if false {
  9577  		} else {
  9578  			*((*bool)(yyv37)) = r.DecodeBool()
  9579  		}
  9580  	}
  9581  	yyj24++
  9582  	if yyhl24 {
  9583  		yyb24 = yyj24 > l
  9584  	} else {
  9585  		yyb24 = r.CheckBreak()
  9586  	}
  9587  	if yyb24 {
  9588  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  9589  		return
  9590  	}
  9591  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  9592  	if r.TryDecodeAsNil() {
  9593  		x.Prefix = ""
  9594  	} else {
  9595  		yyv39 := &x.Prefix
  9596  		yym40 := z.DecBinary()
  9597  		_ = yym40
  9598  		if false {
  9599  		} else {
  9600  			*((*string)(yyv39)) = r.DecodeString()
  9601  		}
  9602  	}
  9603  	yyj24++
  9604  	if yyhl24 {
  9605  		yyb24 = yyj24 > l
  9606  	} else {
  9607  		yyb24 = r.CheckBreak()
  9608  	}
  9609  	if yyb24 {
  9610  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  9611  		return
  9612  	}
  9613  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  9614  	if r.TryDecodeAsNil() {
  9615  		x.AuthToken = ""
  9616  	} else {
  9617  		yyv41 := &x.AuthToken
  9618  		yym42 := z.DecBinary()
  9619  		_ = yym42
  9620  		if false {
  9621  		} else {
  9622  			*((*string)(yyv41)) = r.DecodeString()
  9623  		}
  9624  	}
  9625  	yyj24++
  9626  	if yyhl24 {
  9627  		yyb24 = yyj24 > l
  9628  	} else {
  9629  		yyb24 = r.CheckBreak()
  9630  	}
  9631  	if yyb24 {
  9632  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  9633  		return
  9634  	}
  9635  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
  9636  	if r.TryDecodeAsNil() {
  9637  		x.Forwarded = false
  9638  	} else {
  9639  		yyv43 := &x.Forwarded
  9640  		yym44 := z.DecBinary()
  9641  		_ = yym44
  9642  		if false {
  9643  		} else {
  9644  			*((*bool)(yyv43)) = r.DecodeBool()
  9645  		}
  9646  	}
  9647  	for {
  9648  		yyj24++
  9649  		if yyhl24 {
  9650  			yyb24 = yyj24 > l
  9651  		} else {
  9652  			yyb24 = r.CheckBreak()
  9653  		}
  9654  		if yyb24 {
  9655  			break
  9656  		}
  9657  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
  9658  		z.DecStructFieldNotFound(yyj24-1, "")
  9659  	}
  9660  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  9661  }
  9662  
  9663  func (x *JobListRequest) CodecEncodeSelf(e *codec1978.Encoder) {
  9664  	var h codecSelfer100
  9665  	z, r := codec1978.GenHelperEncoder(e)
  9666  	_, _, _ = h, z, r
  9667  	if x == nil {
  9668  		r.EncodeNil()
  9669  	} else {
  9670  		yym1 := z.EncBinary()
  9671  		_ = yym1
  9672  		if false {
  9673  		} else if z.HasExtensions() && z.EncExt(x) {
  9674  		} else {
  9675  			yysep2 := !z.EncBinary()
  9676  			yy2arr2 := z.EncBasicHandle().StructToArray
  9677  			var yyq2 [8]bool
  9678  			_, _, _ = yysep2, yyq2, yy2arr2
  9679  			const yyr2 bool = false
  9680  			var yynn2 int
  9681  			if yyr2 || yy2arr2 {
  9682  				r.EncodeArrayStart(8)
  9683  			} else {
  9684  				yynn2 = 8
  9685  				for _, b := range yyq2 {
  9686  					if b {
  9687  						yynn2++
  9688  					}
  9689  				}
  9690  				r.EncodeMapStart(yynn2)
  9691  				yynn2 = 0
  9692  			}
  9693  			if yyr2 || yy2arr2 {
  9694  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9695  				yym4 := z.EncBinary()
  9696  				_ = yym4
  9697  				if false {
  9698  				} else {
  9699  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  9700  				}
  9701  			} else {
  9702  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9703  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
  9704  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9705  				yym5 := z.EncBinary()
  9706  				_ = yym5
  9707  				if false {
  9708  				} else {
  9709  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
  9710  				}
  9711  			}
  9712  			if yyr2 || yy2arr2 {
  9713  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9714  				yym7 := z.EncBinary()
  9715  				_ = yym7
  9716  				if false {
  9717  				} else {
  9718  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  9719  				}
  9720  			} else {
  9721  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9722  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
  9723  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9724  				yym8 := z.EncBinary()
  9725  				_ = yym8
  9726  				if false {
  9727  				} else {
  9728  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
  9729  				}
  9730  			}
  9731  			if yyr2 || yy2arr2 {
  9732  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9733  				yym10 := z.EncBinary()
  9734  				_ = yym10
  9735  				if false {
  9736  				} else {
  9737  					r.EncodeUint(uint64(x.MinQueryIndex))
  9738  				}
  9739  			} else {
  9740  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9741  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
  9742  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9743  				yym11 := z.EncBinary()
  9744  				_ = yym11
  9745  				if false {
  9746  				} else {
  9747  					r.EncodeUint(uint64(x.MinQueryIndex))
  9748  				}
  9749  			}
  9750  			if yyr2 || yy2arr2 {
  9751  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9752  				yym13 := z.EncBinary()
  9753  				_ = yym13
  9754  				if false {
  9755  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
  9756  				} else {
  9757  					r.EncodeInt(int64(x.MaxQueryTime))
  9758  				}
  9759  			} else {
  9760  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9761  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
  9762  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9763  				yym14 := z.EncBinary()
  9764  				_ = yym14
  9765  				if false {
  9766  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
  9767  				} else {
  9768  					r.EncodeInt(int64(x.MaxQueryTime))
  9769  				}
  9770  			}
  9771  			if yyr2 || yy2arr2 {
  9772  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9773  				yym16 := z.EncBinary()
  9774  				_ = yym16
  9775  				if false {
  9776  				} else {
  9777  					r.EncodeBool(bool(x.AllowStale))
  9778  				}
  9779  			} else {
  9780  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9781  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
  9782  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9783  				yym17 := z.EncBinary()
  9784  				_ = yym17
  9785  				if false {
  9786  				} else {
  9787  					r.EncodeBool(bool(x.AllowStale))
  9788  				}
  9789  			}
  9790  			if yyr2 || yy2arr2 {
  9791  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9792  				yym19 := z.EncBinary()
  9793  				_ = yym19
  9794  				if false {
  9795  				} else {
  9796  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
  9797  				}
  9798  			} else {
  9799  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9800  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
  9801  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9802  				yym20 := z.EncBinary()
  9803  				_ = yym20
  9804  				if false {
  9805  				} else {
  9806  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
  9807  				}
  9808  			}
  9809  			if yyr2 || yy2arr2 {
  9810  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9811  				yym22 := z.EncBinary()
  9812  				_ = yym22
  9813  				if false {
  9814  				} else {
  9815  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  9816  				}
  9817  			} else {
  9818  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9819  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
  9820  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9821  				yym23 := z.EncBinary()
  9822  				_ = yym23
  9823  				if false {
  9824  				} else {
  9825  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
  9826  				}
  9827  			}
  9828  			if yyr2 || yy2arr2 {
  9829  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
  9830  				yym25 := z.EncBinary()
  9831  				_ = yym25
  9832  				if false {
  9833  				} else {
  9834  					r.EncodeBool(bool(x.Forwarded))
  9835  				}
  9836  			} else {
  9837  				z.EncSendContainerState(codecSelfer_containerMapKey100)
  9838  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
  9839  				z.EncSendContainerState(codecSelfer_containerMapValue100)
  9840  				yym26 := z.EncBinary()
  9841  				_ = yym26
  9842  				if false {
  9843  				} else {
  9844  					r.EncodeBool(bool(x.Forwarded))
  9845  				}
  9846  			}
  9847  			if yyr2 || yy2arr2 {
  9848  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
  9849  			} else {
  9850  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
  9851  			}
  9852  		}
  9853  	}
  9854  }
  9855  
  9856  func (x *JobListRequest) CodecDecodeSelf(d *codec1978.Decoder) {
  9857  	var h codecSelfer100
  9858  	z, r := codec1978.GenHelperDecoder(d)
  9859  	_, _, _ = h, z, r
  9860  	yym1 := z.DecBinary()
  9861  	_ = yym1
  9862  	if false {
  9863  	} else if z.HasExtensions() && z.DecExt(x) {
  9864  	} else {
  9865  		yyct2 := r.ContainerType()
  9866  		if yyct2 == codecSelferValueTypeMap100 {
  9867  			yyl2 := r.ReadMapStart()
  9868  			if yyl2 == 0 {
  9869  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
  9870  			} else {
  9871  				x.codecDecodeSelfFromMap(yyl2, d)
  9872  			}
  9873  		} else if yyct2 == codecSelferValueTypeArray100 {
  9874  			yyl2 := r.ReadArrayStart()
  9875  			if yyl2 == 0 {
  9876  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
  9877  			} else {
  9878  				x.codecDecodeSelfFromArray(yyl2, d)
  9879  			}
  9880  		} else {
  9881  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
  9882  		}
  9883  	}
  9884  }
  9885  
  9886  func (x *JobListRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
  9887  	var h codecSelfer100
  9888  	z, r := codec1978.GenHelperDecoder(d)
  9889  	_, _, _ = h, z, r
  9890  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
  9891  	_ = yys3Slc
  9892  	var yyhl3 bool = l >= 0
  9893  	for yyj3 := 0; ; yyj3++ {
  9894  		if yyhl3 {
  9895  			if yyj3 >= l {
  9896  				break
  9897  			}
  9898  		} else {
  9899  			if r.CheckBreak() {
  9900  				break
  9901  			}
  9902  		}
  9903  		z.DecSendContainerState(codecSelfer_containerMapKey100)
  9904  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
  9905  		yys3 := string(yys3Slc)
  9906  		z.DecSendContainerState(codecSelfer_containerMapValue100)
  9907  		switch yys3 {
  9908  		case "Region":
  9909  			if r.TryDecodeAsNil() {
  9910  				x.Region = ""
  9911  			} else {
  9912  				yyv4 := &x.Region
  9913  				yym5 := z.DecBinary()
  9914  				_ = yym5
  9915  				if false {
  9916  				} else {
  9917  					*((*string)(yyv4)) = r.DecodeString()
  9918  				}
  9919  			}
  9920  		case "Namespace":
  9921  			if r.TryDecodeAsNil() {
  9922  				x.Namespace = ""
  9923  			} else {
  9924  				yyv6 := &x.Namespace
  9925  				yym7 := z.DecBinary()
  9926  				_ = yym7
  9927  				if false {
  9928  				} else {
  9929  					*((*string)(yyv6)) = r.DecodeString()
  9930  				}
  9931  			}
  9932  		case "MinQueryIndex":
  9933  			if r.TryDecodeAsNil() {
  9934  				x.MinQueryIndex = 0
  9935  			} else {
  9936  				yyv8 := &x.MinQueryIndex
  9937  				yym9 := z.DecBinary()
  9938  				_ = yym9
  9939  				if false {
  9940  				} else {
  9941  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
  9942  				}
  9943  			}
  9944  		case "MaxQueryTime":
  9945  			if r.TryDecodeAsNil() {
  9946  				x.MaxQueryTime = 0
  9947  			} else {
  9948  				yyv10 := &x.MaxQueryTime
  9949  				yym11 := z.DecBinary()
  9950  				_ = yym11
  9951  				if false {
  9952  				} else if z.HasExtensions() && z.DecExt(yyv10) {
  9953  				} else {
  9954  					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
  9955  				}
  9956  			}
  9957  		case "AllowStale":
  9958  			if r.TryDecodeAsNil() {
  9959  				x.AllowStale = false
  9960  			} else {
  9961  				yyv12 := &x.AllowStale
  9962  				yym13 := z.DecBinary()
  9963  				_ = yym13
  9964  				if false {
  9965  				} else {
  9966  					*((*bool)(yyv12)) = r.DecodeBool()
  9967  				}
  9968  			}
  9969  		case "Prefix":
  9970  			if r.TryDecodeAsNil() {
  9971  				x.Prefix = ""
  9972  			} else {
  9973  				yyv14 := &x.Prefix
  9974  				yym15 := z.DecBinary()
  9975  				_ = yym15
  9976  				if false {
  9977  				} else {
  9978  					*((*string)(yyv14)) = r.DecodeString()
  9979  				}
  9980  			}
  9981  		case "AuthToken":
  9982  			if r.TryDecodeAsNil() {
  9983  				x.AuthToken = ""
  9984  			} else {
  9985  				yyv16 := &x.AuthToken
  9986  				yym17 := z.DecBinary()
  9987  				_ = yym17
  9988  				if false {
  9989  				} else {
  9990  					*((*string)(yyv16)) = r.DecodeString()
  9991  				}
  9992  			}
  9993  		case "Forwarded":
  9994  			if r.TryDecodeAsNil() {
  9995  				x.Forwarded = false
  9996  			} else {
  9997  				yyv18 := &x.Forwarded
  9998  				yym19 := z.DecBinary()
  9999  				_ = yym19
 10000  				if false {
 10001  				} else {
 10002  					*((*bool)(yyv18)) = r.DecodeBool()
 10003  				}
 10004  			}
 10005  		default:
 10006  			z.DecStructFieldNotFound(-1, yys3)
 10007  		} // end switch yys3
 10008  	} // end for yyj3
 10009  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 10010  }
 10011  
 10012  func (x *JobListRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 10013  	var h codecSelfer100
 10014  	z, r := codec1978.GenHelperDecoder(d)
 10015  	_, _, _ = h, z, r
 10016  	var yyj20 int
 10017  	var yyb20 bool
 10018  	var yyhl20 bool = l >= 0
 10019  	yyj20++
 10020  	if yyhl20 {
 10021  		yyb20 = yyj20 > l
 10022  	} else {
 10023  		yyb20 = r.CheckBreak()
 10024  	}
 10025  	if yyb20 {
 10026  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10027  		return
 10028  	}
 10029  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10030  	if r.TryDecodeAsNil() {
 10031  		x.Region = ""
 10032  	} else {
 10033  		yyv21 := &x.Region
 10034  		yym22 := z.DecBinary()
 10035  		_ = yym22
 10036  		if false {
 10037  		} else {
 10038  			*((*string)(yyv21)) = r.DecodeString()
 10039  		}
 10040  	}
 10041  	yyj20++
 10042  	if yyhl20 {
 10043  		yyb20 = yyj20 > l
 10044  	} else {
 10045  		yyb20 = r.CheckBreak()
 10046  	}
 10047  	if yyb20 {
 10048  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10049  		return
 10050  	}
 10051  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10052  	if r.TryDecodeAsNil() {
 10053  		x.Namespace = ""
 10054  	} else {
 10055  		yyv23 := &x.Namespace
 10056  		yym24 := z.DecBinary()
 10057  		_ = yym24
 10058  		if false {
 10059  		} else {
 10060  			*((*string)(yyv23)) = r.DecodeString()
 10061  		}
 10062  	}
 10063  	yyj20++
 10064  	if yyhl20 {
 10065  		yyb20 = yyj20 > l
 10066  	} else {
 10067  		yyb20 = r.CheckBreak()
 10068  	}
 10069  	if yyb20 {
 10070  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10071  		return
 10072  	}
 10073  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10074  	if r.TryDecodeAsNil() {
 10075  		x.MinQueryIndex = 0
 10076  	} else {
 10077  		yyv25 := &x.MinQueryIndex
 10078  		yym26 := z.DecBinary()
 10079  		_ = yym26
 10080  		if false {
 10081  		} else {
 10082  			*((*uint64)(yyv25)) = uint64(r.DecodeUint(64))
 10083  		}
 10084  	}
 10085  	yyj20++
 10086  	if yyhl20 {
 10087  		yyb20 = yyj20 > l
 10088  	} else {
 10089  		yyb20 = r.CheckBreak()
 10090  	}
 10091  	if yyb20 {
 10092  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10093  		return
 10094  	}
 10095  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10096  	if r.TryDecodeAsNil() {
 10097  		x.MaxQueryTime = 0
 10098  	} else {
 10099  		yyv27 := &x.MaxQueryTime
 10100  		yym28 := z.DecBinary()
 10101  		_ = yym28
 10102  		if false {
 10103  		} else if z.HasExtensions() && z.DecExt(yyv27) {
 10104  		} else {
 10105  			*((*int64)(yyv27)) = int64(r.DecodeInt(64))
 10106  		}
 10107  	}
 10108  	yyj20++
 10109  	if yyhl20 {
 10110  		yyb20 = yyj20 > l
 10111  	} else {
 10112  		yyb20 = r.CheckBreak()
 10113  	}
 10114  	if yyb20 {
 10115  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10116  		return
 10117  	}
 10118  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10119  	if r.TryDecodeAsNil() {
 10120  		x.AllowStale = false
 10121  	} else {
 10122  		yyv29 := &x.AllowStale
 10123  		yym30 := z.DecBinary()
 10124  		_ = yym30
 10125  		if false {
 10126  		} else {
 10127  			*((*bool)(yyv29)) = r.DecodeBool()
 10128  		}
 10129  	}
 10130  	yyj20++
 10131  	if yyhl20 {
 10132  		yyb20 = yyj20 > l
 10133  	} else {
 10134  		yyb20 = r.CheckBreak()
 10135  	}
 10136  	if yyb20 {
 10137  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10138  		return
 10139  	}
 10140  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10141  	if r.TryDecodeAsNil() {
 10142  		x.Prefix = ""
 10143  	} else {
 10144  		yyv31 := &x.Prefix
 10145  		yym32 := z.DecBinary()
 10146  		_ = yym32
 10147  		if false {
 10148  		} else {
 10149  			*((*string)(yyv31)) = r.DecodeString()
 10150  		}
 10151  	}
 10152  	yyj20++
 10153  	if yyhl20 {
 10154  		yyb20 = yyj20 > l
 10155  	} else {
 10156  		yyb20 = r.CheckBreak()
 10157  	}
 10158  	if yyb20 {
 10159  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10160  		return
 10161  	}
 10162  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10163  	if r.TryDecodeAsNil() {
 10164  		x.AuthToken = ""
 10165  	} else {
 10166  		yyv33 := &x.AuthToken
 10167  		yym34 := z.DecBinary()
 10168  		_ = yym34
 10169  		if false {
 10170  		} else {
 10171  			*((*string)(yyv33)) = r.DecodeString()
 10172  		}
 10173  	}
 10174  	yyj20++
 10175  	if yyhl20 {
 10176  		yyb20 = yyj20 > l
 10177  	} else {
 10178  		yyb20 = r.CheckBreak()
 10179  	}
 10180  	if yyb20 {
 10181  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10182  		return
 10183  	}
 10184  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10185  	if r.TryDecodeAsNil() {
 10186  		x.Forwarded = false
 10187  	} else {
 10188  		yyv35 := &x.Forwarded
 10189  		yym36 := z.DecBinary()
 10190  		_ = yym36
 10191  		if false {
 10192  		} else {
 10193  			*((*bool)(yyv35)) = r.DecodeBool()
 10194  		}
 10195  	}
 10196  	for {
 10197  		yyj20++
 10198  		if yyhl20 {
 10199  			yyb20 = yyj20 > l
 10200  		} else {
 10201  			yyb20 = r.CheckBreak()
 10202  		}
 10203  		if yyb20 {
 10204  			break
 10205  		}
 10206  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10207  		z.DecStructFieldNotFound(yyj20-1, "")
 10208  	}
 10209  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10210  }
 10211  
 10212  func (x *JobPlanRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 10213  	var h codecSelfer100
 10214  	z, r := codec1978.GenHelperEncoder(e)
 10215  	_, _, _ = h, z, r
 10216  	if x == nil {
 10217  		r.EncodeNil()
 10218  	} else {
 10219  		yym1 := z.EncBinary()
 10220  		_ = yym1
 10221  		if false {
 10222  		} else if z.HasExtensions() && z.EncExt(x) {
 10223  		} else {
 10224  			yysep2 := !z.EncBinary()
 10225  			yy2arr2 := z.EncBasicHandle().StructToArray
 10226  			var yyq2 [7]bool
 10227  			_, _, _ = yysep2, yyq2, yy2arr2
 10228  			const yyr2 bool = false
 10229  			var yynn2 int
 10230  			if yyr2 || yy2arr2 {
 10231  				r.EncodeArrayStart(7)
 10232  			} else {
 10233  				yynn2 = 7
 10234  				for _, b := range yyq2 {
 10235  					if b {
 10236  						yynn2++
 10237  					}
 10238  				}
 10239  				r.EncodeMapStart(yynn2)
 10240  				yynn2 = 0
 10241  			}
 10242  			if yyr2 || yy2arr2 {
 10243  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10244  				if x.Job == nil {
 10245  					r.EncodeNil()
 10246  				} else {
 10247  					x.Job.CodecEncodeSelf(e)
 10248  				}
 10249  			} else {
 10250  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10251  				r.EncodeString(codecSelferC_UTF8100, string("Job"))
 10252  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10253  				if x.Job == nil {
 10254  					r.EncodeNil()
 10255  				} else {
 10256  					x.Job.CodecEncodeSelf(e)
 10257  				}
 10258  			}
 10259  			if yyr2 || yy2arr2 {
 10260  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10261  				yym7 := z.EncBinary()
 10262  				_ = yym7
 10263  				if false {
 10264  				} else {
 10265  					r.EncodeBool(bool(x.Diff))
 10266  				}
 10267  			} else {
 10268  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10269  				r.EncodeString(codecSelferC_UTF8100, string("Diff"))
 10270  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10271  				yym8 := z.EncBinary()
 10272  				_ = yym8
 10273  				if false {
 10274  				} else {
 10275  					r.EncodeBool(bool(x.Diff))
 10276  				}
 10277  			}
 10278  			if yyr2 || yy2arr2 {
 10279  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10280  				yym10 := z.EncBinary()
 10281  				_ = yym10
 10282  				if false {
 10283  				} else {
 10284  					r.EncodeBool(bool(x.PolicyOverride))
 10285  				}
 10286  			} else {
 10287  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10288  				r.EncodeString(codecSelferC_UTF8100, string("PolicyOverride"))
 10289  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10290  				yym11 := z.EncBinary()
 10291  				_ = yym11
 10292  				if false {
 10293  				} else {
 10294  					r.EncodeBool(bool(x.PolicyOverride))
 10295  				}
 10296  			}
 10297  			if yyr2 || yy2arr2 {
 10298  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10299  				yym13 := z.EncBinary()
 10300  				_ = yym13
 10301  				if false {
 10302  				} else {
 10303  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 10304  				}
 10305  			} else {
 10306  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10307  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 10308  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10309  				yym14 := z.EncBinary()
 10310  				_ = yym14
 10311  				if false {
 10312  				} else {
 10313  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 10314  				}
 10315  			}
 10316  			if yyr2 || yy2arr2 {
 10317  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10318  				yym16 := z.EncBinary()
 10319  				_ = yym16
 10320  				if false {
 10321  				} else {
 10322  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 10323  				}
 10324  			} else {
 10325  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10326  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 10327  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10328  				yym17 := z.EncBinary()
 10329  				_ = yym17
 10330  				if false {
 10331  				} else {
 10332  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 10333  				}
 10334  			}
 10335  			if yyr2 || yy2arr2 {
 10336  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10337  				yym19 := z.EncBinary()
 10338  				_ = yym19
 10339  				if false {
 10340  				} else {
 10341  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 10342  				}
 10343  			} else {
 10344  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10345  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 10346  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10347  				yym20 := z.EncBinary()
 10348  				_ = yym20
 10349  				if false {
 10350  				} else {
 10351  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 10352  				}
 10353  			}
 10354  			if yyr2 || yy2arr2 {
 10355  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10356  				yym22 := z.EncBinary()
 10357  				_ = yym22
 10358  				if false {
 10359  				} else {
 10360  					r.EncodeBool(bool(x.Forwarded))
 10361  				}
 10362  			} else {
 10363  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10364  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 10365  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10366  				yym23 := z.EncBinary()
 10367  				_ = yym23
 10368  				if false {
 10369  				} else {
 10370  					r.EncodeBool(bool(x.Forwarded))
 10371  				}
 10372  			}
 10373  			if yyr2 || yy2arr2 {
 10374  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 10375  			} else {
 10376  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 10377  			}
 10378  		}
 10379  	}
 10380  }
 10381  
 10382  func (x *JobPlanRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 10383  	var h codecSelfer100
 10384  	z, r := codec1978.GenHelperDecoder(d)
 10385  	_, _, _ = h, z, r
 10386  	yym1 := z.DecBinary()
 10387  	_ = yym1
 10388  	if false {
 10389  	} else if z.HasExtensions() && z.DecExt(x) {
 10390  	} else {
 10391  		yyct2 := r.ContainerType()
 10392  		if yyct2 == codecSelferValueTypeMap100 {
 10393  			yyl2 := r.ReadMapStart()
 10394  			if yyl2 == 0 {
 10395  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 10396  			} else {
 10397  				x.codecDecodeSelfFromMap(yyl2, d)
 10398  			}
 10399  		} else if yyct2 == codecSelferValueTypeArray100 {
 10400  			yyl2 := r.ReadArrayStart()
 10401  			if yyl2 == 0 {
 10402  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10403  			} else {
 10404  				x.codecDecodeSelfFromArray(yyl2, d)
 10405  			}
 10406  		} else {
 10407  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 10408  		}
 10409  	}
 10410  }
 10411  
 10412  func (x *JobPlanRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 10413  	var h codecSelfer100
 10414  	z, r := codec1978.GenHelperDecoder(d)
 10415  	_, _, _ = h, z, r
 10416  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 10417  	_ = yys3Slc
 10418  	var yyhl3 bool = l >= 0
 10419  	for yyj3 := 0; ; yyj3++ {
 10420  		if yyhl3 {
 10421  			if yyj3 >= l {
 10422  				break
 10423  			}
 10424  		} else {
 10425  			if r.CheckBreak() {
 10426  				break
 10427  			}
 10428  		}
 10429  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 10430  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 10431  		yys3 := string(yys3Slc)
 10432  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 10433  		switch yys3 {
 10434  		case "Job":
 10435  			if r.TryDecodeAsNil() {
 10436  				if x.Job != nil {
 10437  					x.Job = nil
 10438  				}
 10439  			} else {
 10440  				if x.Job == nil {
 10441  					x.Job = new(Job)
 10442  				}
 10443  				x.Job.CodecDecodeSelf(d)
 10444  			}
 10445  		case "Diff":
 10446  			if r.TryDecodeAsNil() {
 10447  				x.Diff = false
 10448  			} else {
 10449  				yyv5 := &x.Diff
 10450  				yym6 := z.DecBinary()
 10451  				_ = yym6
 10452  				if false {
 10453  				} else {
 10454  					*((*bool)(yyv5)) = r.DecodeBool()
 10455  				}
 10456  			}
 10457  		case "PolicyOverride":
 10458  			if r.TryDecodeAsNil() {
 10459  				x.PolicyOverride = false
 10460  			} else {
 10461  				yyv7 := &x.PolicyOverride
 10462  				yym8 := z.DecBinary()
 10463  				_ = yym8
 10464  				if false {
 10465  				} else {
 10466  					*((*bool)(yyv7)) = r.DecodeBool()
 10467  				}
 10468  			}
 10469  		case "Region":
 10470  			if r.TryDecodeAsNil() {
 10471  				x.Region = ""
 10472  			} else {
 10473  				yyv9 := &x.Region
 10474  				yym10 := z.DecBinary()
 10475  				_ = yym10
 10476  				if false {
 10477  				} else {
 10478  					*((*string)(yyv9)) = r.DecodeString()
 10479  				}
 10480  			}
 10481  		case "Namespace":
 10482  			if r.TryDecodeAsNil() {
 10483  				x.Namespace = ""
 10484  			} else {
 10485  				yyv11 := &x.Namespace
 10486  				yym12 := z.DecBinary()
 10487  				_ = yym12
 10488  				if false {
 10489  				} else {
 10490  					*((*string)(yyv11)) = r.DecodeString()
 10491  				}
 10492  			}
 10493  		case "AuthToken":
 10494  			if r.TryDecodeAsNil() {
 10495  				x.AuthToken = ""
 10496  			} else {
 10497  				yyv13 := &x.AuthToken
 10498  				yym14 := z.DecBinary()
 10499  				_ = yym14
 10500  				if false {
 10501  				} else {
 10502  					*((*string)(yyv13)) = r.DecodeString()
 10503  				}
 10504  			}
 10505  		case "Forwarded":
 10506  			if r.TryDecodeAsNil() {
 10507  				x.Forwarded = false
 10508  			} else {
 10509  				yyv15 := &x.Forwarded
 10510  				yym16 := z.DecBinary()
 10511  				_ = yym16
 10512  				if false {
 10513  				} else {
 10514  					*((*bool)(yyv15)) = r.DecodeBool()
 10515  				}
 10516  			}
 10517  		default:
 10518  			z.DecStructFieldNotFound(-1, yys3)
 10519  		} // end switch yys3
 10520  	} // end for yyj3
 10521  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 10522  }
 10523  
 10524  func (x *JobPlanRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 10525  	var h codecSelfer100
 10526  	z, r := codec1978.GenHelperDecoder(d)
 10527  	_, _, _ = h, z, r
 10528  	var yyj17 int
 10529  	var yyb17 bool
 10530  	var yyhl17 bool = l >= 0
 10531  	yyj17++
 10532  	if yyhl17 {
 10533  		yyb17 = yyj17 > l
 10534  	} else {
 10535  		yyb17 = r.CheckBreak()
 10536  	}
 10537  	if yyb17 {
 10538  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10539  		return
 10540  	}
 10541  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10542  	if r.TryDecodeAsNil() {
 10543  		if x.Job != nil {
 10544  			x.Job = nil
 10545  		}
 10546  	} else {
 10547  		if x.Job == nil {
 10548  			x.Job = new(Job)
 10549  		}
 10550  		x.Job.CodecDecodeSelf(d)
 10551  	}
 10552  	yyj17++
 10553  	if yyhl17 {
 10554  		yyb17 = yyj17 > l
 10555  	} else {
 10556  		yyb17 = r.CheckBreak()
 10557  	}
 10558  	if yyb17 {
 10559  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10560  		return
 10561  	}
 10562  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10563  	if r.TryDecodeAsNil() {
 10564  		x.Diff = false
 10565  	} else {
 10566  		yyv19 := &x.Diff
 10567  		yym20 := z.DecBinary()
 10568  		_ = yym20
 10569  		if false {
 10570  		} else {
 10571  			*((*bool)(yyv19)) = r.DecodeBool()
 10572  		}
 10573  	}
 10574  	yyj17++
 10575  	if yyhl17 {
 10576  		yyb17 = yyj17 > l
 10577  	} else {
 10578  		yyb17 = r.CheckBreak()
 10579  	}
 10580  	if yyb17 {
 10581  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10582  		return
 10583  	}
 10584  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10585  	if r.TryDecodeAsNil() {
 10586  		x.PolicyOverride = false
 10587  	} else {
 10588  		yyv21 := &x.PolicyOverride
 10589  		yym22 := z.DecBinary()
 10590  		_ = yym22
 10591  		if false {
 10592  		} else {
 10593  			*((*bool)(yyv21)) = r.DecodeBool()
 10594  		}
 10595  	}
 10596  	yyj17++
 10597  	if yyhl17 {
 10598  		yyb17 = yyj17 > l
 10599  	} else {
 10600  		yyb17 = r.CheckBreak()
 10601  	}
 10602  	if yyb17 {
 10603  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10604  		return
 10605  	}
 10606  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10607  	if r.TryDecodeAsNil() {
 10608  		x.Region = ""
 10609  	} else {
 10610  		yyv23 := &x.Region
 10611  		yym24 := z.DecBinary()
 10612  		_ = yym24
 10613  		if false {
 10614  		} else {
 10615  			*((*string)(yyv23)) = r.DecodeString()
 10616  		}
 10617  	}
 10618  	yyj17++
 10619  	if yyhl17 {
 10620  		yyb17 = yyj17 > l
 10621  	} else {
 10622  		yyb17 = r.CheckBreak()
 10623  	}
 10624  	if yyb17 {
 10625  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10626  		return
 10627  	}
 10628  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10629  	if r.TryDecodeAsNil() {
 10630  		x.Namespace = ""
 10631  	} else {
 10632  		yyv25 := &x.Namespace
 10633  		yym26 := z.DecBinary()
 10634  		_ = yym26
 10635  		if false {
 10636  		} else {
 10637  			*((*string)(yyv25)) = r.DecodeString()
 10638  		}
 10639  	}
 10640  	yyj17++
 10641  	if yyhl17 {
 10642  		yyb17 = yyj17 > l
 10643  	} else {
 10644  		yyb17 = r.CheckBreak()
 10645  	}
 10646  	if yyb17 {
 10647  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10648  		return
 10649  	}
 10650  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10651  	if r.TryDecodeAsNil() {
 10652  		x.AuthToken = ""
 10653  	} else {
 10654  		yyv27 := &x.AuthToken
 10655  		yym28 := z.DecBinary()
 10656  		_ = yym28
 10657  		if false {
 10658  		} else {
 10659  			*((*string)(yyv27)) = r.DecodeString()
 10660  		}
 10661  	}
 10662  	yyj17++
 10663  	if yyhl17 {
 10664  		yyb17 = yyj17 > l
 10665  	} else {
 10666  		yyb17 = r.CheckBreak()
 10667  	}
 10668  	if yyb17 {
 10669  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10670  		return
 10671  	}
 10672  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10673  	if r.TryDecodeAsNil() {
 10674  		x.Forwarded = false
 10675  	} else {
 10676  		yyv29 := &x.Forwarded
 10677  		yym30 := z.DecBinary()
 10678  		_ = yym30
 10679  		if false {
 10680  		} else {
 10681  			*((*bool)(yyv29)) = r.DecodeBool()
 10682  		}
 10683  	}
 10684  	for {
 10685  		yyj17++
 10686  		if yyhl17 {
 10687  			yyb17 = yyj17 > l
 10688  		} else {
 10689  			yyb17 = r.CheckBreak()
 10690  		}
 10691  		if yyb17 {
 10692  			break
 10693  		}
 10694  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 10695  		z.DecStructFieldNotFound(yyj17-1, "")
 10696  	}
 10697  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10698  }
 10699  
 10700  func (x *JobSummaryRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 10701  	var h codecSelfer100
 10702  	z, r := codec1978.GenHelperEncoder(e)
 10703  	_, _, _ = h, z, r
 10704  	if x == nil {
 10705  		r.EncodeNil()
 10706  	} else {
 10707  		yym1 := z.EncBinary()
 10708  		_ = yym1
 10709  		if false {
 10710  		} else if z.HasExtensions() && z.EncExt(x) {
 10711  		} else {
 10712  			yysep2 := !z.EncBinary()
 10713  			yy2arr2 := z.EncBasicHandle().StructToArray
 10714  			var yyq2 [9]bool
 10715  			_, _, _ = yysep2, yyq2, yy2arr2
 10716  			const yyr2 bool = false
 10717  			var yynn2 int
 10718  			if yyr2 || yy2arr2 {
 10719  				r.EncodeArrayStart(9)
 10720  			} else {
 10721  				yynn2 = 9
 10722  				for _, b := range yyq2 {
 10723  					if b {
 10724  						yynn2++
 10725  					}
 10726  				}
 10727  				r.EncodeMapStart(yynn2)
 10728  				yynn2 = 0
 10729  			}
 10730  			if yyr2 || yy2arr2 {
 10731  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10732  				yym4 := z.EncBinary()
 10733  				_ = yym4
 10734  				if false {
 10735  				} else {
 10736  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 10737  				}
 10738  			} else {
 10739  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10740  				r.EncodeString(codecSelferC_UTF8100, string("JobID"))
 10741  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10742  				yym5 := z.EncBinary()
 10743  				_ = yym5
 10744  				if false {
 10745  				} else {
 10746  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 10747  				}
 10748  			}
 10749  			if yyr2 || yy2arr2 {
 10750  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10751  				yym7 := z.EncBinary()
 10752  				_ = yym7
 10753  				if false {
 10754  				} else {
 10755  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 10756  				}
 10757  			} else {
 10758  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10759  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 10760  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10761  				yym8 := z.EncBinary()
 10762  				_ = yym8
 10763  				if false {
 10764  				} else {
 10765  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 10766  				}
 10767  			}
 10768  			if yyr2 || yy2arr2 {
 10769  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10770  				yym10 := z.EncBinary()
 10771  				_ = yym10
 10772  				if false {
 10773  				} else {
 10774  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 10775  				}
 10776  			} else {
 10777  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10778  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 10779  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10780  				yym11 := z.EncBinary()
 10781  				_ = yym11
 10782  				if false {
 10783  				} else {
 10784  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 10785  				}
 10786  			}
 10787  			if yyr2 || yy2arr2 {
 10788  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10789  				yym13 := z.EncBinary()
 10790  				_ = yym13
 10791  				if false {
 10792  				} else {
 10793  					r.EncodeUint(uint64(x.MinQueryIndex))
 10794  				}
 10795  			} else {
 10796  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10797  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 10798  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10799  				yym14 := z.EncBinary()
 10800  				_ = yym14
 10801  				if false {
 10802  				} else {
 10803  					r.EncodeUint(uint64(x.MinQueryIndex))
 10804  				}
 10805  			}
 10806  			if yyr2 || yy2arr2 {
 10807  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10808  				yym16 := z.EncBinary()
 10809  				_ = yym16
 10810  				if false {
 10811  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 10812  				} else {
 10813  					r.EncodeInt(int64(x.MaxQueryTime))
 10814  				}
 10815  			} else {
 10816  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10817  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 10818  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10819  				yym17 := z.EncBinary()
 10820  				_ = yym17
 10821  				if false {
 10822  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 10823  				} else {
 10824  					r.EncodeInt(int64(x.MaxQueryTime))
 10825  				}
 10826  			}
 10827  			if yyr2 || yy2arr2 {
 10828  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10829  				yym19 := z.EncBinary()
 10830  				_ = yym19
 10831  				if false {
 10832  				} else {
 10833  					r.EncodeBool(bool(x.AllowStale))
 10834  				}
 10835  			} else {
 10836  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10837  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 10838  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10839  				yym20 := z.EncBinary()
 10840  				_ = yym20
 10841  				if false {
 10842  				} else {
 10843  					r.EncodeBool(bool(x.AllowStale))
 10844  				}
 10845  			}
 10846  			if yyr2 || yy2arr2 {
 10847  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10848  				yym22 := z.EncBinary()
 10849  				_ = yym22
 10850  				if false {
 10851  				} else {
 10852  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 10853  				}
 10854  			} else {
 10855  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10856  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 10857  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10858  				yym23 := z.EncBinary()
 10859  				_ = yym23
 10860  				if false {
 10861  				} else {
 10862  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 10863  				}
 10864  			}
 10865  			if yyr2 || yy2arr2 {
 10866  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10867  				yym25 := z.EncBinary()
 10868  				_ = yym25
 10869  				if false {
 10870  				} else {
 10871  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 10872  				}
 10873  			} else {
 10874  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10875  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 10876  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10877  				yym26 := z.EncBinary()
 10878  				_ = yym26
 10879  				if false {
 10880  				} else {
 10881  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 10882  				}
 10883  			}
 10884  			if yyr2 || yy2arr2 {
 10885  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 10886  				yym28 := z.EncBinary()
 10887  				_ = yym28
 10888  				if false {
 10889  				} else {
 10890  					r.EncodeBool(bool(x.Forwarded))
 10891  				}
 10892  			} else {
 10893  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 10894  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 10895  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 10896  				yym29 := z.EncBinary()
 10897  				_ = yym29
 10898  				if false {
 10899  				} else {
 10900  					r.EncodeBool(bool(x.Forwarded))
 10901  				}
 10902  			}
 10903  			if yyr2 || yy2arr2 {
 10904  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 10905  			} else {
 10906  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 10907  			}
 10908  		}
 10909  	}
 10910  }
 10911  
 10912  func (x *JobSummaryRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 10913  	var h codecSelfer100
 10914  	z, r := codec1978.GenHelperDecoder(d)
 10915  	_, _, _ = h, z, r
 10916  	yym1 := z.DecBinary()
 10917  	_ = yym1
 10918  	if false {
 10919  	} else if z.HasExtensions() && z.DecExt(x) {
 10920  	} else {
 10921  		yyct2 := r.ContainerType()
 10922  		if yyct2 == codecSelferValueTypeMap100 {
 10923  			yyl2 := r.ReadMapStart()
 10924  			if yyl2 == 0 {
 10925  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 10926  			} else {
 10927  				x.codecDecodeSelfFromMap(yyl2, d)
 10928  			}
 10929  		} else if yyct2 == codecSelferValueTypeArray100 {
 10930  			yyl2 := r.ReadArrayStart()
 10931  			if yyl2 == 0 {
 10932  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 10933  			} else {
 10934  				x.codecDecodeSelfFromArray(yyl2, d)
 10935  			}
 10936  		} else {
 10937  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 10938  		}
 10939  	}
 10940  }
 10941  
 10942  func (x *JobSummaryRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 10943  	var h codecSelfer100
 10944  	z, r := codec1978.GenHelperDecoder(d)
 10945  	_, _, _ = h, z, r
 10946  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 10947  	_ = yys3Slc
 10948  	var yyhl3 bool = l >= 0
 10949  	for yyj3 := 0; ; yyj3++ {
 10950  		if yyhl3 {
 10951  			if yyj3 >= l {
 10952  				break
 10953  			}
 10954  		} else {
 10955  			if r.CheckBreak() {
 10956  				break
 10957  			}
 10958  		}
 10959  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 10960  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 10961  		yys3 := string(yys3Slc)
 10962  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 10963  		switch yys3 {
 10964  		case "JobID":
 10965  			if r.TryDecodeAsNil() {
 10966  				x.JobID = ""
 10967  			} else {
 10968  				yyv4 := &x.JobID
 10969  				yym5 := z.DecBinary()
 10970  				_ = yym5
 10971  				if false {
 10972  				} else {
 10973  					*((*string)(yyv4)) = r.DecodeString()
 10974  				}
 10975  			}
 10976  		case "Region":
 10977  			if r.TryDecodeAsNil() {
 10978  				x.Region = ""
 10979  			} else {
 10980  				yyv6 := &x.Region
 10981  				yym7 := z.DecBinary()
 10982  				_ = yym7
 10983  				if false {
 10984  				} else {
 10985  					*((*string)(yyv6)) = r.DecodeString()
 10986  				}
 10987  			}
 10988  		case "Namespace":
 10989  			if r.TryDecodeAsNil() {
 10990  				x.Namespace = ""
 10991  			} else {
 10992  				yyv8 := &x.Namespace
 10993  				yym9 := z.DecBinary()
 10994  				_ = yym9
 10995  				if false {
 10996  				} else {
 10997  					*((*string)(yyv8)) = r.DecodeString()
 10998  				}
 10999  			}
 11000  		case "MinQueryIndex":
 11001  			if r.TryDecodeAsNil() {
 11002  				x.MinQueryIndex = 0
 11003  			} else {
 11004  				yyv10 := &x.MinQueryIndex
 11005  				yym11 := z.DecBinary()
 11006  				_ = yym11
 11007  				if false {
 11008  				} else {
 11009  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 11010  				}
 11011  			}
 11012  		case "MaxQueryTime":
 11013  			if r.TryDecodeAsNil() {
 11014  				x.MaxQueryTime = 0
 11015  			} else {
 11016  				yyv12 := &x.MaxQueryTime
 11017  				yym13 := z.DecBinary()
 11018  				_ = yym13
 11019  				if false {
 11020  				} else if z.HasExtensions() && z.DecExt(yyv12) {
 11021  				} else {
 11022  					*((*int64)(yyv12)) = int64(r.DecodeInt(64))
 11023  				}
 11024  			}
 11025  		case "AllowStale":
 11026  			if r.TryDecodeAsNil() {
 11027  				x.AllowStale = false
 11028  			} else {
 11029  				yyv14 := &x.AllowStale
 11030  				yym15 := z.DecBinary()
 11031  				_ = yym15
 11032  				if false {
 11033  				} else {
 11034  					*((*bool)(yyv14)) = r.DecodeBool()
 11035  				}
 11036  			}
 11037  		case "Prefix":
 11038  			if r.TryDecodeAsNil() {
 11039  				x.Prefix = ""
 11040  			} else {
 11041  				yyv16 := &x.Prefix
 11042  				yym17 := z.DecBinary()
 11043  				_ = yym17
 11044  				if false {
 11045  				} else {
 11046  					*((*string)(yyv16)) = r.DecodeString()
 11047  				}
 11048  			}
 11049  		case "AuthToken":
 11050  			if r.TryDecodeAsNil() {
 11051  				x.AuthToken = ""
 11052  			} else {
 11053  				yyv18 := &x.AuthToken
 11054  				yym19 := z.DecBinary()
 11055  				_ = yym19
 11056  				if false {
 11057  				} else {
 11058  					*((*string)(yyv18)) = r.DecodeString()
 11059  				}
 11060  			}
 11061  		case "Forwarded":
 11062  			if r.TryDecodeAsNil() {
 11063  				x.Forwarded = false
 11064  			} else {
 11065  				yyv20 := &x.Forwarded
 11066  				yym21 := z.DecBinary()
 11067  				_ = yym21
 11068  				if false {
 11069  				} else {
 11070  					*((*bool)(yyv20)) = r.DecodeBool()
 11071  				}
 11072  			}
 11073  		default:
 11074  			z.DecStructFieldNotFound(-1, yys3)
 11075  		} // end switch yys3
 11076  	} // end for yyj3
 11077  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 11078  }
 11079  
 11080  func (x *JobSummaryRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 11081  	var h codecSelfer100
 11082  	z, r := codec1978.GenHelperDecoder(d)
 11083  	_, _, _ = h, z, r
 11084  	var yyj22 int
 11085  	var yyb22 bool
 11086  	var yyhl22 bool = l >= 0
 11087  	yyj22++
 11088  	if yyhl22 {
 11089  		yyb22 = yyj22 > l
 11090  	} else {
 11091  		yyb22 = r.CheckBreak()
 11092  	}
 11093  	if yyb22 {
 11094  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11095  		return
 11096  	}
 11097  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11098  	if r.TryDecodeAsNil() {
 11099  		x.JobID = ""
 11100  	} else {
 11101  		yyv23 := &x.JobID
 11102  		yym24 := z.DecBinary()
 11103  		_ = yym24
 11104  		if false {
 11105  		} else {
 11106  			*((*string)(yyv23)) = r.DecodeString()
 11107  		}
 11108  	}
 11109  	yyj22++
 11110  	if yyhl22 {
 11111  		yyb22 = yyj22 > l
 11112  	} else {
 11113  		yyb22 = r.CheckBreak()
 11114  	}
 11115  	if yyb22 {
 11116  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11117  		return
 11118  	}
 11119  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11120  	if r.TryDecodeAsNil() {
 11121  		x.Region = ""
 11122  	} else {
 11123  		yyv25 := &x.Region
 11124  		yym26 := z.DecBinary()
 11125  		_ = yym26
 11126  		if false {
 11127  		} else {
 11128  			*((*string)(yyv25)) = r.DecodeString()
 11129  		}
 11130  	}
 11131  	yyj22++
 11132  	if yyhl22 {
 11133  		yyb22 = yyj22 > l
 11134  	} else {
 11135  		yyb22 = r.CheckBreak()
 11136  	}
 11137  	if yyb22 {
 11138  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11139  		return
 11140  	}
 11141  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11142  	if r.TryDecodeAsNil() {
 11143  		x.Namespace = ""
 11144  	} else {
 11145  		yyv27 := &x.Namespace
 11146  		yym28 := z.DecBinary()
 11147  		_ = yym28
 11148  		if false {
 11149  		} else {
 11150  			*((*string)(yyv27)) = r.DecodeString()
 11151  		}
 11152  	}
 11153  	yyj22++
 11154  	if yyhl22 {
 11155  		yyb22 = yyj22 > l
 11156  	} else {
 11157  		yyb22 = r.CheckBreak()
 11158  	}
 11159  	if yyb22 {
 11160  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11161  		return
 11162  	}
 11163  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11164  	if r.TryDecodeAsNil() {
 11165  		x.MinQueryIndex = 0
 11166  	} else {
 11167  		yyv29 := &x.MinQueryIndex
 11168  		yym30 := z.DecBinary()
 11169  		_ = yym30
 11170  		if false {
 11171  		} else {
 11172  			*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
 11173  		}
 11174  	}
 11175  	yyj22++
 11176  	if yyhl22 {
 11177  		yyb22 = yyj22 > l
 11178  	} else {
 11179  		yyb22 = r.CheckBreak()
 11180  	}
 11181  	if yyb22 {
 11182  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11183  		return
 11184  	}
 11185  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11186  	if r.TryDecodeAsNil() {
 11187  		x.MaxQueryTime = 0
 11188  	} else {
 11189  		yyv31 := &x.MaxQueryTime
 11190  		yym32 := z.DecBinary()
 11191  		_ = yym32
 11192  		if false {
 11193  		} else if z.HasExtensions() && z.DecExt(yyv31) {
 11194  		} else {
 11195  			*((*int64)(yyv31)) = int64(r.DecodeInt(64))
 11196  		}
 11197  	}
 11198  	yyj22++
 11199  	if yyhl22 {
 11200  		yyb22 = yyj22 > l
 11201  	} else {
 11202  		yyb22 = r.CheckBreak()
 11203  	}
 11204  	if yyb22 {
 11205  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11206  		return
 11207  	}
 11208  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11209  	if r.TryDecodeAsNil() {
 11210  		x.AllowStale = false
 11211  	} else {
 11212  		yyv33 := &x.AllowStale
 11213  		yym34 := z.DecBinary()
 11214  		_ = yym34
 11215  		if false {
 11216  		} else {
 11217  			*((*bool)(yyv33)) = r.DecodeBool()
 11218  		}
 11219  	}
 11220  	yyj22++
 11221  	if yyhl22 {
 11222  		yyb22 = yyj22 > l
 11223  	} else {
 11224  		yyb22 = r.CheckBreak()
 11225  	}
 11226  	if yyb22 {
 11227  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11228  		return
 11229  	}
 11230  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11231  	if r.TryDecodeAsNil() {
 11232  		x.Prefix = ""
 11233  	} else {
 11234  		yyv35 := &x.Prefix
 11235  		yym36 := z.DecBinary()
 11236  		_ = yym36
 11237  		if false {
 11238  		} else {
 11239  			*((*string)(yyv35)) = r.DecodeString()
 11240  		}
 11241  	}
 11242  	yyj22++
 11243  	if yyhl22 {
 11244  		yyb22 = yyj22 > l
 11245  	} else {
 11246  		yyb22 = r.CheckBreak()
 11247  	}
 11248  	if yyb22 {
 11249  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11250  		return
 11251  	}
 11252  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11253  	if r.TryDecodeAsNil() {
 11254  		x.AuthToken = ""
 11255  	} else {
 11256  		yyv37 := &x.AuthToken
 11257  		yym38 := z.DecBinary()
 11258  		_ = yym38
 11259  		if false {
 11260  		} else {
 11261  			*((*string)(yyv37)) = r.DecodeString()
 11262  		}
 11263  	}
 11264  	yyj22++
 11265  	if yyhl22 {
 11266  		yyb22 = yyj22 > l
 11267  	} else {
 11268  		yyb22 = r.CheckBreak()
 11269  	}
 11270  	if yyb22 {
 11271  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11272  		return
 11273  	}
 11274  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11275  	if r.TryDecodeAsNil() {
 11276  		x.Forwarded = false
 11277  	} else {
 11278  		yyv39 := &x.Forwarded
 11279  		yym40 := z.DecBinary()
 11280  		_ = yym40
 11281  		if false {
 11282  		} else {
 11283  			*((*bool)(yyv39)) = r.DecodeBool()
 11284  		}
 11285  	}
 11286  	for {
 11287  		yyj22++
 11288  		if yyhl22 {
 11289  			yyb22 = yyj22 > l
 11290  		} else {
 11291  			yyb22 = r.CheckBreak()
 11292  		}
 11293  		if yyb22 {
 11294  			break
 11295  		}
 11296  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11297  		z.DecStructFieldNotFound(yyj22-1, "")
 11298  	}
 11299  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11300  }
 11301  
 11302  func (x *JobDispatchRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 11303  	var h codecSelfer100
 11304  	z, r := codec1978.GenHelperEncoder(e)
 11305  	_, _, _ = h, z, r
 11306  	if x == nil {
 11307  		r.EncodeNil()
 11308  	} else {
 11309  		yym1 := z.EncBinary()
 11310  		_ = yym1
 11311  		if false {
 11312  		} else if z.HasExtensions() && z.EncExt(x) {
 11313  		} else {
 11314  			yysep2 := !z.EncBinary()
 11315  			yy2arr2 := z.EncBasicHandle().StructToArray
 11316  			var yyq2 [7]bool
 11317  			_, _, _ = yysep2, yyq2, yy2arr2
 11318  			const yyr2 bool = false
 11319  			var yynn2 int
 11320  			if yyr2 || yy2arr2 {
 11321  				r.EncodeArrayStart(7)
 11322  			} else {
 11323  				yynn2 = 7
 11324  				for _, b := range yyq2 {
 11325  					if b {
 11326  						yynn2++
 11327  					}
 11328  				}
 11329  				r.EncodeMapStart(yynn2)
 11330  				yynn2 = 0
 11331  			}
 11332  			if yyr2 || yy2arr2 {
 11333  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 11334  				yym4 := z.EncBinary()
 11335  				_ = yym4
 11336  				if false {
 11337  				} else {
 11338  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 11339  				}
 11340  			} else {
 11341  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 11342  				r.EncodeString(codecSelferC_UTF8100, string("JobID"))
 11343  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 11344  				yym5 := z.EncBinary()
 11345  				_ = yym5
 11346  				if false {
 11347  				} else {
 11348  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 11349  				}
 11350  			}
 11351  			if yyr2 || yy2arr2 {
 11352  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 11353  				if x.Payload == nil {
 11354  					r.EncodeNil()
 11355  				} else {
 11356  					yym7 := z.EncBinary()
 11357  					_ = yym7
 11358  					if false {
 11359  					} else {
 11360  						r.EncodeStringBytes(codecSelferC_RAW100, []byte(x.Payload))
 11361  					}
 11362  				}
 11363  			} else {
 11364  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 11365  				r.EncodeString(codecSelferC_UTF8100, string("Payload"))
 11366  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 11367  				if x.Payload == nil {
 11368  					r.EncodeNil()
 11369  				} else {
 11370  					yym8 := z.EncBinary()
 11371  					_ = yym8
 11372  					if false {
 11373  					} else {
 11374  						r.EncodeStringBytes(codecSelferC_RAW100, []byte(x.Payload))
 11375  					}
 11376  				}
 11377  			}
 11378  			if yyr2 || yy2arr2 {
 11379  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 11380  				if x.Meta == nil {
 11381  					r.EncodeNil()
 11382  				} else {
 11383  					yym10 := z.EncBinary()
 11384  					_ = yym10
 11385  					if false {
 11386  					} else {
 11387  						z.F.EncMapStringStringV(x.Meta, false, e)
 11388  					}
 11389  				}
 11390  			} else {
 11391  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 11392  				r.EncodeString(codecSelferC_UTF8100, string("Meta"))
 11393  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 11394  				if x.Meta == nil {
 11395  					r.EncodeNil()
 11396  				} else {
 11397  					yym11 := z.EncBinary()
 11398  					_ = yym11
 11399  					if false {
 11400  					} else {
 11401  						z.F.EncMapStringStringV(x.Meta, false, e)
 11402  					}
 11403  				}
 11404  			}
 11405  			if yyr2 || yy2arr2 {
 11406  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 11407  				yym13 := z.EncBinary()
 11408  				_ = yym13
 11409  				if false {
 11410  				} else {
 11411  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 11412  				}
 11413  			} else {
 11414  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 11415  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 11416  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 11417  				yym14 := z.EncBinary()
 11418  				_ = yym14
 11419  				if false {
 11420  				} else {
 11421  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 11422  				}
 11423  			}
 11424  			if yyr2 || yy2arr2 {
 11425  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 11426  				yym16 := z.EncBinary()
 11427  				_ = yym16
 11428  				if false {
 11429  				} else {
 11430  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 11431  				}
 11432  			} else {
 11433  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 11434  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 11435  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 11436  				yym17 := z.EncBinary()
 11437  				_ = yym17
 11438  				if false {
 11439  				} else {
 11440  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 11441  				}
 11442  			}
 11443  			if yyr2 || yy2arr2 {
 11444  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 11445  				yym19 := z.EncBinary()
 11446  				_ = yym19
 11447  				if false {
 11448  				} else {
 11449  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 11450  				}
 11451  			} else {
 11452  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 11453  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 11454  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 11455  				yym20 := z.EncBinary()
 11456  				_ = yym20
 11457  				if false {
 11458  				} else {
 11459  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 11460  				}
 11461  			}
 11462  			if yyr2 || yy2arr2 {
 11463  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 11464  				yym22 := z.EncBinary()
 11465  				_ = yym22
 11466  				if false {
 11467  				} else {
 11468  					r.EncodeBool(bool(x.Forwarded))
 11469  				}
 11470  			} else {
 11471  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 11472  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 11473  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 11474  				yym23 := z.EncBinary()
 11475  				_ = yym23
 11476  				if false {
 11477  				} else {
 11478  					r.EncodeBool(bool(x.Forwarded))
 11479  				}
 11480  			}
 11481  			if yyr2 || yy2arr2 {
 11482  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 11483  			} else {
 11484  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 11485  			}
 11486  		}
 11487  	}
 11488  }
 11489  
 11490  func (x *JobDispatchRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 11491  	var h codecSelfer100
 11492  	z, r := codec1978.GenHelperDecoder(d)
 11493  	_, _, _ = h, z, r
 11494  	yym1 := z.DecBinary()
 11495  	_ = yym1
 11496  	if false {
 11497  	} else if z.HasExtensions() && z.DecExt(x) {
 11498  	} else {
 11499  		yyct2 := r.ContainerType()
 11500  		if yyct2 == codecSelferValueTypeMap100 {
 11501  			yyl2 := r.ReadMapStart()
 11502  			if yyl2 == 0 {
 11503  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 11504  			} else {
 11505  				x.codecDecodeSelfFromMap(yyl2, d)
 11506  			}
 11507  		} else if yyct2 == codecSelferValueTypeArray100 {
 11508  			yyl2 := r.ReadArrayStart()
 11509  			if yyl2 == 0 {
 11510  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11511  			} else {
 11512  				x.codecDecodeSelfFromArray(yyl2, d)
 11513  			}
 11514  		} else {
 11515  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 11516  		}
 11517  	}
 11518  }
 11519  
 11520  func (x *JobDispatchRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 11521  	var h codecSelfer100
 11522  	z, r := codec1978.GenHelperDecoder(d)
 11523  	_, _, _ = h, z, r
 11524  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 11525  	_ = yys3Slc
 11526  	var yyhl3 bool = l >= 0
 11527  	for yyj3 := 0; ; yyj3++ {
 11528  		if yyhl3 {
 11529  			if yyj3 >= l {
 11530  				break
 11531  			}
 11532  		} else {
 11533  			if r.CheckBreak() {
 11534  				break
 11535  			}
 11536  		}
 11537  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 11538  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 11539  		yys3 := string(yys3Slc)
 11540  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 11541  		switch yys3 {
 11542  		case "JobID":
 11543  			if r.TryDecodeAsNil() {
 11544  				x.JobID = ""
 11545  			} else {
 11546  				yyv4 := &x.JobID
 11547  				yym5 := z.DecBinary()
 11548  				_ = yym5
 11549  				if false {
 11550  				} else {
 11551  					*((*string)(yyv4)) = r.DecodeString()
 11552  				}
 11553  			}
 11554  		case "Payload":
 11555  			if r.TryDecodeAsNil() {
 11556  				x.Payload = nil
 11557  			} else {
 11558  				yyv6 := &x.Payload
 11559  				yym7 := z.DecBinary()
 11560  				_ = yym7
 11561  				if false {
 11562  				} else {
 11563  					*yyv6 = r.DecodeBytes(*(*[]byte)(yyv6), false, false)
 11564  				}
 11565  			}
 11566  		case "Meta":
 11567  			if r.TryDecodeAsNil() {
 11568  				x.Meta = nil
 11569  			} else {
 11570  				yyv8 := &x.Meta
 11571  				yym9 := z.DecBinary()
 11572  				_ = yym9
 11573  				if false {
 11574  				} else {
 11575  					z.F.DecMapStringStringX(yyv8, false, d)
 11576  				}
 11577  			}
 11578  		case "Region":
 11579  			if r.TryDecodeAsNil() {
 11580  				x.Region = ""
 11581  			} else {
 11582  				yyv10 := &x.Region
 11583  				yym11 := z.DecBinary()
 11584  				_ = yym11
 11585  				if false {
 11586  				} else {
 11587  					*((*string)(yyv10)) = r.DecodeString()
 11588  				}
 11589  			}
 11590  		case "Namespace":
 11591  			if r.TryDecodeAsNil() {
 11592  				x.Namespace = ""
 11593  			} else {
 11594  				yyv12 := &x.Namespace
 11595  				yym13 := z.DecBinary()
 11596  				_ = yym13
 11597  				if false {
 11598  				} else {
 11599  					*((*string)(yyv12)) = r.DecodeString()
 11600  				}
 11601  			}
 11602  		case "AuthToken":
 11603  			if r.TryDecodeAsNil() {
 11604  				x.AuthToken = ""
 11605  			} else {
 11606  				yyv14 := &x.AuthToken
 11607  				yym15 := z.DecBinary()
 11608  				_ = yym15
 11609  				if false {
 11610  				} else {
 11611  					*((*string)(yyv14)) = r.DecodeString()
 11612  				}
 11613  			}
 11614  		case "Forwarded":
 11615  			if r.TryDecodeAsNil() {
 11616  				x.Forwarded = false
 11617  			} else {
 11618  				yyv16 := &x.Forwarded
 11619  				yym17 := z.DecBinary()
 11620  				_ = yym17
 11621  				if false {
 11622  				} else {
 11623  					*((*bool)(yyv16)) = r.DecodeBool()
 11624  				}
 11625  			}
 11626  		default:
 11627  			z.DecStructFieldNotFound(-1, yys3)
 11628  		} // end switch yys3
 11629  	} // end for yyj3
 11630  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 11631  }
 11632  
 11633  func (x *JobDispatchRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 11634  	var h codecSelfer100
 11635  	z, r := codec1978.GenHelperDecoder(d)
 11636  	_, _, _ = h, z, r
 11637  	var yyj18 int
 11638  	var yyb18 bool
 11639  	var yyhl18 bool = l >= 0
 11640  	yyj18++
 11641  	if yyhl18 {
 11642  		yyb18 = yyj18 > l
 11643  	} else {
 11644  		yyb18 = r.CheckBreak()
 11645  	}
 11646  	if yyb18 {
 11647  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11648  		return
 11649  	}
 11650  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11651  	if r.TryDecodeAsNil() {
 11652  		x.JobID = ""
 11653  	} else {
 11654  		yyv19 := &x.JobID
 11655  		yym20 := z.DecBinary()
 11656  		_ = yym20
 11657  		if false {
 11658  		} else {
 11659  			*((*string)(yyv19)) = r.DecodeString()
 11660  		}
 11661  	}
 11662  	yyj18++
 11663  	if yyhl18 {
 11664  		yyb18 = yyj18 > l
 11665  	} else {
 11666  		yyb18 = r.CheckBreak()
 11667  	}
 11668  	if yyb18 {
 11669  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11670  		return
 11671  	}
 11672  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11673  	if r.TryDecodeAsNil() {
 11674  		x.Payload = nil
 11675  	} else {
 11676  		yyv21 := &x.Payload
 11677  		yym22 := z.DecBinary()
 11678  		_ = yym22
 11679  		if false {
 11680  		} else {
 11681  			*yyv21 = r.DecodeBytes(*(*[]byte)(yyv21), false, false)
 11682  		}
 11683  	}
 11684  	yyj18++
 11685  	if yyhl18 {
 11686  		yyb18 = yyj18 > l
 11687  	} else {
 11688  		yyb18 = r.CheckBreak()
 11689  	}
 11690  	if yyb18 {
 11691  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11692  		return
 11693  	}
 11694  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11695  	if r.TryDecodeAsNil() {
 11696  		x.Meta = nil
 11697  	} else {
 11698  		yyv23 := &x.Meta
 11699  		yym24 := z.DecBinary()
 11700  		_ = yym24
 11701  		if false {
 11702  		} else {
 11703  			z.F.DecMapStringStringX(yyv23, false, d)
 11704  		}
 11705  	}
 11706  	yyj18++
 11707  	if yyhl18 {
 11708  		yyb18 = yyj18 > l
 11709  	} else {
 11710  		yyb18 = r.CheckBreak()
 11711  	}
 11712  	if yyb18 {
 11713  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11714  		return
 11715  	}
 11716  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11717  	if r.TryDecodeAsNil() {
 11718  		x.Region = ""
 11719  	} else {
 11720  		yyv25 := &x.Region
 11721  		yym26 := z.DecBinary()
 11722  		_ = yym26
 11723  		if false {
 11724  		} else {
 11725  			*((*string)(yyv25)) = r.DecodeString()
 11726  		}
 11727  	}
 11728  	yyj18++
 11729  	if yyhl18 {
 11730  		yyb18 = yyj18 > l
 11731  	} else {
 11732  		yyb18 = r.CheckBreak()
 11733  	}
 11734  	if yyb18 {
 11735  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11736  		return
 11737  	}
 11738  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11739  	if r.TryDecodeAsNil() {
 11740  		x.Namespace = ""
 11741  	} else {
 11742  		yyv27 := &x.Namespace
 11743  		yym28 := z.DecBinary()
 11744  		_ = yym28
 11745  		if false {
 11746  		} else {
 11747  			*((*string)(yyv27)) = r.DecodeString()
 11748  		}
 11749  	}
 11750  	yyj18++
 11751  	if yyhl18 {
 11752  		yyb18 = yyj18 > l
 11753  	} else {
 11754  		yyb18 = r.CheckBreak()
 11755  	}
 11756  	if yyb18 {
 11757  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11758  		return
 11759  	}
 11760  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11761  	if r.TryDecodeAsNil() {
 11762  		x.AuthToken = ""
 11763  	} else {
 11764  		yyv29 := &x.AuthToken
 11765  		yym30 := z.DecBinary()
 11766  		_ = yym30
 11767  		if false {
 11768  		} else {
 11769  			*((*string)(yyv29)) = r.DecodeString()
 11770  		}
 11771  	}
 11772  	yyj18++
 11773  	if yyhl18 {
 11774  		yyb18 = yyj18 > l
 11775  	} else {
 11776  		yyb18 = r.CheckBreak()
 11777  	}
 11778  	if yyb18 {
 11779  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11780  		return
 11781  	}
 11782  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11783  	if r.TryDecodeAsNil() {
 11784  		x.Forwarded = false
 11785  	} else {
 11786  		yyv31 := &x.Forwarded
 11787  		yym32 := z.DecBinary()
 11788  		_ = yym32
 11789  		if false {
 11790  		} else {
 11791  			*((*bool)(yyv31)) = r.DecodeBool()
 11792  		}
 11793  	}
 11794  	for {
 11795  		yyj18++
 11796  		if yyhl18 {
 11797  			yyb18 = yyj18 > l
 11798  		} else {
 11799  			yyb18 = r.CheckBreak()
 11800  		}
 11801  		if yyb18 {
 11802  			break
 11803  		}
 11804  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 11805  		z.DecStructFieldNotFound(yyj18-1, "")
 11806  	}
 11807  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11808  }
 11809  
 11810  func (x *JobValidateRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 11811  	var h codecSelfer100
 11812  	z, r := codec1978.GenHelperEncoder(e)
 11813  	_, _, _ = h, z, r
 11814  	if x == nil {
 11815  		r.EncodeNil()
 11816  	} else {
 11817  		yym1 := z.EncBinary()
 11818  		_ = yym1
 11819  		if false {
 11820  		} else if z.HasExtensions() && z.EncExt(x) {
 11821  		} else {
 11822  			yysep2 := !z.EncBinary()
 11823  			yy2arr2 := z.EncBasicHandle().StructToArray
 11824  			var yyq2 [5]bool
 11825  			_, _, _ = yysep2, yyq2, yy2arr2
 11826  			const yyr2 bool = false
 11827  			var yynn2 int
 11828  			if yyr2 || yy2arr2 {
 11829  				r.EncodeArrayStart(5)
 11830  			} else {
 11831  				yynn2 = 5
 11832  				for _, b := range yyq2 {
 11833  					if b {
 11834  						yynn2++
 11835  					}
 11836  				}
 11837  				r.EncodeMapStart(yynn2)
 11838  				yynn2 = 0
 11839  			}
 11840  			if yyr2 || yy2arr2 {
 11841  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 11842  				if x.Job == nil {
 11843  					r.EncodeNil()
 11844  				} else {
 11845  					x.Job.CodecEncodeSelf(e)
 11846  				}
 11847  			} else {
 11848  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 11849  				r.EncodeString(codecSelferC_UTF8100, string("Job"))
 11850  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 11851  				if x.Job == nil {
 11852  					r.EncodeNil()
 11853  				} else {
 11854  					x.Job.CodecEncodeSelf(e)
 11855  				}
 11856  			}
 11857  			if yyr2 || yy2arr2 {
 11858  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 11859  				yym7 := z.EncBinary()
 11860  				_ = yym7
 11861  				if false {
 11862  				} else {
 11863  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 11864  				}
 11865  			} else {
 11866  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 11867  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 11868  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 11869  				yym8 := z.EncBinary()
 11870  				_ = yym8
 11871  				if false {
 11872  				} else {
 11873  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 11874  				}
 11875  			}
 11876  			if yyr2 || yy2arr2 {
 11877  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 11878  				yym10 := z.EncBinary()
 11879  				_ = yym10
 11880  				if false {
 11881  				} else {
 11882  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 11883  				}
 11884  			} else {
 11885  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 11886  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 11887  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 11888  				yym11 := z.EncBinary()
 11889  				_ = yym11
 11890  				if false {
 11891  				} else {
 11892  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 11893  				}
 11894  			}
 11895  			if yyr2 || yy2arr2 {
 11896  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 11897  				yym13 := z.EncBinary()
 11898  				_ = yym13
 11899  				if false {
 11900  				} else {
 11901  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 11902  				}
 11903  			} else {
 11904  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 11905  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 11906  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 11907  				yym14 := z.EncBinary()
 11908  				_ = yym14
 11909  				if false {
 11910  				} else {
 11911  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 11912  				}
 11913  			}
 11914  			if yyr2 || yy2arr2 {
 11915  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 11916  				yym16 := z.EncBinary()
 11917  				_ = yym16
 11918  				if false {
 11919  				} else {
 11920  					r.EncodeBool(bool(x.Forwarded))
 11921  				}
 11922  			} else {
 11923  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 11924  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 11925  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 11926  				yym17 := z.EncBinary()
 11927  				_ = yym17
 11928  				if false {
 11929  				} else {
 11930  					r.EncodeBool(bool(x.Forwarded))
 11931  				}
 11932  			}
 11933  			if yyr2 || yy2arr2 {
 11934  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 11935  			} else {
 11936  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 11937  			}
 11938  		}
 11939  	}
 11940  }
 11941  
 11942  func (x *JobValidateRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 11943  	var h codecSelfer100
 11944  	z, r := codec1978.GenHelperDecoder(d)
 11945  	_, _, _ = h, z, r
 11946  	yym1 := z.DecBinary()
 11947  	_ = yym1
 11948  	if false {
 11949  	} else if z.HasExtensions() && z.DecExt(x) {
 11950  	} else {
 11951  		yyct2 := r.ContainerType()
 11952  		if yyct2 == codecSelferValueTypeMap100 {
 11953  			yyl2 := r.ReadMapStart()
 11954  			if yyl2 == 0 {
 11955  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 11956  			} else {
 11957  				x.codecDecodeSelfFromMap(yyl2, d)
 11958  			}
 11959  		} else if yyct2 == codecSelferValueTypeArray100 {
 11960  			yyl2 := r.ReadArrayStart()
 11961  			if yyl2 == 0 {
 11962  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 11963  			} else {
 11964  				x.codecDecodeSelfFromArray(yyl2, d)
 11965  			}
 11966  		} else {
 11967  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 11968  		}
 11969  	}
 11970  }
 11971  
 11972  func (x *JobValidateRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 11973  	var h codecSelfer100
 11974  	z, r := codec1978.GenHelperDecoder(d)
 11975  	_, _, _ = h, z, r
 11976  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 11977  	_ = yys3Slc
 11978  	var yyhl3 bool = l >= 0
 11979  	for yyj3 := 0; ; yyj3++ {
 11980  		if yyhl3 {
 11981  			if yyj3 >= l {
 11982  				break
 11983  			}
 11984  		} else {
 11985  			if r.CheckBreak() {
 11986  				break
 11987  			}
 11988  		}
 11989  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 11990  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 11991  		yys3 := string(yys3Slc)
 11992  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 11993  		switch yys3 {
 11994  		case "Job":
 11995  			if r.TryDecodeAsNil() {
 11996  				if x.Job != nil {
 11997  					x.Job = nil
 11998  				}
 11999  			} else {
 12000  				if x.Job == nil {
 12001  					x.Job = new(Job)
 12002  				}
 12003  				x.Job.CodecDecodeSelf(d)
 12004  			}
 12005  		case "Region":
 12006  			if r.TryDecodeAsNil() {
 12007  				x.Region = ""
 12008  			} else {
 12009  				yyv5 := &x.Region
 12010  				yym6 := z.DecBinary()
 12011  				_ = yym6
 12012  				if false {
 12013  				} else {
 12014  					*((*string)(yyv5)) = r.DecodeString()
 12015  				}
 12016  			}
 12017  		case "Namespace":
 12018  			if r.TryDecodeAsNil() {
 12019  				x.Namespace = ""
 12020  			} else {
 12021  				yyv7 := &x.Namespace
 12022  				yym8 := z.DecBinary()
 12023  				_ = yym8
 12024  				if false {
 12025  				} else {
 12026  					*((*string)(yyv7)) = r.DecodeString()
 12027  				}
 12028  			}
 12029  		case "AuthToken":
 12030  			if r.TryDecodeAsNil() {
 12031  				x.AuthToken = ""
 12032  			} else {
 12033  				yyv9 := &x.AuthToken
 12034  				yym10 := z.DecBinary()
 12035  				_ = yym10
 12036  				if false {
 12037  				} else {
 12038  					*((*string)(yyv9)) = r.DecodeString()
 12039  				}
 12040  			}
 12041  		case "Forwarded":
 12042  			if r.TryDecodeAsNil() {
 12043  				x.Forwarded = false
 12044  			} else {
 12045  				yyv11 := &x.Forwarded
 12046  				yym12 := z.DecBinary()
 12047  				_ = yym12
 12048  				if false {
 12049  				} else {
 12050  					*((*bool)(yyv11)) = r.DecodeBool()
 12051  				}
 12052  			}
 12053  		default:
 12054  			z.DecStructFieldNotFound(-1, yys3)
 12055  		} // end switch yys3
 12056  	} // end for yyj3
 12057  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 12058  }
 12059  
 12060  func (x *JobValidateRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 12061  	var h codecSelfer100
 12062  	z, r := codec1978.GenHelperDecoder(d)
 12063  	_, _, _ = h, z, r
 12064  	var yyj13 int
 12065  	var yyb13 bool
 12066  	var yyhl13 bool = l >= 0
 12067  	yyj13++
 12068  	if yyhl13 {
 12069  		yyb13 = yyj13 > l
 12070  	} else {
 12071  		yyb13 = r.CheckBreak()
 12072  	}
 12073  	if yyb13 {
 12074  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12075  		return
 12076  	}
 12077  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 12078  	if r.TryDecodeAsNil() {
 12079  		if x.Job != nil {
 12080  			x.Job = nil
 12081  		}
 12082  	} else {
 12083  		if x.Job == nil {
 12084  			x.Job = new(Job)
 12085  		}
 12086  		x.Job.CodecDecodeSelf(d)
 12087  	}
 12088  	yyj13++
 12089  	if yyhl13 {
 12090  		yyb13 = yyj13 > l
 12091  	} else {
 12092  		yyb13 = r.CheckBreak()
 12093  	}
 12094  	if yyb13 {
 12095  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12096  		return
 12097  	}
 12098  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 12099  	if r.TryDecodeAsNil() {
 12100  		x.Region = ""
 12101  	} else {
 12102  		yyv15 := &x.Region
 12103  		yym16 := z.DecBinary()
 12104  		_ = yym16
 12105  		if false {
 12106  		} else {
 12107  			*((*string)(yyv15)) = r.DecodeString()
 12108  		}
 12109  	}
 12110  	yyj13++
 12111  	if yyhl13 {
 12112  		yyb13 = yyj13 > l
 12113  	} else {
 12114  		yyb13 = r.CheckBreak()
 12115  	}
 12116  	if yyb13 {
 12117  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12118  		return
 12119  	}
 12120  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 12121  	if r.TryDecodeAsNil() {
 12122  		x.Namespace = ""
 12123  	} else {
 12124  		yyv17 := &x.Namespace
 12125  		yym18 := z.DecBinary()
 12126  		_ = yym18
 12127  		if false {
 12128  		} else {
 12129  			*((*string)(yyv17)) = r.DecodeString()
 12130  		}
 12131  	}
 12132  	yyj13++
 12133  	if yyhl13 {
 12134  		yyb13 = yyj13 > l
 12135  	} else {
 12136  		yyb13 = r.CheckBreak()
 12137  	}
 12138  	if yyb13 {
 12139  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12140  		return
 12141  	}
 12142  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 12143  	if r.TryDecodeAsNil() {
 12144  		x.AuthToken = ""
 12145  	} else {
 12146  		yyv19 := &x.AuthToken
 12147  		yym20 := z.DecBinary()
 12148  		_ = yym20
 12149  		if false {
 12150  		} else {
 12151  			*((*string)(yyv19)) = r.DecodeString()
 12152  		}
 12153  	}
 12154  	yyj13++
 12155  	if yyhl13 {
 12156  		yyb13 = yyj13 > l
 12157  	} else {
 12158  		yyb13 = r.CheckBreak()
 12159  	}
 12160  	if yyb13 {
 12161  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12162  		return
 12163  	}
 12164  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 12165  	if r.TryDecodeAsNil() {
 12166  		x.Forwarded = false
 12167  	} else {
 12168  		yyv21 := &x.Forwarded
 12169  		yym22 := z.DecBinary()
 12170  		_ = yym22
 12171  		if false {
 12172  		} else {
 12173  			*((*bool)(yyv21)) = r.DecodeBool()
 12174  		}
 12175  	}
 12176  	for {
 12177  		yyj13++
 12178  		if yyhl13 {
 12179  			yyb13 = yyj13 > l
 12180  		} else {
 12181  			yyb13 = r.CheckBreak()
 12182  		}
 12183  		if yyb13 {
 12184  			break
 12185  		}
 12186  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 12187  		z.DecStructFieldNotFound(yyj13-1, "")
 12188  	}
 12189  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12190  }
 12191  
 12192  func (x *JobRevertRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 12193  	var h codecSelfer100
 12194  	z, r := codec1978.GenHelperEncoder(e)
 12195  	_, _, _ = h, z, r
 12196  	if x == nil {
 12197  		r.EncodeNil()
 12198  	} else {
 12199  		yym1 := z.EncBinary()
 12200  		_ = yym1
 12201  		if false {
 12202  		} else if z.HasExtensions() && z.EncExt(x) {
 12203  		} else {
 12204  			yysep2 := !z.EncBinary()
 12205  			yy2arr2 := z.EncBasicHandle().StructToArray
 12206  			var yyq2 [7]bool
 12207  			_, _, _ = yysep2, yyq2, yy2arr2
 12208  			const yyr2 bool = false
 12209  			var yynn2 int
 12210  			if yyr2 || yy2arr2 {
 12211  				r.EncodeArrayStart(7)
 12212  			} else {
 12213  				yynn2 = 7
 12214  				for _, b := range yyq2 {
 12215  					if b {
 12216  						yynn2++
 12217  					}
 12218  				}
 12219  				r.EncodeMapStart(yynn2)
 12220  				yynn2 = 0
 12221  			}
 12222  			if yyr2 || yy2arr2 {
 12223  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 12224  				yym4 := z.EncBinary()
 12225  				_ = yym4
 12226  				if false {
 12227  				} else {
 12228  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 12229  				}
 12230  			} else {
 12231  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 12232  				r.EncodeString(codecSelferC_UTF8100, string("JobID"))
 12233  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 12234  				yym5 := z.EncBinary()
 12235  				_ = yym5
 12236  				if false {
 12237  				} else {
 12238  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 12239  				}
 12240  			}
 12241  			if yyr2 || yy2arr2 {
 12242  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 12243  				yym7 := z.EncBinary()
 12244  				_ = yym7
 12245  				if false {
 12246  				} else {
 12247  					r.EncodeUint(uint64(x.JobVersion))
 12248  				}
 12249  			} else {
 12250  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 12251  				r.EncodeString(codecSelferC_UTF8100, string("JobVersion"))
 12252  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 12253  				yym8 := z.EncBinary()
 12254  				_ = yym8
 12255  				if false {
 12256  				} else {
 12257  					r.EncodeUint(uint64(x.JobVersion))
 12258  				}
 12259  			}
 12260  			if yyr2 || yy2arr2 {
 12261  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 12262  				if x.EnforcePriorVersion == nil {
 12263  					r.EncodeNil()
 12264  				} else {
 12265  					yy10 := *x.EnforcePriorVersion
 12266  					yym11 := z.EncBinary()
 12267  					_ = yym11
 12268  					if false {
 12269  					} else {
 12270  						r.EncodeUint(uint64(yy10))
 12271  					}
 12272  				}
 12273  			} else {
 12274  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 12275  				r.EncodeString(codecSelferC_UTF8100, string("EnforcePriorVersion"))
 12276  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 12277  				if x.EnforcePriorVersion == nil {
 12278  					r.EncodeNil()
 12279  				} else {
 12280  					yy12 := *x.EnforcePriorVersion
 12281  					yym13 := z.EncBinary()
 12282  					_ = yym13
 12283  					if false {
 12284  					} else {
 12285  						r.EncodeUint(uint64(yy12))
 12286  					}
 12287  				}
 12288  			}
 12289  			if yyr2 || yy2arr2 {
 12290  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 12291  				yym15 := z.EncBinary()
 12292  				_ = yym15
 12293  				if false {
 12294  				} else {
 12295  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 12296  				}
 12297  			} else {
 12298  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 12299  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 12300  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 12301  				yym16 := z.EncBinary()
 12302  				_ = yym16
 12303  				if false {
 12304  				} else {
 12305  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 12306  				}
 12307  			}
 12308  			if yyr2 || yy2arr2 {
 12309  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 12310  				yym18 := z.EncBinary()
 12311  				_ = yym18
 12312  				if false {
 12313  				} else {
 12314  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 12315  				}
 12316  			} else {
 12317  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 12318  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 12319  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 12320  				yym19 := z.EncBinary()
 12321  				_ = yym19
 12322  				if false {
 12323  				} else {
 12324  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 12325  				}
 12326  			}
 12327  			if yyr2 || yy2arr2 {
 12328  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 12329  				yym21 := z.EncBinary()
 12330  				_ = yym21
 12331  				if false {
 12332  				} else {
 12333  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 12334  				}
 12335  			} else {
 12336  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 12337  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 12338  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 12339  				yym22 := z.EncBinary()
 12340  				_ = yym22
 12341  				if false {
 12342  				} else {
 12343  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 12344  				}
 12345  			}
 12346  			if yyr2 || yy2arr2 {
 12347  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 12348  				yym24 := z.EncBinary()
 12349  				_ = yym24
 12350  				if false {
 12351  				} else {
 12352  					r.EncodeBool(bool(x.Forwarded))
 12353  				}
 12354  			} else {
 12355  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 12356  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 12357  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 12358  				yym25 := z.EncBinary()
 12359  				_ = yym25
 12360  				if false {
 12361  				} else {
 12362  					r.EncodeBool(bool(x.Forwarded))
 12363  				}
 12364  			}
 12365  			if yyr2 || yy2arr2 {
 12366  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 12367  			} else {
 12368  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 12369  			}
 12370  		}
 12371  	}
 12372  }
 12373  
 12374  func (x *JobRevertRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 12375  	var h codecSelfer100
 12376  	z, r := codec1978.GenHelperDecoder(d)
 12377  	_, _, _ = h, z, r
 12378  	yym1 := z.DecBinary()
 12379  	_ = yym1
 12380  	if false {
 12381  	} else if z.HasExtensions() && z.DecExt(x) {
 12382  	} else {
 12383  		yyct2 := r.ContainerType()
 12384  		if yyct2 == codecSelferValueTypeMap100 {
 12385  			yyl2 := r.ReadMapStart()
 12386  			if yyl2 == 0 {
 12387  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 12388  			} else {
 12389  				x.codecDecodeSelfFromMap(yyl2, d)
 12390  			}
 12391  		} else if yyct2 == codecSelferValueTypeArray100 {
 12392  			yyl2 := r.ReadArrayStart()
 12393  			if yyl2 == 0 {
 12394  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12395  			} else {
 12396  				x.codecDecodeSelfFromArray(yyl2, d)
 12397  			}
 12398  		} else {
 12399  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 12400  		}
 12401  	}
 12402  }
 12403  
 12404  func (x *JobRevertRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 12405  	var h codecSelfer100
 12406  	z, r := codec1978.GenHelperDecoder(d)
 12407  	_, _, _ = h, z, r
 12408  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 12409  	_ = yys3Slc
 12410  	var yyhl3 bool = l >= 0
 12411  	for yyj3 := 0; ; yyj3++ {
 12412  		if yyhl3 {
 12413  			if yyj3 >= l {
 12414  				break
 12415  			}
 12416  		} else {
 12417  			if r.CheckBreak() {
 12418  				break
 12419  			}
 12420  		}
 12421  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 12422  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 12423  		yys3 := string(yys3Slc)
 12424  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 12425  		switch yys3 {
 12426  		case "JobID":
 12427  			if r.TryDecodeAsNil() {
 12428  				x.JobID = ""
 12429  			} else {
 12430  				yyv4 := &x.JobID
 12431  				yym5 := z.DecBinary()
 12432  				_ = yym5
 12433  				if false {
 12434  				} else {
 12435  					*((*string)(yyv4)) = r.DecodeString()
 12436  				}
 12437  			}
 12438  		case "JobVersion":
 12439  			if r.TryDecodeAsNil() {
 12440  				x.JobVersion = 0
 12441  			} else {
 12442  				yyv6 := &x.JobVersion
 12443  				yym7 := z.DecBinary()
 12444  				_ = yym7
 12445  				if false {
 12446  				} else {
 12447  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 12448  				}
 12449  			}
 12450  		case "EnforcePriorVersion":
 12451  			if r.TryDecodeAsNil() {
 12452  				if x.EnforcePriorVersion != nil {
 12453  					x.EnforcePriorVersion = nil
 12454  				}
 12455  			} else {
 12456  				if x.EnforcePriorVersion == nil {
 12457  					x.EnforcePriorVersion = new(uint64)
 12458  				}
 12459  				yym9 := z.DecBinary()
 12460  				_ = yym9
 12461  				if false {
 12462  				} else {
 12463  					*((*uint64)(x.EnforcePriorVersion)) = uint64(r.DecodeUint(64))
 12464  				}
 12465  			}
 12466  		case "Region":
 12467  			if r.TryDecodeAsNil() {
 12468  				x.Region = ""
 12469  			} else {
 12470  				yyv10 := &x.Region
 12471  				yym11 := z.DecBinary()
 12472  				_ = yym11
 12473  				if false {
 12474  				} else {
 12475  					*((*string)(yyv10)) = r.DecodeString()
 12476  				}
 12477  			}
 12478  		case "Namespace":
 12479  			if r.TryDecodeAsNil() {
 12480  				x.Namespace = ""
 12481  			} else {
 12482  				yyv12 := &x.Namespace
 12483  				yym13 := z.DecBinary()
 12484  				_ = yym13
 12485  				if false {
 12486  				} else {
 12487  					*((*string)(yyv12)) = r.DecodeString()
 12488  				}
 12489  			}
 12490  		case "AuthToken":
 12491  			if r.TryDecodeAsNil() {
 12492  				x.AuthToken = ""
 12493  			} else {
 12494  				yyv14 := &x.AuthToken
 12495  				yym15 := z.DecBinary()
 12496  				_ = yym15
 12497  				if false {
 12498  				} else {
 12499  					*((*string)(yyv14)) = r.DecodeString()
 12500  				}
 12501  			}
 12502  		case "Forwarded":
 12503  			if r.TryDecodeAsNil() {
 12504  				x.Forwarded = false
 12505  			} else {
 12506  				yyv16 := &x.Forwarded
 12507  				yym17 := z.DecBinary()
 12508  				_ = yym17
 12509  				if false {
 12510  				} else {
 12511  					*((*bool)(yyv16)) = r.DecodeBool()
 12512  				}
 12513  			}
 12514  		default:
 12515  			z.DecStructFieldNotFound(-1, yys3)
 12516  		} // end switch yys3
 12517  	} // end for yyj3
 12518  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 12519  }
 12520  
 12521  func (x *JobRevertRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 12522  	var h codecSelfer100
 12523  	z, r := codec1978.GenHelperDecoder(d)
 12524  	_, _, _ = h, z, r
 12525  	var yyj18 int
 12526  	var yyb18 bool
 12527  	var yyhl18 bool = l >= 0
 12528  	yyj18++
 12529  	if yyhl18 {
 12530  		yyb18 = yyj18 > l
 12531  	} else {
 12532  		yyb18 = r.CheckBreak()
 12533  	}
 12534  	if yyb18 {
 12535  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12536  		return
 12537  	}
 12538  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 12539  	if r.TryDecodeAsNil() {
 12540  		x.JobID = ""
 12541  	} else {
 12542  		yyv19 := &x.JobID
 12543  		yym20 := z.DecBinary()
 12544  		_ = yym20
 12545  		if false {
 12546  		} else {
 12547  			*((*string)(yyv19)) = r.DecodeString()
 12548  		}
 12549  	}
 12550  	yyj18++
 12551  	if yyhl18 {
 12552  		yyb18 = yyj18 > l
 12553  	} else {
 12554  		yyb18 = r.CheckBreak()
 12555  	}
 12556  	if yyb18 {
 12557  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12558  		return
 12559  	}
 12560  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 12561  	if r.TryDecodeAsNil() {
 12562  		x.JobVersion = 0
 12563  	} else {
 12564  		yyv21 := &x.JobVersion
 12565  		yym22 := z.DecBinary()
 12566  		_ = yym22
 12567  		if false {
 12568  		} else {
 12569  			*((*uint64)(yyv21)) = uint64(r.DecodeUint(64))
 12570  		}
 12571  	}
 12572  	yyj18++
 12573  	if yyhl18 {
 12574  		yyb18 = yyj18 > l
 12575  	} else {
 12576  		yyb18 = r.CheckBreak()
 12577  	}
 12578  	if yyb18 {
 12579  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12580  		return
 12581  	}
 12582  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 12583  	if r.TryDecodeAsNil() {
 12584  		if x.EnforcePriorVersion != nil {
 12585  			x.EnforcePriorVersion = nil
 12586  		}
 12587  	} else {
 12588  		if x.EnforcePriorVersion == nil {
 12589  			x.EnforcePriorVersion = new(uint64)
 12590  		}
 12591  		yym24 := z.DecBinary()
 12592  		_ = yym24
 12593  		if false {
 12594  		} else {
 12595  			*((*uint64)(x.EnforcePriorVersion)) = uint64(r.DecodeUint(64))
 12596  		}
 12597  	}
 12598  	yyj18++
 12599  	if yyhl18 {
 12600  		yyb18 = yyj18 > l
 12601  	} else {
 12602  		yyb18 = r.CheckBreak()
 12603  	}
 12604  	if yyb18 {
 12605  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12606  		return
 12607  	}
 12608  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 12609  	if r.TryDecodeAsNil() {
 12610  		x.Region = ""
 12611  	} else {
 12612  		yyv25 := &x.Region
 12613  		yym26 := z.DecBinary()
 12614  		_ = yym26
 12615  		if false {
 12616  		} else {
 12617  			*((*string)(yyv25)) = r.DecodeString()
 12618  		}
 12619  	}
 12620  	yyj18++
 12621  	if yyhl18 {
 12622  		yyb18 = yyj18 > l
 12623  	} else {
 12624  		yyb18 = r.CheckBreak()
 12625  	}
 12626  	if yyb18 {
 12627  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12628  		return
 12629  	}
 12630  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 12631  	if r.TryDecodeAsNil() {
 12632  		x.Namespace = ""
 12633  	} else {
 12634  		yyv27 := &x.Namespace
 12635  		yym28 := z.DecBinary()
 12636  		_ = yym28
 12637  		if false {
 12638  		} else {
 12639  			*((*string)(yyv27)) = r.DecodeString()
 12640  		}
 12641  	}
 12642  	yyj18++
 12643  	if yyhl18 {
 12644  		yyb18 = yyj18 > l
 12645  	} else {
 12646  		yyb18 = r.CheckBreak()
 12647  	}
 12648  	if yyb18 {
 12649  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12650  		return
 12651  	}
 12652  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 12653  	if r.TryDecodeAsNil() {
 12654  		x.AuthToken = ""
 12655  	} else {
 12656  		yyv29 := &x.AuthToken
 12657  		yym30 := z.DecBinary()
 12658  		_ = yym30
 12659  		if false {
 12660  		} else {
 12661  			*((*string)(yyv29)) = r.DecodeString()
 12662  		}
 12663  	}
 12664  	yyj18++
 12665  	if yyhl18 {
 12666  		yyb18 = yyj18 > l
 12667  	} else {
 12668  		yyb18 = r.CheckBreak()
 12669  	}
 12670  	if yyb18 {
 12671  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12672  		return
 12673  	}
 12674  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 12675  	if r.TryDecodeAsNil() {
 12676  		x.Forwarded = false
 12677  	} else {
 12678  		yyv31 := &x.Forwarded
 12679  		yym32 := z.DecBinary()
 12680  		_ = yym32
 12681  		if false {
 12682  		} else {
 12683  			*((*bool)(yyv31)) = r.DecodeBool()
 12684  		}
 12685  	}
 12686  	for {
 12687  		yyj18++
 12688  		if yyhl18 {
 12689  			yyb18 = yyj18 > l
 12690  		} else {
 12691  			yyb18 = r.CheckBreak()
 12692  		}
 12693  		if yyb18 {
 12694  			break
 12695  		}
 12696  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 12697  		z.DecStructFieldNotFound(yyj18-1, "")
 12698  	}
 12699  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12700  }
 12701  
 12702  func (x *JobStabilityRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 12703  	var h codecSelfer100
 12704  	z, r := codec1978.GenHelperEncoder(e)
 12705  	_, _, _ = h, z, r
 12706  	if x == nil {
 12707  		r.EncodeNil()
 12708  	} else {
 12709  		yym1 := z.EncBinary()
 12710  		_ = yym1
 12711  		if false {
 12712  		} else if z.HasExtensions() && z.EncExt(x) {
 12713  		} else {
 12714  			yysep2 := !z.EncBinary()
 12715  			yy2arr2 := z.EncBasicHandle().StructToArray
 12716  			var yyq2 [7]bool
 12717  			_, _, _ = yysep2, yyq2, yy2arr2
 12718  			const yyr2 bool = false
 12719  			var yynn2 int
 12720  			if yyr2 || yy2arr2 {
 12721  				r.EncodeArrayStart(7)
 12722  			} else {
 12723  				yynn2 = 7
 12724  				for _, b := range yyq2 {
 12725  					if b {
 12726  						yynn2++
 12727  					}
 12728  				}
 12729  				r.EncodeMapStart(yynn2)
 12730  				yynn2 = 0
 12731  			}
 12732  			if yyr2 || yy2arr2 {
 12733  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 12734  				yym4 := z.EncBinary()
 12735  				_ = yym4
 12736  				if false {
 12737  				} else {
 12738  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 12739  				}
 12740  			} else {
 12741  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 12742  				r.EncodeString(codecSelferC_UTF8100, string("JobID"))
 12743  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 12744  				yym5 := z.EncBinary()
 12745  				_ = yym5
 12746  				if false {
 12747  				} else {
 12748  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 12749  				}
 12750  			}
 12751  			if yyr2 || yy2arr2 {
 12752  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 12753  				yym7 := z.EncBinary()
 12754  				_ = yym7
 12755  				if false {
 12756  				} else {
 12757  					r.EncodeUint(uint64(x.JobVersion))
 12758  				}
 12759  			} else {
 12760  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 12761  				r.EncodeString(codecSelferC_UTF8100, string("JobVersion"))
 12762  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 12763  				yym8 := z.EncBinary()
 12764  				_ = yym8
 12765  				if false {
 12766  				} else {
 12767  					r.EncodeUint(uint64(x.JobVersion))
 12768  				}
 12769  			}
 12770  			if yyr2 || yy2arr2 {
 12771  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 12772  				yym10 := z.EncBinary()
 12773  				_ = yym10
 12774  				if false {
 12775  				} else {
 12776  					r.EncodeBool(bool(x.Stable))
 12777  				}
 12778  			} else {
 12779  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 12780  				r.EncodeString(codecSelferC_UTF8100, string("Stable"))
 12781  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 12782  				yym11 := z.EncBinary()
 12783  				_ = yym11
 12784  				if false {
 12785  				} else {
 12786  					r.EncodeBool(bool(x.Stable))
 12787  				}
 12788  			}
 12789  			if yyr2 || yy2arr2 {
 12790  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 12791  				yym13 := z.EncBinary()
 12792  				_ = yym13
 12793  				if false {
 12794  				} else {
 12795  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 12796  				}
 12797  			} else {
 12798  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 12799  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 12800  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 12801  				yym14 := z.EncBinary()
 12802  				_ = yym14
 12803  				if false {
 12804  				} else {
 12805  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 12806  				}
 12807  			}
 12808  			if yyr2 || yy2arr2 {
 12809  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 12810  				yym16 := z.EncBinary()
 12811  				_ = yym16
 12812  				if false {
 12813  				} else {
 12814  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 12815  				}
 12816  			} else {
 12817  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 12818  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 12819  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 12820  				yym17 := z.EncBinary()
 12821  				_ = yym17
 12822  				if false {
 12823  				} else {
 12824  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 12825  				}
 12826  			}
 12827  			if yyr2 || yy2arr2 {
 12828  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 12829  				yym19 := z.EncBinary()
 12830  				_ = yym19
 12831  				if false {
 12832  				} else {
 12833  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 12834  				}
 12835  			} else {
 12836  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 12837  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 12838  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 12839  				yym20 := z.EncBinary()
 12840  				_ = yym20
 12841  				if false {
 12842  				} else {
 12843  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 12844  				}
 12845  			}
 12846  			if yyr2 || yy2arr2 {
 12847  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 12848  				yym22 := z.EncBinary()
 12849  				_ = yym22
 12850  				if false {
 12851  				} else {
 12852  					r.EncodeBool(bool(x.Forwarded))
 12853  				}
 12854  			} else {
 12855  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 12856  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 12857  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 12858  				yym23 := z.EncBinary()
 12859  				_ = yym23
 12860  				if false {
 12861  				} else {
 12862  					r.EncodeBool(bool(x.Forwarded))
 12863  				}
 12864  			}
 12865  			if yyr2 || yy2arr2 {
 12866  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 12867  			} else {
 12868  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 12869  			}
 12870  		}
 12871  	}
 12872  }
 12873  
 12874  func (x *JobStabilityRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 12875  	var h codecSelfer100
 12876  	z, r := codec1978.GenHelperDecoder(d)
 12877  	_, _, _ = h, z, r
 12878  	yym1 := z.DecBinary()
 12879  	_ = yym1
 12880  	if false {
 12881  	} else if z.HasExtensions() && z.DecExt(x) {
 12882  	} else {
 12883  		yyct2 := r.ContainerType()
 12884  		if yyct2 == codecSelferValueTypeMap100 {
 12885  			yyl2 := r.ReadMapStart()
 12886  			if yyl2 == 0 {
 12887  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 12888  			} else {
 12889  				x.codecDecodeSelfFromMap(yyl2, d)
 12890  			}
 12891  		} else if yyct2 == codecSelferValueTypeArray100 {
 12892  			yyl2 := r.ReadArrayStart()
 12893  			if yyl2 == 0 {
 12894  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 12895  			} else {
 12896  				x.codecDecodeSelfFromArray(yyl2, d)
 12897  			}
 12898  		} else {
 12899  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 12900  		}
 12901  	}
 12902  }
 12903  
 12904  func (x *JobStabilityRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 12905  	var h codecSelfer100
 12906  	z, r := codec1978.GenHelperDecoder(d)
 12907  	_, _, _ = h, z, r
 12908  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 12909  	_ = yys3Slc
 12910  	var yyhl3 bool = l >= 0
 12911  	for yyj3 := 0; ; yyj3++ {
 12912  		if yyhl3 {
 12913  			if yyj3 >= l {
 12914  				break
 12915  			}
 12916  		} else {
 12917  			if r.CheckBreak() {
 12918  				break
 12919  			}
 12920  		}
 12921  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 12922  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 12923  		yys3 := string(yys3Slc)
 12924  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 12925  		switch yys3 {
 12926  		case "JobID":
 12927  			if r.TryDecodeAsNil() {
 12928  				x.JobID = ""
 12929  			} else {
 12930  				yyv4 := &x.JobID
 12931  				yym5 := z.DecBinary()
 12932  				_ = yym5
 12933  				if false {
 12934  				} else {
 12935  					*((*string)(yyv4)) = r.DecodeString()
 12936  				}
 12937  			}
 12938  		case "JobVersion":
 12939  			if r.TryDecodeAsNil() {
 12940  				x.JobVersion = 0
 12941  			} else {
 12942  				yyv6 := &x.JobVersion
 12943  				yym7 := z.DecBinary()
 12944  				_ = yym7
 12945  				if false {
 12946  				} else {
 12947  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 12948  				}
 12949  			}
 12950  		case "Stable":
 12951  			if r.TryDecodeAsNil() {
 12952  				x.Stable = false
 12953  			} else {
 12954  				yyv8 := &x.Stable
 12955  				yym9 := z.DecBinary()
 12956  				_ = yym9
 12957  				if false {
 12958  				} else {
 12959  					*((*bool)(yyv8)) = r.DecodeBool()
 12960  				}
 12961  			}
 12962  		case "Region":
 12963  			if r.TryDecodeAsNil() {
 12964  				x.Region = ""
 12965  			} else {
 12966  				yyv10 := &x.Region
 12967  				yym11 := z.DecBinary()
 12968  				_ = yym11
 12969  				if false {
 12970  				} else {
 12971  					*((*string)(yyv10)) = r.DecodeString()
 12972  				}
 12973  			}
 12974  		case "Namespace":
 12975  			if r.TryDecodeAsNil() {
 12976  				x.Namespace = ""
 12977  			} else {
 12978  				yyv12 := &x.Namespace
 12979  				yym13 := z.DecBinary()
 12980  				_ = yym13
 12981  				if false {
 12982  				} else {
 12983  					*((*string)(yyv12)) = r.DecodeString()
 12984  				}
 12985  			}
 12986  		case "AuthToken":
 12987  			if r.TryDecodeAsNil() {
 12988  				x.AuthToken = ""
 12989  			} else {
 12990  				yyv14 := &x.AuthToken
 12991  				yym15 := z.DecBinary()
 12992  				_ = yym15
 12993  				if false {
 12994  				} else {
 12995  					*((*string)(yyv14)) = r.DecodeString()
 12996  				}
 12997  			}
 12998  		case "Forwarded":
 12999  			if r.TryDecodeAsNil() {
 13000  				x.Forwarded = false
 13001  			} else {
 13002  				yyv16 := &x.Forwarded
 13003  				yym17 := z.DecBinary()
 13004  				_ = yym17
 13005  				if false {
 13006  				} else {
 13007  					*((*bool)(yyv16)) = r.DecodeBool()
 13008  				}
 13009  			}
 13010  		default:
 13011  			z.DecStructFieldNotFound(-1, yys3)
 13012  		} // end switch yys3
 13013  	} // end for yyj3
 13014  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 13015  }
 13016  
 13017  func (x *JobStabilityRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 13018  	var h codecSelfer100
 13019  	z, r := codec1978.GenHelperDecoder(d)
 13020  	_, _, _ = h, z, r
 13021  	var yyj18 int
 13022  	var yyb18 bool
 13023  	var yyhl18 bool = l >= 0
 13024  	yyj18++
 13025  	if yyhl18 {
 13026  		yyb18 = yyj18 > l
 13027  	} else {
 13028  		yyb18 = r.CheckBreak()
 13029  	}
 13030  	if yyb18 {
 13031  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13032  		return
 13033  	}
 13034  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13035  	if r.TryDecodeAsNil() {
 13036  		x.JobID = ""
 13037  	} else {
 13038  		yyv19 := &x.JobID
 13039  		yym20 := z.DecBinary()
 13040  		_ = yym20
 13041  		if false {
 13042  		} else {
 13043  			*((*string)(yyv19)) = r.DecodeString()
 13044  		}
 13045  	}
 13046  	yyj18++
 13047  	if yyhl18 {
 13048  		yyb18 = yyj18 > l
 13049  	} else {
 13050  		yyb18 = r.CheckBreak()
 13051  	}
 13052  	if yyb18 {
 13053  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13054  		return
 13055  	}
 13056  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13057  	if r.TryDecodeAsNil() {
 13058  		x.JobVersion = 0
 13059  	} else {
 13060  		yyv21 := &x.JobVersion
 13061  		yym22 := z.DecBinary()
 13062  		_ = yym22
 13063  		if false {
 13064  		} else {
 13065  			*((*uint64)(yyv21)) = uint64(r.DecodeUint(64))
 13066  		}
 13067  	}
 13068  	yyj18++
 13069  	if yyhl18 {
 13070  		yyb18 = yyj18 > l
 13071  	} else {
 13072  		yyb18 = r.CheckBreak()
 13073  	}
 13074  	if yyb18 {
 13075  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13076  		return
 13077  	}
 13078  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13079  	if r.TryDecodeAsNil() {
 13080  		x.Stable = false
 13081  	} else {
 13082  		yyv23 := &x.Stable
 13083  		yym24 := z.DecBinary()
 13084  		_ = yym24
 13085  		if false {
 13086  		} else {
 13087  			*((*bool)(yyv23)) = r.DecodeBool()
 13088  		}
 13089  	}
 13090  	yyj18++
 13091  	if yyhl18 {
 13092  		yyb18 = yyj18 > l
 13093  	} else {
 13094  		yyb18 = r.CheckBreak()
 13095  	}
 13096  	if yyb18 {
 13097  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13098  		return
 13099  	}
 13100  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13101  	if r.TryDecodeAsNil() {
 13102  		x.Region = ""
 13103  	} else {
 13104  		yyv25 := &x.Region
 13105  		yym26 := z.DecBinary()
 13106  		_ = yym26
 13107  		if false {
 13108  		} else {
 13109  			*((*string)(yyv25)) = r.DecodeString()
 13110  		}
 13111  	}
 13112  	yyj18++
 13113  	if yyhl18 {
 13114  		yyb18 = yyj18 > l
 13115  	} else {
 13116  		yyb18 = r.CheckBreak()
 13117  	}
 13118  	if yyb18 {
 13119  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13120  		return
 13121  	}
 13122  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13123  	if r.TryDecodeAsNil() {
 13124  		x.Namespace = ""
 13125  	} else {
 13126  		yyv27 := &x.Namespace
 13127  		yym28 := z.DecBinary()
 13128  		_ = yym28
 13129  		if false {
 13130  		} else {
 13131  			*((*string)(yyv27)) = r.DecodeString()
 13132  		}
 13133  	}
 13134  	yyj18++
 13135  	if yyhl18 {
 13136  		yyb18 = yyj18 > l
 13137  	} else {
 13138  		yyb18 = r.CheckBreak()
 13139  	}
 13140  	if yyb18 {
 13141  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13142  		return
 13143  	}
 13144  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13145  	if r.TryDecodeAsNil() {
 13146  		x.AuthToken = ""
 13147  	} else {
 13148  		yyv29 := &x.AuthToken
 13149  		yym30 := z.DecBinary()
 13150  		_ = yym30
 13151  		if false {
 13152  		} else {
 13153  			*((*string)(yyv29)) = r.DecodeString()
 13154  		}
 13155  	}
 13156  	yyj18++
 13157  	if yyhl18 {
 13158  		yyb18 = yyj18 > l
 13159  	} else {
 13160  		yyb18 = r.CheckBreak()
 13161  	}
 13162  	if yyb18 {
 13163  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13164  		return
 13165  	}
 13166  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13167  	if r.TryDecodeAsNil() {
 13168  		x.Forwarded = false
 13169  	} else {
 13170  		yyv31 := &x.Forwarded
 13171  		yym32 := z.DecBinary()
 13172  		_ = yym32
 13173  		if false {
 13174  		} else {
 13175  			*((*bool)(yyv31)) = r.DecodeBool()
 13176  		}
 13177  	}
 13178  	for {
 13179  		yyj18++
 13180  		if yyhl18 {
 13181  			yyb18 = yyj18 > l
 13182  		} else {
 13183  			yyb18 = r.CheckBreak()
 13184  		}
 13185  		if yyb18 {
 13186  			break
 13187  		}
 13188  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13189  		z.DecStructFieldNotFound(yyj18-1, "")
 13190  	}
 13191  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13192  }
 13193  
 13194  func (x *JobStabilityResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 13195  	var h codecSelfer100
 13196  	z, r := codec1978.GenHelperEncoder(e)
 13197  	_, _, _ = h, z, r
 13198  	if x == nil {
 13199  		r.EncodeNil()
 13200  	} else {
 13201  		yym1 := z.EncBinary()
 13202  		_ = yym1
 13203  		if false {
 13204  		} else if z.HasExtensions() && z.EncExt(x) {
 13205  		} else {
 13206  			yysep2 := !z.EncBinary()
 13207  			yy2arr2 := z.EncBasicHandle().StructToArray
 13208  			var yyq2 [1]bool
 13209  			_, _, _ = yysep2, yyq2, yy2arr2
 13210  			const yyr2 bool = false
 13211  			var yynn2 int
 13212  			if yyr2 || yy2arr2 {
 13213  				r.EncodeArrayStart(1)
 13214  			} else {
 13215  				yynn2 = 1
 13216  				for _, b := range yyq2 {
 13217  					if b {
 13218  						yynn2++
 13219  					}
 13220  				}
 13221  				r.EncodeMapStart(yynn2)
 13222  				yynn2 = 0
 13223  			}
 13224  			if yyr2 || yy2arr2 {
 13225  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 13226  				yym4 := z.EncBinary()
 13227  				_ = yym4
 13228  				if false {
 13229  				} else {
 13230  					r.EncodeUint(uint64(x.Index))
 13231  				}
 13232  			} else {
 13233  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 13234  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 13235  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 13236  				yym5 := z.EncBinary()
 13237  				_ = yym5
 13238  				if false {
 13239  				} else {
 13240  					r.EncodeUint(uint64(x.Index))
 13241  				}
 13242  			}
 13243  			if yyr2 || yy2arr2 {
 13244  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 13245  			} else {
 13246  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 13247  			}
 13248  		}
 13249  	}
 13250  }
 13251  
 13252  func (x *JobStabilityResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 13253  	var h codecSelfer100
 13254  	z, r := codec1978.GenHelperDecoder(d)
 13255  	_, _, _ = h, z, r
 13256  	yym1 := z.DecBinary()
 13257  	_ = yym1
 13258  	if false {
 13259  	} else if z.HasExtensions() && z.DecExt(x) {
 13260  	} else {
 13261  		yyct2 := r.ContainerType()
 13262  		if yyct2 == codecSelferValueTypeMap100 {
 13263  			yyl2 := r.ReadMapStart()
 13264  			if yyl2 == 0 {
 13265  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 13266  			} else {
 13267  				x.codecDecodeSelfFromMap(yyl2, d)
 13268  			}
 13269  		} else if yyct2 == codecSelferValueTypeArray100 {
 13270  			yyl2 := r.ReadArrayStart()
 13271  			if yyl2 == 0 {
 13272  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13273  			} else {
 13274  				x.codecDecodeSelfFromArray(yyl2, d)
 13275  			}
 13276  		} else {
 13277  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 13278  		}
 13279  	}
 13280  }
 13281  
 13282  func (x *JobStabilityResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 13283  	var h codecSelfer100
 13284  	z, r := codec1978.GenHelperDecoder(d)
 13285  	_, _, _ = h, z, r
 13286  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 13287  	_ = yys3Slc
 13288  	var yyhl3 bool = l >= 0
 13289  	for yyj3 := 0; ; yyj3++ {
 13290  		if yyhl3 {
 13291  			if yyj3 >= l {
 13292  				break
 13293  			}
 13294  		} else {
 13295  			if r.CheckBreak() {
 13296  				break
 13297  			}
 13298  		}
 13299  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 13300  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 13301  		yys3 := string(yys3Slc)
 13302  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 13303  		switch yys3 {
 13304  		case "Index":
 13305  			if r.TryDecodeAsNil() {
 13306  				x.Index = 0
 13307  			} else {
 13308  				yyv4 := &x.Index
 13309  				yym5 := z.DecBinary()
 13310  				_ = yym5
 13311  				if false {
 13312  				} else {
 13313  					*((*uint64)(yyv4)) = uint64(r.DecodeUint(64))
 13314  				}
 13315  			}
 13316  		default:
 13317  			z.DecStructFieldNotFound(-1, yys3)
 13318  		} // end switch yys3
 13319  	} // end for yyj3
 13320  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 13321  }
 13322  
 13323  func (x *JobStabilityResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 13324  	var h codecSelfer100
 13325  	z, r := codec1978.GenHelperDecoder(d)
 13326  	_, _, _ = h, z, r
 13327  	var yyj6 int
 13328  	var yyb6 bool
 13329  	var yyhl6 bool = l >= 0
 13330  	yyj6++
 13331  	if yyhl6 {
 13332  		yyb6 = yyj6 > l
 13333  	} else {
 13334  		yyb6 = r.CheckBreak()
 13335  	}
 13336  	if yyb6 {
 13337  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13338  		return
 13339  	}
 13340  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13341  	if r.TryDecodeAsNil() {
 13342  		x.Index = 0
 13343  	} else {
 13344  		yyv7 := &x.Index
 13345  		yym8 := z.DecBinary()
 13346  		_ = yym8
 13347  		if false {
 13348  		} else {
 13349  			*((*uint64)(yyv7)) = uint64(r.DecodeUint(64))
 13350  		}
 13351  	}
 13352  	for {
 13353  		yyj6++
 13354  		if yyhl6 {
 13355  			yyb6 = yyj6 > l
 13356  		} else {
 13357  			yyb6 = r.CheckBreak()
 13358  		}
 13359  		if yyb6 {
 13360  			break
 13361  		}
 13362  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13363  		z.DecStructFieldNotFound(yyj6-1, "")
 13364  	}
 13365  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13366  }
 13367  
 13368  func (x *NodeListRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 13369  	var h codecSelfer100
 13370  	z, r := codec1978.GenHelperEncoder(e)
 13371  	_, _, _ = h, z, r
 13372  	if x == nil {
 13373  		r.EncodeNil()
 13374  	} else {
 13375  		yym1 := z.EncBinary()
 13376  		_ = yym1
 13377  		if false {
 13378  		} else if z.HasExtensions() && z.EncExt(x) {
 13379  		} else {
 13380  			yysep2 := !z.EncBinary()
 13381  			yy2arr2 := z.EncBasicHandle().StructToArray
 13382  			var yyq2 [8]bool
 13383  			_, _, _ = yysep2, yyq2, yy2arr2
 13384  			const yyr2 bool = false
 13385  			var yynn2 int
 13386  			if yyr2 || yy2arr2 {
 13387  				r.EncodeArrayStart(8)
 13388  			} else {
 13389  				yynn2 = 8
 13390  				for _, b := range yyq2 {
 13391  					if b {
 13392  						yynn2++
 13393  					}
 13394  				}
 13395  				r.EncodeMapStart(yynn2)
 13396  				yynn2 = 0
 13397  			}
 13398  			if yyr2 || yy2arr2 {
 13399  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 13400  				yym4 := z.EncBinary()
 13401  				_ = yym4
 13402  				if false {
 13403  				} else {
 13404  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 13405  				}
 13406  			} else {
 13407  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 13408  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 13409  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 13410  				yym5 := z.EncBinary()
 13411  				_ = yym5
 13412  				if false {
 13413  				} else {
 13414  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 13415  				}
 13416  			}
 13417  			if yyr2 || yy2arr2 {
 13418  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 13419  				yym7 := z.EncBinary()
 13420  				_ = yym7
 13421  				if false {
 13422  				} else {
 13423  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 13424  				}
 13425  			} else {
 13426  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 13427  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 13428  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 13429  				yym8 := z.EncBinary()
 13430  				_ = yym8
 13431  				if false {
 13432  				} else {
 13433  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 13434  				}
 13435  			}
 13436  			if yyr2 || yy2arr2 {
 13437  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 13438  				yym10 := z.EncBinary()
 13439  				_ = yym10
 13440  				if false {
 13441  				} else {
 13442  					r.EncodeUint(uint64(x.MinQueryIndex))
 13443  				}
 13444  			} else {
 13445  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 13446  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 13447  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 13448  				yym11 := z.EncBinary()
 13449  				_ = yym11
 13450  				if false {
 13451  				} else {
 13452  					r.EncodeUint(uint64(x.MinQueryIndex))
 13453  				}
 13454  			}
 13455  			if yyr2 || yy2arr2 {
 13456  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 13457  				yym13 := z.EncBinary()
 13458  				_ = yym13
 13459  				if false {
 13460  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 13461  				} else {
 13462  					r.EncodeInt(int64(x.MaxQueryTime))
 13463  				}
 13464  			} else {
 13465  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 13466  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 13467  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 13468  				yym14 := z.EncBinary()
 13469  				_ = yym14
 13470  				if false {
 13471  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 13472  				} else {
 13473  					r.EncodeInt(int64(x.MaxQueryTime))
 13474  				}
 13475  			}
 13476  			if yyr2 || yy2arr2 {
 13477  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 13478  				yym16 := z.EncBinary()
 13479  				_ = yym16
 13480  				if false {
 13481  				} else {
 13482  					r.EncodeBool(bool(x.AllowStale))
 13483  				}
 13484  			} else {
 13485  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 13486  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 13487  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 13488  				yym17 := z.EncBinary()
 13489  				_ = yym17
 13490  				if false {
 13491  				} else {
 13492  					r.EncodeBool(bool(x.AllowStale))
 13493  				}
 13494  			}
 13495  			if yyr2 || yy2arr2 {
 13496  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 13497  				yym19 := z.EncBinary()
 13498  				_ = yym19
 13499  				if false {
 13500  				} else {
 13501  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 13502  				}
 13503  			} else {
 13504  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 13505  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 13506  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 13507  				yym20 := z.EncBinary()
 13508  				_ = yym20
 13509  				if false {
 13510  				} else {
 13511  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 13512  				}
 13513  			}
 13514  			if yyr2 || yy2arr2 {
 13515  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 13516  				yym22 := z.EncBinary()
 13517  				_ = yym22
 13518  				if false {
 13519  				} else {
 13520  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 13521  				}
 13522  			} else {
 13523  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 13524  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 13525  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 13526  				yym23 := z.EncBinary()
 13527  				_ = yym23
 13528  				if false {
 13529  				} else {
 13530  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 13531  				}
 13532  			}
 13533  			if yyr2 || yy2arr2 {
 13534  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 13535  				yym25 := z.EncBinary()
 13536  				_ = yym25
 13537  				if false {
 13538  				} else {
 13539  					r.EncodeBool(bool(x.Forwarded))
 13540  				}
 13541  			} else {
 13542  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 13543  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 13544  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 13545  				yym26 := z.EncBinary()
 13546  				_ = yym26
 13547  				if false {
 13548  				} else {
 13549  					r.EncodeBool(bool(x.Forwarded))
 13550  				}
 13551  			}
 13552  			if yyr2 || yy2arr2 {
 13553  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 13554  			} else {
 13555  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 13556  			}
 13557  		}
 13558  	}
 13559  }
 13560  
 13561  func (x *NodeListRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 13562  	var h codecSelfer100
 13563  	z, r := codec1978.GenHelperDecoder(d)
 13564  	_, _, _ = h, z, r
 13565  	yym1 := z.DecBinary()
 13566  	_ = yym1
 13567  	if false {
 13568  	} else if z.HasExtensions() && z.DecExt(x) {
 13569  	} else {
 13570  		yyct2 := r.ContainerType()
 13571  		if yyct2 == codecSelferValueTypeMap100 {
 13572  			yyl2 := r.ReadMapStart()
 13573  			if yyl2 == 0 {
 13574  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 13575  			} else {
 13576  				x.codecDecodeSelfFromMap(yyl2, d)
 13577  			}
 13578  		} else if yyct2 == codecSelferValueTypeArray100 {
 13579  			yyl2 := r.ReadArrayStart()
 13580  			if yyl2 == 0 {
 13581  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13582  			} else {
 13583  				x.codecDecodeSelfFromArray(yyl2, d)
 13584  			}
 13585  		} else {
 13586  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 13587  		}
 13588  	}
 13589  }
 13590  
 13591  func (x *NodeListRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 13592  	var h codecSelfer100
 13593  	z, r := codec1978.GenHelperDecoder(d)
 13594  	_, _, _ = h, z, r
 13595  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 13596  	_ = yys3Slc
 13597  	var yyhl3 bool = l >= 0
 13598  	for yyj3 := 0; ; yyj3++ {
 13599  		if yyhl3 {
 13600  			if yyj3 >= l {
 13601  				break
 13602  			}
 13603  		} else {
 13604  			if r.CheckBreak() {
 13605  				break
 13606  			}
 13607  		}
 13608  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 13609  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 13610  		yys3 := string(yys3Slc)
 13611  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 13612  		switch yys3 {
 13613  		case "Region":
 13614  			if r.TryDecodeAsNil() {
 13615  				x.Region = ""
 13616  			} else {
 13617  				yyv4 := &x.Region
 13618  				yym5 := z.DecBinary()
 13619  				_ = yym5
 13620  				if false {
 13621  				} else {
 13622  					*((*string)(yyv4)) = r.DecodeString()
 13623  				}
 13624  			}
 13625  		case "Namespace":
 13626  			if r.TryDecodeAsNil() {
 13627  				x.Namespace = ""
 13628  			} else {
 13629  				yyv6 := &x.Namespace
 13630  				yym7 := z.DecBinary()
 13631  				_ = yym7
 13632  				if false {
 13633  				} else {
 13634  					*((*string)(yyv6)) = r.DecodeString()
 13635  				}
 13636  			}
 13637  		case "MinQueryIndex":
 13638  			if r.TryDecodeAsNil() {
 13639  				x.MinQueryIndex = 0
 13640  			} else {
 13641  				yyv8 := &x.MinQueryIndex
 13642  				yym9 := z.DecBinary()
 13643  				_ = yym9
 13644  				if false {
 13645  				} else {
 13646  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 13647  				}
 13648  			}
 13649  		case "MaxQueryTime":
 13650  			if r.TryDecodeAsNil() {
 13651  				x.MaxQueryTime = 0
 13652  			} else {
 13653  				yyv10 := &x.MaxQueryTime
 13654  				yym11 := z.DecBinary()
 13655  				_ = yym11
 13656  				if false {
 13657  				} else if z.HasExtensions() && z.DecExt(yyv10) {
 13658  				} else {
 13659  					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
 13660  				}
 13661  			}
 13662  		case "AllowStale":
 13663  			if r.TryDecodeAsNil() {
 13664  				x.AllowStale = false
 13665  			} else {
 13666  				yyv12 := &x.AllowStale
 13667  				yym13 := z.DecBinary()
 13668  				_ = yym13
 13669  				if false {
 13670  				} else {
 13671  					*((*bool)(yyv12)) = r.DecodeBool()
 13672  				}
 13673  			}
 13674  		case "Prefix":
 13675  			if r.TryDecodeAsNil() {
 13676  				x.Prefix = ""
 13677  			} else {
 13678  				yyv14 := &x.Prefix
 13679  				yym15 := z.DecBinary()
 13680  				_ = yym15
 13681  				if false {
 13682  				} else {
 13683  					*((*string)(yyv14)) = r.DecodeString()
 13684  				}
 13685  			}
 13686  		case "AuthToken":
 13687  			if r.TryDecodeAsNil() {
 13688  				x.AuthToken = ""
 13689  			} else {
 13690  				yyv16 := &x.AuthToken
 13691  				yym17 := z.DecBinary()
 13692  				_ = yym17
 13693  				if false {
 13694  				} else {
 13695  					*((*string)(yyv16)) = r.DecodeString()
 13696  				}
 13697  			}
 13698  		case "Forwarded":
 13699  			if r.TryDecodeAsNil() {
 13700  				x.Forwarded = false
 13701  			} else {
 13702  				yyv18 := &x.Forwarded
 13703  				yym19 := z.DecBinary()
 13704  				_ = yym19
 13705  				if false {
 13706  				} else {
 13707  					*((*bool)(yyv18)) = r.DecodeBool()
 13708  				}
 13709  			}
 13710  		default:
 13711  			z.DecStructFieldNotFound(-1, yys3)
 13712  		} // end switch yys3
 13713  	} // end for yyj3
 13714  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 13715  }
 13716  
 13717  func (x *NodeListRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 13718  	var h codecSelfer100
 13719  	z, r := codec1978.GenHelperDecoder(d)
 13720  	_, _, _ = h, z, r
 13721  	var yyj20 int
 13722  	var yyb20 bool
 13723  	var yyhl20 bool = l >= 0
 13724  	yyj20++
 13725  	if yyhl20 {
 13726  		yyb20 = yyj20 > l
 13727  	} else {
 13728  		yyb20 = r.CheckBreak()
 13729  	}
 13730  	if yyb20 {
 13731  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13732  		return
 13733  	}
 13734  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13735  	if r.TryDecodeAsNil() {
 13736  		x.Region = ""
 13737  	} else {
 13738  		yyv21 := &x.Region
 13739  		yym22 := z.DecBinary()
 13740  		_ = yym22
 13741  		if false {
 13742  		} else {
 13743  			*((*string)(yyv21)) = r.DecodeString()
 13744  		}
 13745  	}
 13746  	yyj20++
 13747  	if yyhl20 {
 13748  		yyb20 = yyj20 > l
 13749  	} else {
 13750  		yyb20 = r.CheckBreak()
 13751  	}
 13752  	if yyb20 {
 13753  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13754  		return
 13755  	}
 13756  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13757  	if r.TryDecodeAsNil() {
 13758  		x.Namespace = ""
 13759  	} else {
 13760  		yyv23 := &x.Namespace
 13761  		yym24 := z.DecBinary()
 13762  		_ = yym24
 13763  		if false {
 13764  		} else {
 13765  			*((*string)(yyv23)) = r.DecodeString()
 13766  		}
 13767  	}
 13768  	yyj20++
 13769  	if yyhl20 {
 13770  		yyb20 = yyj20 > l
 13771  	} else {
 13772  		yyb20 = r.CheckBreak()
 13773  	}
 13774  	if yyb20 {
 13775  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13776  		return
 13777  	}
 13778  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13779  	if r.TryDecodeAsNil() {
 13780  		x.MinQueryIndex = 0
 13781  	} else {
 13782  		yyv25 := &x.MinQueryIndex
 13783  		yym26 := z.DecBinary()
 13784  		_ = yym26
 13785  		if false {
 13786  		} else {
 13787  			*((*uint64)(yyv25)) = uint64(r.DecodeUint(64))
 13788  		}
 13789  	}
 13790  	yyj20++
 13791  	if yyhl20 {
 13792  		yyb20 = yyj20 > l
 13793  	} else {
 13794  		yyb20 = r.CheckBreak()
 13795  	}
 13796  	if yyb20 {
 13797  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13798  		return
 13799  	}
 13800  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13801  	if r.TryDecodeAsNil() {
 13802  		x.MaxQueryTime = 0
 13803  	} else {
 13804  		yyv27 := &x.MaxQueryTime
 13805  		yym28 := z.DecBinary()
 13806  		_ = yym28
 13807  		if false {
 13808  		} else if z.HasExtensions() && z.DecExt(yyv27) {
 13809  		} else {
 13810  			*((*int64)(yyv27)) = int64(r.DecodeInt(64))
 13811  		}
 13812  	}
 13813  	yyj20++
 13814  	if yyhl20 {
 13815  		yyb20 = yyj20 > l
 13816  	} else {
 13817  		yyb20 = r.CheckBreak()
 13818  	}
 13819  	if yyb20 {
 13820  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13821  		return
 13822  	}
 13823  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13824  	if r.TryDecodeAsNil() {
 13825  		x.AllowStale = false
 13826  	} else {
 13827  		yyv29 := &x.AllowStale
 13828  		yym30 := z.DecBinary()
 13829  		_ = yym30
 13830  		if false {
 13831  		} else {
 13832  			*((*bool)(yyv29)) = r.DecodeBool()
 13833  		}
 13834  	}
 13835  	yyj20++
 13836  	if yyhl20 {
 13837  		yyb20 = yyj20 > l
 13838  	} else {
 13839  		yyb20 = r.CheckBreak()
 13840  	}
 13841  	if yyb20 {
 13842  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13843  		return
 13844  	}
 13845  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13846  	if r.TryDecodeAsNil() {
 13847  		x.Prefix = ""
 13848  	} else {
 13849  		yyv31 := &x.Prefix
 13850  		yym32 := z.DecBinary()
 13851  		_ = yym32
 13852  		if false {
 13853  		} else {
 13854  			*((*string)(yyv31)) = r.DecodeString()
 13855  		}
 13856  	}
 13857  	yyj20++
 13858  	if yyhl20 {
 13859  		yyb20 = yyj20 > l
 13860  	} else {
 13861  		yyb20 = r.CheckBreak()
 13862  	}
 13863  	if yyb20 {
 13864  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13865  		return
 13866  	}
 13867  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13868  	if r.TryDecodeAsNil() {
 13869  		x.AuthToken = ""
 13870  	} else {
 13871  		yyv33 := &x.AuthToken
 13872  		yym34 := z.DecBinary()
 13873  		_ = yym34
 13874  		if false {
 13875  		} else {
 13876  			*((*string)(yyv33)) = r.DecodeString()
 13877  		}
 13878  	}
 13879  	yyj20++
 13880  	if yyhl20 {
 13881  		yyb20 = yyj20 > l
 13882  	} else {
 13883  		yyb20 = r.CheckBreak()
 13884  	}
 13885  	if yyb20 {
 13886  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13887  		return
 13888  	}
 13889  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13890  	if r.TryDecodeAsNil() {
 13891  		x.Forwarded = false
 13892  	} else {
 13893  		yyv35 := &x.Forwarded
 13894  		yym36 := z.DecBinary()
 13895  		_ = yym36
 13896  		if false {
 13897  		} else {
 13898  			*((*bool)(yyv35)) = r.DecodeBool()
 13899  		}
 13900  	}
 13901  	for {
 13902  		yyj20++
 13903  		if yyhl20 {
 13904  			yyb20 = yyj20 > l
 13905  		} else {
 13906  			yyb20 = r.CheckBreak()
 13907  		}
 13908  		if yyb20 {
 13909  			break
 13910  		}
 13911  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 13912  		z.DecStructFieldNotFound(yyj20-1, "")
 13913  	}
 13914  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 13915  }
 13916  
 13917  func (x *EvalUpdateRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 13918  	var h codecSelfer100
 13919  	z, r := codec1978.GenHelperEncoder(e)
 13920  	_, _, _ = h, z, r
 13921  	if x == nil {
 13922  		r.EncodeNil()
 13923  	} else {
 13924  		yym1 := z.EncBinary()
 13925  		_ = yym1
 13926  		if false {
 13927  		} else if z.HasExtensions() && z.EncExt(x) {
 13928  		} else {
 13929  			yysep2 := !z.EncBinary()
 13930  			yy2arr2 := z.EncBasicHandle().StructToArray
 13931  			var yyq2 [6]bool
 13932  			_, _, _ = yysep2, yyq2, yy2arr2
 13933  			const yyr2 bool = false
 13934  			var yynn2 int
 13935  			if yyr2 || yy2arr2 {
 13936  				r.EncodeArrayStart(6)
 13937  			} else {
 13938  				yynn2 = 6
 13939  				for _, b := range yyq2 {
 13940  					if b {
 13941  						yynn2++
 13942  					}
 13943  				}
 13944  				r.EncodeMapStart(yynn2)
 13945  				yynn2 = 0
 13946  			}
 13947  			if yyr2 || yy2arr2 {
 13948  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 13949  				if x.Evals == nil {
 13950  					r.EncodeNil()
 13951  				} else {
 13952  					yym4 := z.EncBinary()
 13953  					_ = yym4
 13954  					if false {
 13955  					} else {
 13956  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.Evals), e)
 13957  					}
 13958  				}
 13959  			} else {
 13960  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 13961  				r.EncodeString(codecSelferC_UTF8100, string("Evals"))
 13962  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 13963  				if x.Evals == nil {
 13964  					r.EncodeNil()
 13965  				} else {
 13966  					yym5 := z.EncBinary()
 13967  					_ = yym5
 13968  					if false {
 13969  					} else {
 13970  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.Evals), e)
 13971  					}
 13972  				}
 13973  			}
 13974  			if yyr2 || yy2arr2 {
 13975  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 13976  				yym7 := z.EncBinary()
 13977  				_ = yym7
 13978  				if false {
 13979  				} else {
 13980  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalToken))
 13981  				}
 13982  			} else {
 13983  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 13984  				r.EncodeString(codecSelferC_UTF8100, string("EvalToken"))
 13985  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 13986  				yym8 := z.EncBinary()
 13987  				_ = yym8
 13988  				if false {
 13989  				} else {
 13990  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalToken))
 13991  				}
 13992  			}
 13993  			if yyr2 || yy2arr2 {
 13994  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 13995  				yym10 := z.EncBinary()
 13996  				_ = yym10
 13997  				if false {
 13998  				} else {
 13999  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 14000  				}
 14001  			} else {
 14002  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14003  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 14004  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14005  				yym11 := z.EncBinary()
 14006  				_ = yym11
 14007  				if false {
 14008  				} else {
 14009  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 14010  				}
 14011  			}
 14012  			if yyr2 || yy2arr2 {
 14013  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14014  				yym13 := z.EncBinary()
 14015  				_ = yym13
 14016  				if false {
 14017  				} else {
 14018  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 14019  				}
 14020  			} else {
 14021  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14022  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 14023  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14024  				yym14 := z.EncBinary()
 14025  				_ = yym14
 14026  				if false {
 14027  				} else {
 14028  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 14029  				}
 14030  			}
 14031  			if yyr2 || yy2arr2 {
 14032  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14033  				yym16 := z.EncBinary()
 14034  				_ = yym16
 14035  				if false {
 14036  				} else {
 14037  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 14038  				}
 14039  			} else {
 14040  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14041  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 14042  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14043  				yym17 := z.EncBinary()
 14044  				_ = yym17
 14045  				if false {
 14046  				} else {
 14047  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 14048  				}
 14049  			}
 14050  			if yyr2 || yy2arr2 {
 14051  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14052  				yym19 := z.EncBinary()
 14053  				_ = yym19
 14054  				if false {
 14055  				} else {
 14056  					r.EncodeBool(bool(x.Forwarded))
 14057  				}
 14058  			} else {
 14059  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14060  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 14061  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14062  				yym20 := z.EncBinary()
 14063  				_ = yym20
 14064  				if false {
 14065  				} else {
 14066  					r.EncodeBool(bool(x.Forwarded))
 14067  				}
 14068  			}
 14069  			if yyr2 || yy2arr2 {
 14070  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 14071  			} else {
 14072  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 14073  			}
 14074  		}
 14075  	}
 14076  }
 14077  
 14078  func (x *EvalUpdateRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 14079  	var h codecSelfer100
 14080  	z, r := codec1978.GenHelperDecoder(d)
 14081  	_, _, _ = h, z, r
 14082  	yym1 := z.DecBinary()
 14083  	_ = yym1
 14084  	if false {
 14085  	} else if z.HasExtensions() && z.DecExt(x) {
 14086  	} else {
 14087  		yyct2 := r.ContainerType()
 14088  		if yyct2 == codecSelferValueTypeMap100 {
 14089  			yyl2 := r.ReadMapStart()
 14090  			if yyl2 == 0 {
 14091  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 14092  			} else {
 14093  				x.codecDecodeSelfFromMap(yyl2, d)
 14094  			}
 14095  		} else if yyct2 == codecSelferValueTypeArray100 {
 14096  			yyl2 := r.ReadArrayStart()
 14097  			if yyl2 == 0 {
 14098  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14099  			} else {
 14100  				x.codecDecodeSelfFromArray(yyl2, d)
 14101  			}
 14102  		} else {
 14103  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 14104  		}
 14105  	}
 14106  }
 14107  
 14108  func (x *EvalUpdateRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 14109  	var h codecSelfer100
 14110  	z, r := codec1978.GenHelperDecoder(d)
 14111  	_, _, _ = h, z, r
 14112  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 14113  	_ = yys3Slc
 14114  	var yyhl3 bool = l >= 0
 14115  	for yyj3 := 0; ; yyj3++ {
 14116  		if yyhl3 {
 14117  			if yyj3 >= l {
 14118  				break
 14119  			}
 14120  		} else {
 14121  			if r.CheckBreak() {
 14122  				break
 14123  			}
 14124  		}
 14125  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 14126  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 14127  		yys3 := string(yys3Slc)
 14128  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 14129  		switch yys3 {
 14130  		case "Evals":
 14131  			if r.TryDecodeAsNil() {
 14132  				x.Evals = nil
 14133  			} else {
 14134  				yyv4 := &x.Evals
 14135  				yym5 := z.DecBinary()
 14136  				_ = yym5
 14137  				if false {
 14138  				} else {
 14139  					h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv4), d)
 14140  				}
 14141  			}
 14142  		case "EvalToken":
 14143  			if r.TryDecodeAsNil() {
 14144  				x.EvalToken = ""
 14145  			} else {
 14146  				yyv6 := &x.EvalToken
 14147  				yym7 := z.DecBinary()
 14148  				_ = yym7
 14149  				if false {
 14150  				} else {
 14151  					*((*string)(yyv6)) = r.DecodeString()
 14152  				}
 14153  			}
 14154  		case "Region":
 14155  			if r.TryDecodeAsNil() {
 14156  				x.Region = ""
 14157  			} else {
 14158  				yyv8 := &x.Region
 14159  				yym9 := z.DecBinary()
 14160  				_ = yym9
 14161  				if false {
 14162  				} else {
 14163  					*((*string)(yyv8)) = r.DecodeString()
 14164  				}
 14165  			}
 14166  		case "Namespace":
 14167  			if r.TryDecodeAsNil() {
 14168  				x.Namespace = ""
 14169  			} else {
 14170  				yyv10 := &x.Namespace
 14171  				yym11 := z.DecBinary()
 14172  				_ = yym11
 14173  				if false {
 14174  				} else {
 14175  					*((*string)(yyv10)) = r.DecodeString()
 14176  				}
 14177  			}
 14178  		case "AuthToken":
 14179  			if r.TryDecodeAsNil() {
 14180  				x.AuthToken = ""
 14181  			} else {
 14182  				yyv12 := &x.AuthToken
 14183  				yym13 := z.DecBinary()
 14184  				_ = yym13
 14185  				if false {
 14186  				} else {
 14187  					*((*string)(yyv12)) = r.DecodeString()
 14188  				}
 14189  			}
 14190  		case "Forwarded":
 14191  			if r.TryDecodeAsNil() {
 14192  				x.Forwarded = false
 14193  			} else {
 14194  				yyv14 := &x.Forwarded
 14195  				yym15 := z.DecBinary()
 14196  				_ = yym15
 14197  				if false {
 14198  				} else {
 14199  					*((*bool)(yyv14)) = r.DecodeBool()
 14200  				}
 14201  			}
 14202  		default:
 14203  			z.DecStructFieldNotFound(-1, yys3)
 14204  		} // end switch yys3
 14205  	} // end for yyj3
 14206  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 14207  }
 14208  
 14209  func (x *EvalUpdateRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 14210  	var h codecSelfer100
 14211  	z, r := codec1978.GenHelperDecoder(d)
 14212  	_, _, _ = h, z, r
 14213  	var yyj16 int
 14214  	var yyb16 bool
 14215  	var yyhl16 bool = l >= 0
 14216  	yyj16++
 14217  	if yyhl16 {
 14218  		yyb16 = yyj16 > l
 14219  	} else {
 14220  		yyb16 = r.CheckBreak()
 14221  	}
 14222  	if yyb16 {
 14223  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14224  		return
 14225  	}
 14226  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 14227  	if r.TryDecodeAsNil() {
 14228  		x.Evals = nil
 14229  	} else {
 14230  		yyv17 := &x.Evals
 14231  		yym18 := z.DecBinary()
 14232  		_ = yym18
 14233  		if false {
 14234  		} else {
 14235  			h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv17), d)
 14236  		}
 14237  	}
 14238  	yyj16++
 14239  	if yyhl16 {
 14240  		yyb16 = yyj16 > l
 14241  	} else {
 14242  		yyb16 = r.CheckBreak()
 14243  	}
 14244  	if yyb16 {
 14245  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14246  		return
 14247  	}
 14248  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 14249  	if r.TryDecodeAsNil() {
 14250  		x.EvalToken = ""
 14251  	} else {
 14252  		yyv19 := &x.EvalToken
 14253  		yym20 := z.DecBinary()
 14254  		_ = yym20
 14255  		if false {
 14256  		} else {
 14257  			*((*string)(yyv19)) = r.DecodeString()
 14258  		}
 14259  	}
 14260  	yyj16++
 14261  	if yyhl16 {
 14262  		yyb16 = yyj16 > l
 14263  	} else {
 14264  		yyb16 = r.CheckBreak()
 14265  	}
 14266  	if yyb16 {
 14267  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14268  		return
 14269  	}
 14270  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 14271  	if r.TryDecodeAsNil() {
 14272  		x.Region = ""
 14273  	} else {
 14274  		yyv21 := &x.Region
 14275  		yym22 := z.DecBinary()
 14276  		_ = yym22
 14277  		if false {
 14278  		} else {
 14279  			*((*string)(yyv21)) = r.DecodeString()
 14280  		}
 14281  	}
 14282  	yyj16++
 14283  	if yyhl16 {
 14284  		yyb16 = yyj16 > l
 14285  	} else {
 14286  		yyb16 = r.CheckBreak()
 14287  	}
 14288  	if yyb16 {
 14289  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14290  		return
 14291  	}
 14292  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 14293  	if r.TryDecodeAsNil() {
 14294  		x.Namespace = ""
 14295  	} else {
 14296  		yyv23 := &x.Namespace
 14297  		yym24 := z.DecBinary()
 14298  		_ = yym24
 14299  		if false {
 14300  		} else {
 14301  			*((*string)(yyv23)) = r.DecodeString()
 14302  		}
 14303  	}
 14304  	yyj16++
 14305  	if yyhl16 {
 14306  		yyb16 = yyj16 > l
 14307  	} else {
 14308  		yyb16 = r.CheckBreak()
 14309  	}
 14310  	if yyb16 {
 14311  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14312  		return
 14313  	}
 14314  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 14315  	if r.TryDecodeAsNil() {
 14316  		x.AuthToken = ""
 14317  	} else {
 14318  		yyv25 := &x.AuthToken
 14319  		yym26 := z.DecBinary()
 14320  		_ = yym26
 14321  		if false {
 14322  		} else {
 14323  			*((*string)(yyv25)) = r.DecodeString()
 14324  		}
 14325  	}
 14326  	yyj16++
 14327  	if yyhl16 {
 14328  		yyb16 = yyj16 > l
 14329  	} else {
 14330  		yyb16 = r.CheckBreak()
 14331  	}
 14332  	if yyb16 {
 14333  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14334  		return
 14335  	}
 14336  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 14337  	if r.TryDecodeAsNil() {
 14338  		x.Forwarded = false
 14339  	} else {
 14340  		yyv27 := &x.Forwarded
 14341  		yym28 := z.DecBinary()
 14342  		_ = yym28
 14343  		if false {
 14344  		} else {
 14345  			*((*bool)(yyv27)) = r.DecodeBool()
 14346  		}
 14347  	}
 14348  	for {
 14349  		yyj16++
 14350  		if yyhl16 {
 14351  			yyb16 = yyj16 > l
 14352  		} else {
 14353  			yyb16 = r.CheckBreak()
 14354  		}
 14355  		if yyb16 {
 14356  			break
 14357  		}
 14358  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 14359  		z.DecStructFieldNotFound(yyj16-1, "")
 14360  	}
 14361  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14362  }
 14363  
 14364  func (x *EvalDeleteRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 14365  	var h codecSelfer100
 14366  	z, r := codec1978.GenHelperEncoder(e)
 14367  	_, _, _ = h, z, r
 14368  	if x == nil {
 14369  		r.EncodeNil()
 14370  	} else {
 14371  		yym1 := z.EncBinary()
 14372  		_ = yym1
 14373  		if false {
 14374  		} else if z.HasExtensions() && z.EncExt(x) {
 14375  		} else {
 14376  			yysep2 := !z.EncBinary()
 14377  			yy2arr2 := z.EncBasicHandle().StructToArray
 14378  			var yyq2 [6]bool
 14379  			_, _, _ = yysep2, yyq2, yy2arr2
 14380  			const yyr2 bool = false
 14381  			var yynn2 int
 14382  			if yyr2 || yy2arr2 {
 14383  				r.EncodeArrayStart(6)
 14384  			} else {
 14385  				yynn2 = 6
 14386  				for _, b := range yyq2 {
 14387  					if b {
 14388  						yynn2++
 14389  					}
 14390  				}
 14391  				r.EncodeMapStart(yynn2)
 14392  				yynn2 = 0
 14393  			}
 14394  			if yyr2 || yy2arr2 {
 14395  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14396  				if x.Evals == nil {
 14397  					r.EncodeNil()
 14398  				} else {
 14399  					yym4 := z.EncBinary()
 14400  					_ = yym4
 14401  					if false {
 14402  					} else {
 14403  						z.F.EncSliceStringV(x.Evals, false, e)
 14404  					}
 14405  				}
 14406  			} else {
 14407  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14408  				r.EncodeString(codecSelferC_UTF8100, string("Evals"))
 14409  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14410  				if x.Evals == nil {
 14411  					r.EncodeNil()
 14412  				} else {
 14413  					yym5 := z.EncBinary()
 14414  					_ = yym5
 14415  					if false {
 14416  					} else {
 14417  						z.F.EncSliceStringV(x.Evals, false, e)
 14418  					}
 14419  				}
 14420  			}
 14421  			if yyr2 || yy2arr2 {
 14422  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14423  				if x.Allocs == nil {
 14424  					r.EncodeNil()
 14425  				} else {
 14426  					yym7 := z.EncBinary()
 14427  					_ = yym7
 14428  					if false {
 14429  					} else {
 14430  						z.F.EncSliceStringV(x.Allocs, false, e)
 14431  					}
 14432  				}
 14433  			} else {
 14434  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14435  				r.EncodeString(codecSelferC_UTF8100, string("Allocs"))
 14436  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14437  				if x.Allocs == nil {
 14438  					r.EncodeNil()
 14439  				} else {
 14440  					yym8 := z.EncBinary()
 14441  					_ = yym8
 14442  					if false {
 14443  					} else {
 14444  						z.F.EncSliceStringV(x.Allocs, false, e)
 14445  					}
 14446  				}
 14447  			}
 14448  			if yyr2 || yy2arr2 {
 14449  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14450  				yym10 := z.EncBinary()
 14451  				_ = yym10
 14452  				if false {
 14453  				} else {
 14454  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 14455  				}
 14456  			} else {
 14457  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14458  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 14459  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14460  				yym11 := z.EncBinary()
 14461  				_ = yym11
 14462  				if false {
 14463  				} else {
 14464  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 14465  				}
 14466  			}
 14467  			if yyr2 || yy2arr2 {
 14468  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14469  				yym13 := z.EncBinary()
 14470  				_ = yym13
 14471  				if false {
 14472  				} else {
 14473  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 14474  				}
 14475  			} else {
 14476  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14477  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 14478  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14479  				yym14 := z.EncBinary()
 14480  				_ = yym14
 14481  				if false {
 14482  				} else {
 14483  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 14484  				}
 14485  			}
 14486  			if yyr2 || yy2arr2 {
 14487  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14488  				yym16 := z.EncBinary()
 14489  				_ = yym16
 14490  				if false {
 14491  				} else {
 14492  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 14493  				}
 14494  			} else {
 14495  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14496  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 14497  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14498  				yym17 := z.EncBinary()
 14499  				_ = yym17
 14500  				if false {
 14501  				} else {
 14502  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 14503  				}
 14504  			}
 14505  			if yyr2 || yy2arr2 {
 14506  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14507  				yym19 := z.EncBinary()
 14508  				_ = yym19
 14509  				if false {
 14510  				} else {
 14511  					r.EncodeBool(bool(x.Forwarded))
 14512  				}
 14513  			} else {
 14514  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14515  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 14516  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14517  				yym20 := z.EncBinary()
 14518  				_ = yym20
 14519  				if false {
 14520  				} else {
 14521  					r.EncodeBool(bool(x.Forwarded))
 14522  				}
 14523  			}
 14524  			if yyr2 || yy2arr2 {
 14525  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 14526  			} else {
 14527  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 14528  			}
 14529  		}
 14530  	}
 14531  }
 14532  
 14533  func (x *EvalDeleteRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 14534  	var h codecSelfer100
 14535  	z, r := codec1978.GenHelperDecoder(d)
 14536  	_, _, _ = h, z, r
 14537  	yym1 := z.DecBinary()
 14538  	_ = yym1
 14539  	if false {
 14540  	} else if z.HasExtensions() && z.DecExt(x) {
 14541  	} else {
 14542  		yyct2 := r.ContainerType()
 14543  		if yyct2 == codecSelferValueTypeMap100 {
 14544  			yyl2 := r.ReadMapStart()
 14545  			if yyl2 == 0 {
 14546  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 14547  			} else {
 14548  				x.codecDecodeSelfFromMap(yyl2, d)
 14549  			}
 14550  		} else if yyct2 == codecSelferValueTypeArray100 {
 14551  			yyl2 := r.ReadArrayStart()
 14552  			if yyl2 == 0 {
 14553  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14554  			} else {
 14555  				x.codecDecodeSelfFromArray(yyl2, d)
 14556  			}
 14557  		} else {
 14558  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 14559  		}
 14560  	}
 14561  }
 14562  
 14563  func (x *EvalDeleteRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 14564  	var h codecSelfer100
 14565  	z, r := codec1978.GenHelperDecoder(d)
 14566  	_, _, _ = h, z, r
 14567  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 14568  	_ = yys3Slc
 14569  	var yyhl3 bool = l >= 0
 14570  	for yyj3 := 0; ; yyj3++ {
 14571  		if yyhl3 {
 14572  			if yyj3 >= l {
 14573  				break
 14574  			}
 14575  		} else {
 14576  			if r.CheckBreak() {
 14577  				break
 14578  			}
 14579  		}
 14580  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 14581  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 14582  		yys3 := string(yys3Slc)
 14583  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 14584  		switch yys3 {
 14585  		case "Evals":
 14586  			if r.TryDecodeAsNil() {
 14587  				x.Evals = nil
 14588  			} else {
 14589  				yyv4 := &x.Evals
 14590  				yym5 := z.DecBinary()
 14591  				_ = yym5
 14592  				if false {
 14593  				} else {
 14594  					z.F.DecSliceStringX(yyv4, false, d)
 14595  				}
 14596  			}
 14597  		case "Allocs":
 14598  			if r.TryDecodeAsNil() {
 14599  				x.Allocs = nil
 14600  			} else {
 14601  				yyv6 := &x.Allocs
 14602  				yym7 := z.DecBinary()
 14603  				_ = yym7
 14604  				if false {
 14605  				} else {
 14606  					z.F.DecSliceStringX(yyv6, false, d)
 14607  				}
 14608  			}
 14609  		case "Region":
 14610  			if r.TryDecodeAsNil() {
 14611  				x.Region = ""
 14612  			} else {
 14613  				yyv8 := &x.Region
 14614  				yym9 := z.DecBinary()
 14615  				_ = yym9
 14616  				if false {
 14617  				} else {
 14618  					*((*string)(yyv8)) = r.DecodeString()
 14619  				}
 14620  			}
 14621  		case "Namespace":
 14622  			if r.TryDecodeAsNil() {
 14623  				x.Namespace = ""
 14624  			} else {
 14625  				yyv10 := &x.Namespace
 14626  				yym11 := z.DecBinary()
 14627  				_ = yym11
 14628  				if false {
 14629  				} else {
 14630  					*((*string)(yyv10)) = r.DecodeString()
 14631  				}
 14632  			}
 14633  		case "AuthToken":
 14634  			if r.TryDecodeAsNil() {
 14635  				x.AuthToken = ""
 14636  			} else {
 14637  				yyv12 := &x.AuthToken
 14638  				yym13 := z.DecBinary()
 14639  				_ = yym13
 14640  				if false {
 14641  				} else {
 14642  					*((*string)(yyv12)) = r.DecodeString()
 14643  				}
 14644  			}
 14645  		case "Forwarded":
 14646  			if r.TryDecodeAsNil() {
 14647  				x.Forwarded = false
 14648  			} else {
 14649  				yyv14 := &x.Forwarded
 14650  				yym15 := z.DecBinary()
 14651  				_ = yym15
 14652  				if false {
 14653  				} else {
 14654  					*((*bool)(yyv14)) = r.DecodeBool()
 14655  				}
 14656  			}
 14657  		default:
 14658  			z.DecStructFieldNotFound(-1, yys3)
 14659  		} // end switch yys3
 14660  	} // end for yyj3
 14661  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 14662  }
 14663  
 14664  func (x *EvalDeleteRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 14665  	var h codecSelfer100
 14666  	z, r := codec1978.GenHelperDecoder(d)
 14667  	_, _, _ = h, z, r
 14668  	var yyj16 int
 14669  	var yyb16 bool
 14670  	var yyhl16 bool = l >= 0
 14671  	yyj16++
 14672  	if yyhl16 {
 14673  		yyb16 = yyj16 > l
 14674  	} else {
 14675  		yyb16 = r.CheckBreak()
 14676  	}
 14677  	if yyb16 {
 14678  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14679  		return
 14680  	}
 14681  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 14682  	if r.TryDecodeAsNil() {
 14683  		x.Evals = nil
 14684  	} else {
 14685  		yyv17 := &x.Evals
 14686  		yym18 := z.DecBinary()
 14687  		_ = yym18
 14688  		if false {
 14689  		} else {
 14690  			z.F.DecSliceStringX(yyv17, false, d)
 14691  		}
 14692  	}
 14693  	yyj16++
 14694  	if yyhl16 {
 14695  		yyb16 = yyj16 > l
 14696  	} else {
 14697  		yyb16 = r.CheckBreak()
 14698  	}
 14699  	if yyb16 {
 14700  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14701  		return
 14702  	}
 14703  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 14704  	if r.TryDecodeAsNil() {
 14705  		x.Allocs = nil
 14706  	} else {
 14707  		yyv19 := &x.Allocs
 14708  		yym20 := z.DecBinary()
 14709  		_ = yym20
 14710  		if false {
 14711  		} else {
 14712  			z.F.DecSliceStringX(yyv19, false, d)
 14713  		}
 14714  	}
 14715  	yyj16++
 14716  	if yyhl16 {
 14717  		yyb16 = yyj16 > l
 14718  	} else {
 14719  		yyb16 = r.CheckBreak()
 14720  	}
 14721  	if yyb16 {
 14722  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14723  		return
 14724  	}
 14725  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 14726  	if r.TryDecodeAsNil() {
 14727  		x.Region = ""
 14728  	} else {
 14729  		yyv21 := &x.Region
 14730  		yym22 := z.DecBinary()
 14731  		_ = yym22
 14732  		if false {
 14733  		} else {
 14734  			*((*string)(yyv21)) = r.DecodeString()
 14735  		}
 14736  	}
 14737  	yyj16++
 14738  	if yyhl16 {
 14739  		yyb16 = yyj16 > l
 14740  	} else {
 14741  		yyb16 = r.CheckBreak()
 14742  	}
 14743  	if yyb16 {
 14744  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14745  		return
 14746  	}
 14747  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 14748  	if r.TryDecodeAsNil() {
 14749  		x.Namespace = ""
 14750  	} else {
 14751  		yyv23 := &x.Namespace
 14752  		yym24 := z.DecBinary()
 14753  		_ = yym24
 14754  		if false {
 14755  		} else {
 14756  			*((*string)(yyv23)) = r.DecodeString()
 14757  		}
 14758  	}
 14759  	yyj16++
 14760  	if yyhl16 {
 14761  		yyb16 = yyj16 > l
 14762  	} else {
 14763  		yyb16 = r.CheckBreak()
 14764  	}
 14765  	if yyb16 {
 14766  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14767  		return
 14768  	}
 14769  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 14770  	if r.TryDecodeAsNil() {
 14771  		x.AuthToken = ""
 14772  	} else {
 14773  		yyv25 := &x.AuthToken
 14774  		yym26 := z.DecBinary()
 14775  		_ = yym26
 14776  		if false {
 14777  		} else {
 14778  			*((*string)(yyv25)) = r.DecodeString()
 14779  		}
 14780  	}
 14781  	yyj16++
 14782  	if yyhl16 {
 14783  		yyb16 = yyj16 > l
 14784  	} else {
 14785  		yyb16 = r.CheckBreak()
 14786  	}
 14787  	if yyb16 {
 14788  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14789  		return
 14790  	}
 14791  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 14792  	if r.TryDecodeAsNil() {
 14793  		x.Forwarded = false
 14794  	} else {
 14795  		yyv27 := &x.Forwarded
 14796  		yym28 := z.DecBinary()
 14797  		_ = yym28
 14798  		if false {
 14799  		} else {
 14800  			*((*bool)(yyv27)) = r.DecodeBool()
 14801  		}
 14802  	}
 14803  	for {
 14804  		yyj16++
 14805  		if yyhl16 {
 14806  			yyb16 = yyj16 > l
 14807  		} else {
 14808  			yyb16 = r.CheckBreak()
 14809  		}
 14810  		if yyb16 {
 14811  			break
 14812  		}
 14813  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 14814  		z.DecStructFieldNotFound(yyj16-1, "")
 14815  	}
 14816  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 14817  }
 14818  
 14819  func (x *EvalSpecificRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 14820  	var h codecSelfer100
 14821  	z, r := codec1978.GenHelperEncoder(e)
 14822  	_, _, _ = h, z, r
 14823  	if x == nil {
 14824  		r.EncodeNil()
 14825  	} else {
 14826  		yym1 := z.EncBinary()
 14827  		_ = yym1
 14828  		if false {
 14829  		} else if z.HasExtensions() && z.EncExt(x) {
 14830  		} else {
 14831  			yysep2 := !z.EncBinary()
 14832  			yy2arr2 := z.EncBasicHandle().StructToArray
 14833  			var yyq2 [9]bool
 14834  			_, _, _ = yysep2, yyq2, yy2arr2
 14835  			const yyr2 bool = false
 14836  			var yynn2 int
 14837  			if yyr2 || yy2arr2 {
 14838  				r.EncodeArrayStart(9)
 14839  			} else {
 14840  				yynn2 = 9
 14841  				for _, b := range yyq2 {
 14842  					if b {
 14843  						yynn2++
 14844  					}
 14845  				}
 14846  				r.EncodeMapStart(yynn2)
 14847  				yynn2 = 0
 14848  			}
 14849  			if yyr2 || yy2arr2 {
 14850  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14851  				yym4 := z.EncBinary()
 14852  				_ = yym4
 14853  				if false {
 14854  				} else {
 14855  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 14856  				}
 14857  			} else {
 14858  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14859  				r.EncodeString(codecSelferC_UTF8100, string("EvalID"))
 14860  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14861  				yym5 := z.EncBinary()
 14862  				_ = yym5
 14863  				if false {
 14864  				} else {
 14865  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 14866  				}
 14867  			}
 14868  			if yyr2 || yy2arr2 {
 14869  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14870  				yym7 := z.EncBinary()
 14871  				_ = yym7
 14872  				if false {
 14873  				} else {
 14874  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 14875  				}
 14876  			} else {
 14877  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14878  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 14879  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14880  				yym8 := z.EncBinary()
 14881  				_ = yym8
 14882  				if false {
 14883  				} else {
 14884  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 14885  				}
 14886  			}
 14887  			if yyr2 || yy2arr2 {
 14888  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14889  				yym10 := z.EncBinary()
 14890  				_ = yym10
 14891  				if false {
 14892  				} else {
 14893  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 14894  				}
 14895  			} else {
 14896  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14897  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 14898  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14899  				yym11 := z.EncBinary()
 14900  				_ = yym11
 14901  				if false {
 14902  				} else {
 14903  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 14904  				}
 14905  			}
 14906  			if yyr2 || yy2arr2 {
 14907  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14908  				yym13 := z.EncBinary()
 14909  				_ = yym13
 14910  				if false {
 14911  				} else {
 14912  					r.EncodeUint(uint64(x.MinQueryIndex))
 14913  				}
 14914  			} else {
 14915  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14916  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 14917  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14918  				yym14 := z.EncBinary()
 14919  				_ = yym14
 14920  				if false {
 14921  				} else {
 14922  					r.EncodeUint(uint64(x.MinQueryIndex))
 14923  				}
 14924  			}
 14925  			if yyr2 || yy2arr2 {
 14926  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14927  				yym16 := z.EncBinary()
 14928  				_ = yym16
 14929  				if false {
 14930  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 14931  				} else {
 14932  					r.EncodeInt(int64(x.MaxQueryTime))
 14933  				}
 14934  			} else {
 14935  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14936  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 14937  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14938  				yym17 := z.EncBinary()
 14939  				_ = yym17
 14940  				if false {
 14941  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 14942  				} else {
 14943  					r.EncodeInt(int64(x.MaxQueryTime))
 14944  				}
 14945  			}
 14946  			if yyr2 || yy2arr2 {
 14947  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14948  				yym19 := z.EncBinary()
 14949  				_ = yym19
 14950  				if false {
 14951  				} else {
 14952  					r.EncodeBool(bool(x.AllowStale))
 14953  				}
 14954  			} else {
 14955  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14956  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 14957  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14958  				yym20 := z.EncBinary()
 14959  				_ = yym20
 14960  				if false {
 14961  				} else {
 14962  					r.EncodeBool(bool(x.AllowStale))
 14963  				}
 14964  			}
 14965  			if yyr2 || yy2arr2 {
 14966  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14967  				yym22 := z.EncBinary()
 14968  				_ = yym22
 14969  				if false {
 14970  				} else {
 14971  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 14972  				}
 14973  			} else {
 14974  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14975  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 14976  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14977  				yym23 := z.EncBinary()
 14978  				_ = yym23
 14979  				if false {
 14980  				} else {
 14981  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 14982  				}
 14983  			}
 14984  			if yyr2 || yy2arr2 {
 14985  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 14986  				yym25 := z.EncBinary()
 14987  				_ = yym25
 14988  				if false {
 14989  				} else {
 14990  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 14991  				}
 14992  			} else {
 14993  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 14994  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 14995  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 14996  				yym26 := z.EncBinary()
 14997  				_ = yym26
 14998  				if false {
 14999  				} else {
 15000  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 15001  				}
 15002  			}
 15003  			if yyr2 || yy2arr2 {
 15004  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 15005  				yym28 := z.EncBinary()
 15006  				_ = yym28
 15007  				if false {
 15008  				} else {
 15009  					r.EncodeBool(bool(x.Forwarded))
 15010  				}
 15011  			} else {
 15012  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 15013  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 15014  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 15015  				yym29 := z.EncBinary()
 15016  				_ = yym29
 15017  				if false {
 15018  				} else {
 15019  					r.EncodeBool(bool(x.Forwarded))
 15020  				}
 15021  			}
 15022  			if yyr2 || yy2arr2 {
 15023  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 15024  			} else {
 15025  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 15026  			}
 15027  		}
 15028  	}
 15029  }
 15030  
 15031  func (x *EvalSpecificRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 15032  	var h codecSelfer100
 15033  	z, r := codec1978.GenHelperDecoder(d)
 15034  	_, _, _ = h, z, r
 15035  	yym1 := z.DecBinary()
 15036  	_ = yym1
 15037  	if false {
 15038  	} else if z.HasExtensions() && z.DecExt(x) {
 15039  	} else {
 15040  		yyct2 := r.ContainerType()
 15041  		if yyct2 == codecSelferValueTypeMap100 {
 15042  			yyl2 := r.ReadMapStart()
 15043  			if yyl2 == 0 {
 15044  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 15045  			} else {
 15046  				x.codecDecodeSelfFromMap(yyl2, d)
 15047  			}
 15048  		} else if yyct2 == codecSelferValueTypeArray100 {
 15049  			yyl2 := r.ReadArrayStart()
 15050  			if yyl2 == 0 {
 15051  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15052  			} else {
 15053  				x.codecDecodeSelfFromArray(yyl2, d)
 15054  			}
 15055  		} else {
 15056  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 15057  		}
 15058  	}
 15059  }
 15060  
 15061  func (x *EvalSpecificRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 15062  	var h codecSelfer100
 15063  	z, r := codec1978.GenHelperDecoder(d)
 15064  	_, _, _ = h, z, r
 15065  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 15066  	_ = yys3Slc
 15067  	var yyhl3 bool = l >= 0
 15068  	for yyj3 := 0; ; yyj3++ {
 15069  		if yyhl3 {
 15070  			if yyj3 >= l {
 15071  				break
 15072  			}
 15073  		} else {
 15074  			if r.CheckBreak() {
 15075  				break
 15076  			}
 15077  		}
 15078  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 15079  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 15080  		yys3 := string(yys3Slc)
 15081  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 15082  		switch yys3 {
 15083  		case "EvalID":
 15084  			if r.TryDecodeAsNil() {
 15085  				x.EvalID = ""
 15086  			} else {
 15087  				yyv4 := &x.EvalID
 15088  				yym5 := z.DecBinary()
 15089  				_ = yym5
 15090  				if false {
 15091  				} else {
 15092  					*((*string)(yyv4)) = r.DecodeString()
 15093  				}
 15094  			}
 15095  		case "Region":
 15096  			if r.TryDecodeAsNil() {
 15097  				x.Region = ""
 15098  			} else {
 15099  				yyv6 := &x.Region
 15100  				yym7 := z.DecBinary()
 15101  				_ = yym7
 15102  				if false {
 15103  				} else {
 15104  					*((*string)(yyv6)) = r.DecodeString()
 15105  				}
 15106  			}
 15107  		case "Namespace":
 15108  			if r.TryDecodeAsNil() {
 15109  				x.Namespace = ""
 15110  			} else {
 15111  				yyv8 := &x.Namespace
 15112  				yym9 := z.DecBinary()
 15113  				_ = yym9
 15114  				if false {
 15115  				} else {
 15116  					*((*string)(yyv8)) = r.DecodeString()
 15117  				}
 15118  			}
 15119  		case "MinQueryIndex":
 15120  			if r.TryDecodeAsNil() {
 15121  				x.MinQueryIndex = 0
 15122  			} else {
 15123  				yyv10 := &x.MinQueryIndex
 15124  				yym11 := z.DecBinary()
 15125  				_ = yym11
 15126  				if false {
 15127  				} else {
 15128  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 15129  				}
 15130  			}
 15131  		case "MaxQueryTime":
 15132  			if r.TryDecodeAsNil() {
 15133  				x.MaxQueryTime = 0
 15134  			} else {
 15135  				yyv12 := &x.MaxQueryTime
 15136  				yym13 := z.DecBinary()
 15137  				_ = yym13
 15138  				if false {
 15139  				} else if z.HasExtensions() && z.DecExt(yyv12) {
 15140  				} else {
 15141  					*((*int64)(yyv12)) = int64(r.DecodeInt(64))
 15142  				}
 15143  			}
 15144  		case "AllowStale":
 15145  			if r.TryDecodeAsNil() {
 15146  				x.AllowStale = false
 15147  			} else {
 15148  				yyv14 := &x.AllowStale
 15149  				yym15 := z.DecBinary()
 15150  				_ = yym15
 15151  				if false {
 15152  				} else {
 15153  					*((*bool)(yyv14)) = r.DecodeBool()
 15154  				}
 15155  			}
 15156  		case "Prefix":
 15157  			if r.TryDecodeAsNil() {
 15158  				x.Prefix = ""
 15159  			} else {
 15160  				yyv16 := &x.Prefix
 15161  				yym17 := z.DecBinary()
 15162  				_ = yym17
 15163  				if false {
 15164  				} else {
 15165  					*((*string)(yyv16)) = r.DecodeString()
 15166  				}
 15167  			}
 15168  		case "AuthToken":
 15169  			if r.TryDecodeAsNil() {
 15170  				x.AuthToken = ""
 15171  			} else {
 15172  				yyv18 := &x.AuthToken
 15173  				yym19 := z.DecBinary()
 15174  				_ = yym19
 15175  				if false {
 15176  				} else {
 15177  					*((*string)(yyv18)) = r.DecodeString()
 15178  				}
 15179  			}
 15180  		case "Forwarded":
 15181  			if r.TryDecodeAsNil() {
 15182  				x.Forwarded = false
 15183  			} else {
 15184  				yyv20 := &x.Forwarded
 15185  				yym21 := z.DecBinary()
 15186  				_ = yym21
 15187  				if false {
 15188  				} else {
 15189  					*((*bool)(yyv20)) = r.DecodeBool()
 15190  				}
 15191  			}
 15192  		default:
 15193  			z.DecStructFieldNotFound(-1, yys3)
 15194  		} // end switch yys3
 15195  	} // end for yyj3
 15196  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 15197  }
 15198  
 15199  func (x *EvalSpecificRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 15200  	var h codecSelfer100
 15201  	z, r := codec1978.GenHelperDecoder(d)
 15202  	_, _, _ = h, z, r
 15203  	var yyj22 int
 15204  	var yyb22 bool
 15205  	var yyhl22 bool = l >= 0
 15206  	yyj22++
 15207  	if yyhl22 {
 15208  		yyb22 = yyj22 > l
 15209  	} else {
 15210  		yyb22 = r.CheckBreak()
 15211  	}
 15212  	if yyb22 {
 15213  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15214  		return
 15215  	}
 15216  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15217  	if r.TryDecodeAsNil() {
 15218  		x.EvalID = ""
 15219  	} else {
 15220  		yyv23 := &x.EvalID
 15221  		yym24 := z.DecBinary()
 15222  		_ = yym24
 15223  		if false {
 15224  		} else {
 15225  			*((*string)(yyv23)) = r.DecodeString()
 15226  		}
 15227  	}
 15228  	yyj22++
 15229  	if yyhl22 {
 15230  		yyb22 = yyj22 > l
 15231  	} else {
 15232  		yyb22 = r.CheckBreak()
 15233  	}
 15234  	if yyb22 {
 15235  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15236  		return
 15237  	}
 15238  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15239  	if r.TryDecodeAsNil() {
 15240  		x.Region = ""
 15241  	} else {
 15242  		yyv25 := &x.Region
 15243  		yym26 := z.DecBinary()
 15244  		_ = yym26
 15245  		if false {
 15246  		} else {
 15247  			*((*string)(yyv25)) = r.DecodeString()
 15248  		}
 15249  	}
 15250  	yyj22++
 15251  	if yyhl22 {
 15252  		yyb22 = yyj22 > l
 15253  	} else {
 15254  		yyb22 = r.CheckBreak()
 15255  	}
 15256  	if yyb22 {
 15257  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15258  		return
 15259  	}
 15260  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15261  	if r.TryDecodeAsNil() {
 15262  		x.Namespace = ""
 15263  	} else {
 15264  		yyv27 := &x.Namespace
 15265  		yym28 := z.DecBinary()
 15266  		_ = yym28
 15267  		if false {
 15268  		} else {
 15269  			*((*string)(yyv27)) = r.DecodeString()
 15270  		}
 15271  	}
 15272  	yyj22++
 15273  	if yyhl22 {
 15274  		yyb22 = yyj22 > l
 15275  	} else {
 15276  		yyb22 = r.CheckBreak()
 15277  	}
 15278  	if yyb22 {
 15279  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15280  		return
 15281  	}
 15282  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15283  	if r.TryDecodeAsNil() {
 15284  		x.MinQueryIndex = 0
 15285  	} else {
 15286  		yyv29 := &x.MinQueryIndex
 15287  		yym30 := z.DecBinary()
 15288  		_ = yym30
 15289  		if false {
 15290  		} else {
 15291  			*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
 15292  		}
 15293  	}
 15294  	yyj22++
 15295  	if yyhl22 {
 15296  		yyb22 = yyj22 > l
 15297  	} else {
 15298  		yyb22 = r.CheckBreak()
 15299  	}
 15300  	if yyb22 {
 15301  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15302  		return
 15303  	}
 15304  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15305  	if r.TryDecodeAsNil() {
 15306  		x.MaxQueryTime = 0
 15307  	} else {
 15308  		yyv31 := &x.MaxQueryTime
 15309  		yym32 := z.DecBinary()
 15310  		_ = yym32
 15311  		if false {
 15312  		} else if z.HasExtensions() && z.DecExt(yyv31) {
 15313  		} else {
 15314  			*((*int64)(yyv31)) = int64(r.DecodeInt(64))
 15315  		}
 15316  	}
 15317  	yyj22++
 15318  	if yyhl22 {
 15319  		yyb22 = yyj22 > l
 15320  	} else {
 15321  		yyb22 = r.CheckBreak()
 15322  	}
 15323  	if yyb22 {
 15324  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15325  		return
 15326  	}
 15327  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15328  	if r.TryDecodeAsNil() {
 15329  		x.AllowStale = false
 15330  	} else {
 15331  		yyv33 := &x.AllowStale
 15332  		yym34 := z.DecBinary()
 15333  		_ = yym34
 15334  		if false {
 15335  		} else {
 15336  			*((*bool)(yyv33)) = r.DecodeBool()
 15337  		}
 15338  	}
 15339  	yyj22++
 15340  	if yyhl22 {
 15341  		yyb22 = yyj22 > l
 15342  	} else {
 15343  		yyb22 = r.CheckBreak()
 15344  	}
 15345  	if yyb22 {
 15346  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15347  		return
 15348  	}
 15349  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15350  	if r.TryDecodeAsNil() {
 15351  		x.Prefix = ""
 15352  	} else {
 15353  		yyv35 := &x.Prefix
 15354  		yym36 := z.DecBinary()
 15355  		_ = yym36
 15356  		if false {
 15357  		} else {
 15358  			*((*string)(yyv35)) = r.DecodeString()
 15359  		}
 15360  	}
 15361  	yyj22++
 15362  	if yyhl22 {
 15363  		yyb22 = yyj22 > l
 15364  	} else {
 15365  		yyb22 = r.CheckBreak()
 15366  	}
 15367  	if yyb22 {
 15368  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15369  		return
 15370  	}
 15371  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15372  	if r.TryDecodeAsNil() {
 15373  		x.AuthToken = ""
 15374  	} else {
 15375  		yyv37 := &x.AuthToken
 15376  		yym38 := z.DecBinary()
 15377  		_ = yym38
 15378  		if false {
 15379  		} else {
 15380  			*((*string)(yyv37)) = r.DecodeString()
 15381  		}
 15382  	}
 15383  	yyj22++
 15384  	if yyhl22 {
 15385  		yyb22 = yyj22 > l
 15386  	} else {
 15387  		yyb22 = r.CheckBreak()
 15388  	}
 15389  	if yyb22 {
 15390  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15391  		return
 15392  	}
 15393  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15394  	if r.TryDecodeAsNil() {
 15395  		x.Forwarded = false
 15396  	} else {
 15397  		yyv39 := &x.Forwarded
 15398  		yym40 := z.DecBinary()
 15399  		_ = yym40
 15400  		if false {
 15401  		} else {
 15402  			*((*bool)(yyv39)) = r.DecodeBool()
 15403  		}
 15404  	}
 15405  	for {
 15406  		yyj22++
 15407  		if yyhl22 {
 15408  			yyb22 = yyj22 > l
 15409  		} else {
 15410  			yyb22 = r.CheckBreak()
 15411  		}
 15412  		if yyb22 {
 15413  			break
 15414  		}
 15415  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15416  		z.DecStructFieldNotFound(yyj22-1, "")
 15417  	}
 15418  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15419  }
 15420  
 15421  func (x *EvalAckRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 15422  	var h codecSelfer100
 15423  	z, r := codec1978.GenHelperEncoder(e)
 15424  	_, _, _ = h, z, r
 15425  	if x == nil {
 15426  		r.EncodeNil()
 15427  	} else {
 15428  		yym1 := z.EncBinary()
 15429  		_ = yym1
 15430  		if false {
 15431  		} else if z.HasExtensions() && z.EncExt(x) {
 15432  		} else {
 15433  			yysep2 := !z.EncBinary()
 15434  			yy2arr2 := z.EncBasicHandle().StructToArray
 15435  			var yyq2 [6]bool
 15436  			_, _, _ = yysep2, yyq2, yy2arr2
 15437  			const yyr2 bool = false
 15438  			var yynn2 int
 15439  			if yyr2 || yy2arr2 {
 15440  				r.EncodeArrayStart(6)
 15441  			} else {
 15442  				yynn2 = 6
 15443  				for _, b := range yyq2 {
 15444  					if b {
 15445  						yynn2++
 15446  					}
 15447  				}
 15448  				r.EncodeMapStart(yynn2)
 15449  				yynn2 = 0
 15450  			}
 15451  			if yyr2 || yy2arr2 {
 15452  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 15453  				yym4 := z.EncBinary()
 15454  				_ = yym4
 15455  				if false {
 15456  				} else {
 15457  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 15458  				}
 15459  			} else {
 15460  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 15461  				r.EncodeString(codecSelferC_UTF8100, string("EvalID"))
 15462  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 15463  				yym5 := z.EncBinary()
 15464  				_ = yym5
 15465  				if false {
 15466  				} else {
 15467  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 15468  				}
 15469  			}
 15470  			if yyr2 || yy2arr2 {
 15471  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 15472  				yym7 := z.EncBinary()
 15473  				_ = yym7
 15474  				if false {
 15475  				} else {
 15476  					r.EncodeString(codecSelferC_UTF8100, string(x.Token))
 15477  				}
 15478  			} else {
 15479  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 15480  				r.EncodeString(codecSelferC_UTF8100, string("Token"))
 15481  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 15482  				yym8 := z.EncBinary()
 15483  				_ = yym8
 15484  				if false {
 15485  				} else {
 15486  					r.EncodeString(codecSelferC_UTF8100, string(x.Token))
 15487  				}
 15488  			}
 15489  			if yyr2 || yy2arr2 {
 15490  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 15491  				yym10 := z.EncBinary()
 15492  				_ = yym10
 15493  				if false {
 15494  				} else {
 15495  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 15496  				}
 15497  			} else {
 15498  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 15499  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 15500  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 15501  				yym11 := z.EncBinary()
 15502  				_ = yym11
 15503  				if false {
 15504  				} else {
 15505  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 15506  				}
 15507  			}
 15508  			if yyr2 || yy2arr2 {
 15509  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 15510  				yym13 := z.EncBinary()
 15511  				_ = yym13
 15512  				if false {
 15513  				} else {
 15514  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 15515  				}
 15516  			} else {
 15517  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 15518  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 15519  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 15520  				yym14 := z.EncBinary()
 15521  				_ = yym14
 15522  				if false {
 15523  				} else {
 15524  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 15525  				}
 15526  			}
 15527  			if yyr2 || yy2arr2 {
 15528  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 15529  				yym16 := z.EncBinary()
 15530  				_ = yym16
 15531  				if false {
 15532  				} else {
 15533  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 15534  				}
 15535  			} else {
 15536  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 15537  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 15538  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 15539  				yym17 := z.EncBinary()
 15540  				_ = yym17
 15541  				if false {
 15542  				} else {
 15543  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 15544  				}
 15545  			}
 15546  			if yyr2 || yy2arr2 {
 15547  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 15548  				yym19 := z.EncBinary()
 15549  				_ = yym19
 15550  				if false {
 15551  				} else {
 15552  					r.EncodeBool(bool(x.Forwarded))
 15553  				}
 15554  			} else {
 15555  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 15556  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 15557  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 15558  				yym20 := z.EncBinary()
 15559  				_ = yym20
 15560  				if false {
 15561  				} else {
 15562  					r.EncodeBool(bool(x.Forwarded))
 15563  				}
 15564  			}
 15565  			if yyr2 || yy2arr2 {
 15566  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 15567  			} else {
 15568  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 15569  			}
 15570  		}
 15571  	}
 15572  }
 15573  
 15574  func (x *EvalAckRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 15575  	var h codecSelfer100
 15576  	z, r := codec1978.GenHelperDecoder(d)
 15577  	_, _, _ = h, z, r
 15578  	yym1 := z.DecBinary()
 15579  	_ = yym1
 15580  	if false {
 15581  	} else if z.HasExtensions() && z.DecExt(x) {
 15582  	} else {
 15583  		yyct2 := r.ContainerType()
 15584  		if yyct2 == codecSelferValueTypeMap100 {
 15585  			yyl2 := r.ReadMapStart()
 15586  			if yyl2 == 0 {
 15587  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 15588  			} else {
 15589  				x.codecDecodeSelfFromMap(yyl2, d)
 15590  			}
 15591  		} else if yyct2 == codecSelferValueTypeArray100 {
 15592  			yyl2 := r.ReadArrayStart()
 15593  			if yyl2 == 0 {
 15594  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15595  			} else {
 15596  				x.codecDecodeSelfFromArray(yyl2, d)
 15597  			}
 15598  		} else {
 15599  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 15600  		}
 15601  	}
 15602  }
 15603  
 15604  func (x *EvalAckRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 15605  	var h codecSelfer100
 15606  	z, r := codec1978.GenHelperDecoder(d)
 15607  	_, _, _ = h, z, r
 15608  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 15609  	_ = yys3Slc
 15610  	var yyhl3 bool = l >= 0
 15611  	for yyj3 := 0; ; yyj3++ {
 15612  		if yyhl3 {
 15613  			if yyj3 >= l {
 15614  				break
 15615  			}
 15616  		} else {
 15617  			if r.CheckBreak() {
 15618  				break
 15619  			}
 15620  		}
 15621  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 15622  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 15623  		yys3 := string(yys3Slc)
 15624  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 15625  		switch yys3 {
 15626  		case "EvalID":
 15627  			if r.TryDecodeAsNil() {
 15628  				x.EvalID = ""
 15629  			} else {
 15630  				yyv4 := &x.EvalID
 15631  				yym5 := z.DecBinary()
 15632  				_ = yym5
 15633  				if false {
 15634  				} else {
 15635  					*((*string)(yyv4)) = r.DecodeString()
 15636  				}
 15637  			}
 15638  		case "Token":
 15639  			if r.TryDecodeAsNil() {
 15640  				x.Token = ""
 15641  			} else {
 15642  				yyv6 := &x.Token
 15643  				yym7 := z.DecBinary()
 15644  				_ = yym7
 15645  				if false {
 15646  				} else {
 15647  					*((*string)(yyv6)) = r.DecodeString()
 15648  				}
 15649  			}
 15650  		case "Region":
 15651  			if r.TryDecodeAsNil() {
 15652  				x.Region = ""
 15653  			} else {
 15654  				yyv8 := &x.Region
 15655  				yym9 := z.DecBinary()
 15656  				_ = yym9
 15657  				if false {
 15658  				} else {
 15659  					*((*string)(yyv8)) = r.DecodeString()
 15660  				}
 15661  			}
 15662  		case "Namespace":
 15663  			if r.TryDecodeAsNil() {
 15664  				x.Namespace = ""
 15665  			} else {
 15666  				yyv10 := &x.Namespace
 15667  				yym11 := z.DecBinary()
 15668  				_ = yym11
 15669  				if false {
 15670  				} else {
 15671  					*((*string)(yyv10)) = r.DecodeString()
 15672  				}
 15673  			}
 15674  		case "AuthToken":
 15675  			if r.TryDecodeAsNil() {
 15676  				x.AuthToken = ""
 15677  			} else {
 15678  				yyv12 := &x.AuthToken
 15679  				yym13 := z.DecBinary()
 15680  				_ = yym13
 15681  				if false {
 15682  				} else {
 15683  					*((*string)(yyv12)) = r.DecodeString()
 15684  				}
 15685  			}
 15686  		case "Forwarded":
 15687  			if r.TryDecodeAsNil() {
 15688  				x.Forwarded = false
 15689  			} else {
 15690  				yyv14 := &x.Forwarded
 15691  				yym15 := z.DecBinary()
 15692  				_ = yym15
 15693  				if false {
 15694  				} else {
 15695  					*((*bool)(yyv14)) = r.DecodeBool()
 15696  				}
 15697  			}
 15698  		default:
 15699  			z.DecStructFieldNotFound(-1, yys3)
 15700  		} // end switch yys3
 15701  	} // end for yyj3
 15702  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 15703  }
 15704  
 15705  func (x *EvalAckRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 15706  	var h codecSelfer100
 15707  	z, r := codec1978.GenHelperDecoder(d)
 15708  	_, _, _ = h, z, r
 15709  	var yyj16 int
 15710  	var yyb16 bool
 15711  	var yyhl16 bool = l >= 0
 15712  	yyj16++
 15713  	if yyhl16 {
 15714  		yyb16 = yyj16 > l
 15715  	} else {
 15716  		yyb16 = r.CheckBreak()
 15717  	}
 15718  	if yyb16 {
 15719  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15720  		return
 15721  	}
 15722  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15723  	if r.TryDecodeAsNil() {
 15724  		x.EvalID = ""
 15725  	} else {
 15726  		yyv17 := &x.EvalID
 15727  		yym18 := z.DecBinary()
 15728  		_ = yym18
 15729  		if false {
 15730  		} else {
 15731  			*((*string)(yyv17)) = r.DecodeString()
 15732  		}
 15733  	}
 15734  	yyj16++
 15735  	if yyhl16 {
 15736  		yyb16 = yyj16 > l
 15737  	} else {
 15738  		yyb16 = r.CheckBreak()
 15739  	}
 15740  	if yyb16 {
 15741  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15742  		return
 15743  	}
 15744  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15745  	if r.TryDecodeAsNil() {
 15746  		x.Token = ""
 15747  	} else {
 15748  		yyv19 := &x.Token
 15749  		yym20 := z.DecBinary()
 15750  		_ = yym20
 15751  		if false {
 15752  		} else {
 15753  			*((*string)(yyv19)) = r.DecodeString()
 15754  		}
 15755  	}
 15756  	yyj16++
 15757  	if yyhl16 {
 15758  		yyb16 = yyj16 > l
 15759  	} else {
 15760  		yyb16 = r.CheckBreak()
 15761  	}
 15762  	if yyb16 {
 15763  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15764  		return
 15765  	}
 15766  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15767  	if r.TryDecodeAsNil() {
 15768  		x.Region = ""
 15769  	} else {
 15770  		yyv21 := &x.Region
 15771  		yym22 := z.DecBinary()
 15772  		_ = yym22
 15773  		if false {
 15774  		} else {
 15775  			*((*string)(yyv21)) = r.DecodeString()
 15776  		}
 15777  	}
 15778  	yyj16++
 15779  	if yyhl16 {
 15780  		yyb16 = yyj16 > l
 15781  	} else {
 15782  		yyb16 = r.CheckBreak()
 15783  	}
 15784  	if yyb16 {
 15785  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15786  		return
 15787  	}
 15788  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15789  	if r.TryDecodeAsNil() {
 15790  		x.Namespace = ""
 15791  	} else {
 15792  		yyv23 := &x.Namespace
 15793  		yym24 := z.DecBinary()
 15794  		_ = yym24
 15795  		if false {
 15796  		} else {
 15797  			*((*string)(yyv23)) = r.DecodeString()
 15798  		}
 15799  	}
 15800  	yyj16++
 15801  	if yyhl16 {
 15802  		yyb16 = yyj16 > l
 15803  	} else {
 15804  		yyb16 = r.CheckBreak()
 15805  	}
 15806  	if yyb16 {
 15807  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15808  		return
 15809  	}
 15810  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15811  	if r.TryDecodeAsNil() {
 15812  		x.AuthToken = ""
 15813  	} else {
 15814  		yyv25 := &x.AuthToken
 15815  		yym26 := z.DecBinary()
 15816  		_ = yym26
 15817  		if false {
 15818  		} else {
 15819  			*((*string)(yyv25)) = r.DecodeString()
 15820  		}
 15821  	}
 15822  	yyj16++
 15823  	if yyhl16 {
 15824  		yyb16 = yyj16 > l
 15825  	} else {
 15826  		yyb16 = r.CheckBreak()
 15827  	}
 15828  	if yyb16 {
 15829  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15830  		return
 15831  	}
 15832  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15833  	if r.TryDecodeAsNil() {
 15834  		x.Forwarded = false
 15835  	} else {
 15836  		yyv27 := &x.Forwarded
 15837  		yym28 := z.DecBinary()
 15838  		_ = yym28
 15839  		if false {
 15840  		} else {
 15841  			*((*bool)(yyv27)) = r.DecodeBool()
 15842  		}
 15843  	}
 15844  	for {
 15845  		yyj16++
 15846  		if yyhl16 {
 15847  			yyb16 = yyj16 > l
 15848  		} else {
 15849  			yyb16 = r.CheckBreak()
 15850  		}
 15851  		if yyb16 {
 15852  			break
 15853  		}
 15854  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 15855  		z.DecStructFieldNotFound(yyj16-1, "")
 15856  	}
 15857  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 15858  }
 15859  
 15860  func (x *EvalDequeueRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 15861  	var h codecSelfer100
 15862  	z, r := codec1978.GenHelperEncoder(e)
 15863  	_, _, _ = h, z, r
 15864  	if x == nil {
 15865  		r.EncodeNil()
 15866  	} else {
 15867  		yym1 := z.EncBinary()
 15868  		_ = yym1
 15869  		if false {
 15870  		} else if z.HasExtensions() && z.EncExt(x) {
 15871  		} else {
 15872  			yysep2 := !z.EncBinary()
 15873  			yy2arr2 := z.EncBasicHandle().StructToArray
 15874  			var yyq2 [7]bool
 15875  			_, _, _ = yysep2, yyq2, yy2arr2
 15876  			const yyr2 bool = false
 15877  			var yynn2 int
 15878  			if yyr2 || yy2arr2 {
 15879  				r.EncodeArrayStart(7)
 15880  			} else {
 15881  				yynn2 = 7
 15882  				for _, b := range yyq2 {
 15883  					if b {
 15884  						yynn2++
 15885  					}
 15886  				}
 15887  				r.EncodeMapStart(yynn2)
 15888  				yynn2 = 0
 15889  			}
 15890  			if yyr2 || yy2arr2 {
 15891  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 15892  				if x.Schedulers == nil {
 15893  					r.EncodeNil()
 15894  				} else {
 15895  					yym4 := z.EncBinary()
 15896  					_ = yym4
 15897  					if false {
 15898  					} else {
 15899  						z.F.EncSliceStringV(x.Schedulers, false, e)
 15900  					}
 15901  				}
 15902  			} else {
 15903  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 15904  				r.EncodeString(codecSelferC_UTF8100, string("Schedulers"))
 15905  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 15906  				if x.Schedulers == nil {
 15907  					r.EncodeNil()
 15908  				} else {
 15909  					yym5 := z.EncBinary()
 15910  					_ = yym5
 15911  					if false {
 15912  					} else {
 15913  						z.F.EncSliceStringV(x.Schedulers, false, e)
 15914  					}
 15915  				}
 15916  			}
 15917  			if yyr2 || yy2arr2 {
 15918  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 15919  				yym7 := z.EncBinary()
 15920  				_ = yym7
 15921  				if false {
 15922  				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
 15923  				} else {
 15924  					r.EncodeInt(int64(x.Timeout))
 15925  				}
 15926  			} else {
 15927  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 15928  				r.EncodeString(codecSelferC_UTF8100, string("Timeout"))
 15929  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 15930  				yym8 := z.EncBinary()
 15931  				_ = yym8
 15932  				if false {
 15933  				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
 15934  				} else {
 15935  					r.EncodeInt(int64(x.Timeout))
 15936  				}
 15937  			}
 15938  			if yyr2 || yy2arr2 {
 15939  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 15940  				yym10 := z.EncBinary()
 15941  				_ = yym10
 15942  				if false {
 15943  				} else {
 15944  					r.EncodeUint(uint64(x.SchedulerVersion))
 15945  				}
 15946  			} else {
 15947  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 15948  				r.EncodeString(codecSelferC_UTF8100, string("SchedulerVersion"))
 15949  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 15950  				yym11 := z.EncBinary()
 15951  				_ = yym11
 15952  				if false {
 15953  				} else {
 15954  					r.EncodeUint(uint64(x.SchedulerVersion))
 15955  				}
 15956  			}
 15957  			if yyr2 || yy2arr2 {
 15958  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 15959  				yym13 := z.EncBinary()
 15960  				_ = yym13
 15961  				if false {
 15962  				} else {
 15963  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 15964  				}
 15965  			} else {
 15966  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 15967  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 15968  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 15969  				yym14 := z.EncBinary()
 15970  				_ = yym14
 15971  				if false {
 15972  				} else {
 15973  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 15974  				}
 15975  			}
 15976  			if yyr2 || yy2arr2 {
 15977  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 15978  				yym16 := z.EncBinary()
 15979  				_ = yym16
 15980  				if false {
 15981  				} else {
 15982  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 15983  				}
 15984  			} else {
 15985  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 15986  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 15987  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 15988  				yym17 := z.EncBinary()
 15989  				_ = yym17
 15990  				if false {
 15991  				} else {
 15992  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 15993  				}
 15994  			}
 15995  			if yyr2 || yy2arr2 {
 15996  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 15997  				yym19 := z.EncBinary()
 15998  				_ = yym19
 15999  				if false {
 16000  				} else {
 16001  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 16002  				}
 16003  			} else {
 16004  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 16005  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 16006  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 16007  				yym20 := z.EncBinary()
 16008  				_ = yym20
 16009  				if false {
 16010  				} else {
 16011  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 16012  				}
 16013  			}
 16014  			if yyr2 || yy2arr2 {
 16015  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 16016  				yym22 := z.EncBinary()
 16017  				_ = yym22
 16018  				if false {
 16019  				} else {
 16020  					r.EncodeBool(bool(x.Forwarded))
 16021  				}
 16022  			} else {
 16023  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 16024  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 16025  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 16026  				yym23 := z.EncBinary()
 16027  				_ = yym23
 16028  				if false {
 16029  				} else {
 16030  					r.EncodeBool(bool(x.Forwarded))
 16031  				}
 16032  			}
 16033  			if yyr2 || yy2arr2 {
 16034  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 16035  			} else {
 16036  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 16037  			}
 16038  		}
 16039  	}
 16040  }
 16041  
 16042  func (x *EvalDequeueRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 16043  	var h codecSelfer100
 16044  	z, r := codec1978.GenHelperDecoder(d)
 16045  	_, _, _ = h, z, r
 16046  	yym1 := z.DecBinary()
 16047  	_ = yym1
 16048  	if false {
 16049  	} else if z.HasExtensions() && z.DecExt(x) {
 16050  	} else {
 16051  		yyct2 := r.ContainerType()
 16052  		if yyct2 == codecSelferValueTypeMap100 {
 16053  			yyl2 := r.ReadMapStart()
 16054  			if yyl2 == 0 {
 16055  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 16056  			} else {
 16057  				x.codecDecodeSelfFromMap(yyl2, d)
 16058  			}
 16059  		} else if yyct2 == codecSelferValueTypeArray100 {
 16060  			yyl2 := r.ReadArrayStart()
 16061  			if yyl2 == 0 {
 16062  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16063  			} else {
 16064  				x.codecDecodeSelfFromArray(yyl2, d)
 16065  			}
 16066  		} else {
 16067  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 16068  		}
 16069  	}
 16070  }
 16071  
 16072  func (x *EvalDequeueRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 16073  	var h codecSelfer100
 16074  	z, r := codec1978.GenHelperDecoder(d)
 16075  	_, _, _ = h, z, r
 16076  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 16077  	_ = yys3Slc
 16078  	var yyhl3 bool = l >= 0
 16079  	for yyj3 := 0; ; yyj3++ {
 16080  		if yyhl3 {
 16081  			if yyj3 >= l {
 16082  				break
 16083  			}
 16084  		} else {
 16085  			if r.CheckBreak() {
 16086  				break
 16087  			}
 16088  		}
 16089  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 16090  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 16091  		yys3 := string(yys3Slc)
 16092  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 16093  		switch yys3 {
 16094  		case "Schedulers":
 16095  			if r.TryDecodeAsNil() {
 16096  				x.Schedulers = nil
 16097  			} else {
 16098  				yyv4 := &x.Schedulers
 16099  				yym5 := z.DecBinary()
 16100  				_ = yym5
 16101  				if false {
 16102  				} else {
 16103  					z.F.DecSliceStringX(yyv4, false, d)
 16104  				}
 16105  			}
 16106  		case "Timeout":
 16107  			if r.TryDecodeAsNil() {
 16108  				x.Timeout = 0
 16109  			} else {
 16110  				yyv6 := &x.Timeout
 16111  				yym7 := z.DecBinary()
 16112  				_ = yym7
 16113  				if false {
 16114  				} else if z.HasExtensions() && z.DecExt(yyv6) {
 16115  				} else {
 16116  					*((*int64)(yyv6)) = int64(r.DecodeInt(64))
 16117  				}
 16118  			}
 16119  		case "SchedulerVersion":
 16120  			if r.TryDecodeAsNil() {
 16121  				x.SchedulerVersion = 0
 16122  			} else {
 16123  				yyv8 := &x.SchedulerVersion
 16124  				yym9 := z.DecBinary()
 16125  				_ = yym9
 16126  				if false {
 16127  				} else {
 16128  					*((*uint16)(yyv8)) = uint16(r.DecodeUint(16))
 16129  				}
 16130  			}
 16131  		case "Region":
 16132  			if r.TryDecodeAsNil() {
 16133  				x.Region = ""
 16134  			} else {
 16135  				yyv10 := &x.Region
 16136  				yym11 := z.DecBinary()
 16137  				_ = yym11
 16138  				if false {
 16139  				} else {
 16140  					*((*string)(yyv10)) = r.DecodeString()
 16141  				}
 16142  			}
 16143  		case "Namespace":
 16144  			if r.TryDecodeAsNil() {
 16145  				x.Namespace = ""
 16146  			} else {
 16147  				yyv12 := &x.Namespace
 16148  				yym13 := z.DecBinary()
 16149  				_ = yym13
 16150  				if false {
 16151  				} else {
 16152  					*((*string)(yyv12)) = r.DecodeString()
 16153  				}
 16154  			}
 16155  		case "AuthToken":
 16156  			if r.TryDecodeAsNil() {
 16157  				x.AuthToken = ""
 16158  			} else {
 16159  				yyv14 := &x.AuthToken
 16160  				yym15 := z.DecBinary()
 16161  				_ = yym15
 16162  				if false {
 16163  				} else {
 16164  					*((*string)(yyv14)) = r.DecodeString()
 16165  				}
 16166  			}
 16167  		case "Forwarded":
 16168  			if r.TryDecodeAsNil() {
 16169  				x.Forwarded = false
 16170  			} else {
 16171  				yyv16 := &x.Forwarded
 16172  				yym17 := z.DecBinary()
 16173  				_ = yym17
 16174  				if false {
 16175  				} else {
 16176  					*((*bool)(yyv16)) = r.DecodeBool()
 16177  				}
 16178  			}
 16179  		default:
 16180  			z.DecStructFieldNotFound(-1, yys3)
 16181  		} // end switch yys3
 16182  	} // end for yyj3
 16183  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 16184  }
 16185  
 16186  func (x *EvalDequeueRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 16187  	var h codecSelfer100
 16188  	z, r := codec1978.GenHelperDecoder(d)
 16189  	_, _, _ = h, z, r
 16190  	var yyj18 int
 16191  	var yyb18 bool
 16192  	var yyhl18 bool = l >= 0
 16193  	yyj18++
 16194  	if yyhl18 {
 16195  		yyb18 = yyj18 > l
 16196  	} else {
 16197  		yyb18 = r.CheckBreak()
 16198  	}
 16199  	if yyb18 {
 16200  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16201  		return
 16202  	}
 16203  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16204  	if r.TryDecodeAsNil() {
 16205  		x.Schedulers = nil
 16206  	} else {
 16207  		yyv19 := &x.Schedulers
 16208  		yym20 := z.DecBinary()
 16209  		_ = yym20
 16210  		if false {
 16211  		} else {
 16212  			z.F.DecSliceStringX(yyv19, false, d)
 16213  		}
 16214  	}
 16215  	yyj18++
 16216  	if yyhl18 {
 16217  		yyb18 = yyj18 > l
 16218  	} else {
 16219  		yyb18 = r.CheckBreak()
 16220  	}
 16221  	if yyb18 {
 16222  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16223  		return
 16224  	}
 16225  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16226  	if r.TryDecodeAsNil() {
 16227  		x.Timeout = 0
 16228  	} else {
 16229  		yyv21 := &x.Timeout
 16230  		yym22 := z.DecBinary()
 16231  		_ = yym22
 16232  		if false {
 16233  		} else if z.HasExtensions() && z.DecExt(yyv21) {
 16234  		} else {
 16235  			*((*int64)(yyv21)) = int64(r.DecodeInt(64))
 16236  		}
 16237  	}
 16238  	yyj18++
 16239  	if yyhl18 {
 16240  		yyb18 = yyj18 > l
 16241  	} else {
 16242  		yyb18 = r.CheckBreak()
 16243  	}
 16244  	if yyb18 {
 16245  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16246  		return
 16247  	}
 16248  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16249  	if r.TryDecodeAsNil() {
 16250  		x.SchedulerVersion = 0
 16251  	} else {
 16252  		yyv23 := &x.SchedulerVersion
 16253  		yym24 := z.DecBinary()
 16254  		_ = yym24
 16255  		if false {
 16256  		} else {
 16257  			*((*uint16)(yyv23)) = uint16(r.DecodeUint(16))
 16258  		}
 16259  	}
 16260  	yyj18++
 16261  	if yyhl18 {
 16262  		yyb18 = yyj18 > l
 16263  	} else {
 16264  		yyb18 = r.CheckBreak()
 16265  	}
 16266  	if yyb18 {
 16267  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16268  		return
 16269  	}
 16270  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16271  	if r.TryDecodeAsNil() {
 16272  		x.Region = ""
 16273  	} else {
 16274  		yyv25 := &x.Region
 16275  		yym26 := z.DecBinary()
 16276  		_ = yym26
 16277  		if false {
 16278  		} else {
 16279  			*((*string)(yyv25)) = r.DecodeString()
 16280  		}
 16281  	}
 16282  	yyj18++
 16283  	if yyhl18 {
 16284  		yyb18 = yyj18 > l
 16285  	} else {
 16286  		yyb18 = r.CheckBreak()
 16287  	}
 16288  	if yyb18 {
 16289  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16290  		return
 16291  	}
 16292  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16293  	if r.TryDecodeAsNil() {
 16294  		x.Namespace = ""
 16295  	} else {
 16296  		yyv27 := &x.Namespace
 16297  		yym28 := z.DecBinary()
 16298  		_ = yym28
 16299  		if false {
 16300  		} else {
 16301  			*((*string)(yyv27)) = r.DecodeString()
 16302  		}
 16303  	}
 16304  	yyj18++
 16305  	if yyhl18 {
 16306  		yyb18 = yyj18 > l
 16307  	} else {
 16308  		yyb18 = r.CheckBreak()
 16309  	}
 16310  	if yyb18 {
 16311  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16312  		return
 16313  	}
 16314  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16315  	if r.TryDecodeAsNil() {
 16316  		x.AuthToken = ""
 16317  	} else {
 16318  		yyv29 := &x.AuthToken
 16319  		yym30 := z.DecBinary()
 16320  		_ = yym30
 16321  		if false {
 16322  		} else {
 16323  			*((*string)(yyv29)) = r.DecodeString()
 16324  		}
 16325  	}
 16326  	yyj18++
 16327  	if yyhl18 {
 16328  		yyb18 = yyj18 > l
 16329  	} else {
 16330  		yyb18 = r.CheckBreak()
 16331  	}
 16332  	if yyb18 {
 16333  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16334  		return
 16335  	}
 16336  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16337  	if r.TryDecodeAsNil() {
 16338  		x.Forwarded = false
 16339  	} else {
 16340  		yyv31 := &x.Forwarded
 16341  		yym32 := z.DecBinary()
 16342  		_ = yym32
 16343  		if false {
 16344  		} else {
 16345  			*((*bool)(yyv31)) = r.DecodeBool()
 16346  		}
 16347  	}
 16348  	for {
 16349  		yyj18++
 16350  		if yyhl18 {
 16351  			yyb18 = yyj18 > l
 16352  		} else {
 16353  			yyb18 = r.CheckBreak()
 16354  		}
 16355  		if yyb18 {
 16356  			break
 16357  		}
 16358  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16359  		z.DecStructFieldNotFound(yyj18-1, "")
 16360  	}
 16361  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16362  }
 16363  
 16364  func (x *EvalListRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 16365  	var h codecSelfer100
 16366  	z, r := codec1978.GenHelperEncoder(e)
 16367  	_, _, _ = h, z, r
 16368  	if x == nil {
 16369  		r.EncodeNil()
 16370  	} else {
 16371  		yym1 := z.EncBinary()
 16372  		_ = yym1
 16373  		if false {
 16374  		} else if z.HasExtensions() && z.EncExt(x) {
 16375  		} else {
 16376  			yysep2 := !z.EncBinary()
 16377  			yy2arr2 := z.EncBasicHandle().StructToArray
 16378  			var yyq2 [8]bool
 16379  			_, _, _ = yysep2, yyq2, yy2arr2
 16380  			const yyr2 bool = false
 16381  			var yynn2 int
 16382  			if yyr2 || yy2arr2 {
 16383  				r.EncodeArrayStart(8)
 16384  			} else {
 16385  				yynn2 = 8
 16386  				for _, b := range yyq2 {
 16387  					if b {
 16388  						yynn2++
 16389  					}
 16390  				}
 16391  				r.EncodeMapStart(yynn2)
 16392  				yynn2 = 0
 16393  			}
 16394  			if yyr2 || yy2arr2 {
 16395  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 16396  				yym4 := z.EncBinary()
 16397  				_ = yym4
 16398  				if false {
 16399  				} else {
 16400  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 16401  				}
 16402  			} else {
 16403  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 16404  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 16405  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 16406  				yym5 := z.EncBinary()
 16407  				_ = yym5
 16408  				if false {
 16409  				} else {
 16410  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 16411  				}
 16412  			}
 16413  			if yyr2 || yy2arr2 {
 16414  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 16415  				yym7 := z.EncBinary()
 16416  				_ = yym7
 16417  				if false {
 16418  				} else {
 16419  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 16420  				}
 16421  			} else {
 16422  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 16423  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 16424  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 16425  				yym8 := z.EncBinary()
 16426  				_ = yym8
 16427  				if false {
 16428  				} else {
 16429  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 16430  				}
 16431  			}
 16432  			if yyr2 || yy2arr2 {
 16433  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 16434  				yym10 := z.EncBinary()
 16435  				_ = yym10
 16436  				if false {
 16437  				} else {
 16438  					r.EncodeUint(uint64(x.MinQueryIndex))
 16439  				}
 16440  			} else {
 16441  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 16442  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 16443  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 16444  				yym11 := z.EncBinary()
 16445  				_ = yym11
 16446  				if false {
 16447  				} else {
 16448  					r.EncodeUint(uint64(x.MinQueryIndex))
 16449  				}
 16450  			}
 16451  			if yyr2 || yy2arr2 {
 16452  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 16453  				yym13 := z.EncBinary()
 16454  				_ = yym13
 16455  				if false {
 16456  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 16457  				} else {
 16458  					r.EncodeInt(int64(x.MaxQueryTime))
 16459  				}
 16460  			} else {
 16461  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 16462  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 16463  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 16464  				yym14 := z.EncBinary()
 16465  				_ = yym14
 16466  				if false {
 16467  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 16468  				} else {
 16469  					r.EncodeInt(int64(x.MaxQueryTime))
 16470  				}
 16471  			}
 16472  			if yyr2 || yy2arr2 {
 16473  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 16474  				yym16 := z.EncBinary()
 16475  				_ = yym16
 16476  				if false {
 16477  				} else {
 16478  					r.EncodeBool(bool(x.AllowStale))
 16479  				}
 16480  			} else {
 16481  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 16482  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 16483  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 16484  				yym17 := z.EncBinary()
 16485  				_ = yym17
 16486  				if false {
 16487  				} else {
 16488  					r.EncodeBool(bool(x.AllowStale))
 16489  				}
 16490  			}
 16491  			if yyr2 || yy2arr2 {
 16492  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 16493  				yym19 := z.EncBinary()
 16494  				_ = yym19
 16495  				if false {
 16496  				} else {
 16497  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 16498  				}
 16499  			} else {
 16500  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 16501  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 16502  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 16503  				yym20 := z.EncBinary()
 16504  				_ = yym20
 16505  				if false {
 16506  				} else {
 16507  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 16508  				}
 16509  			}
 16510  			if yyr2 || yy2arr2 {
 16511  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 16512  				yym22 := z.EncBinary()
 16513  				_ = yym22
 16514  				if false {
 16515  				} else {
 16516  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 16517  				}
 16518  			} else {
 16519  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 16520  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 16521  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 16522  				yym23 := z.EncBinary()
 16523  				_ = yym23
 16524  				if false {
 16525  				} else {
 16526  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 16527  				}
 16528  			}
 16529  			if yyr2 || yy2arr2 {
 16530  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 16531  				yym25 := z.EncBinary()
 16532  				_ = yym25
 16533  				if false {
 16534  				} else {
 16535  					r.EncodeBool(bool(x.Forwarded))
 16536  				}
 16537  			} else {
 16538  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 16539  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 16540  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 16541  				yym26 := z.EncBinary()
 16542  				_ = yym26
 16543  				if false {
 16544  				} else {
 16545  					r.EncodeBool(bool(x.Forwarded))
 16546  				}
 16547  			}
 16548  			if yyr2 || yy2arr2 {
 16549  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 16550  			} else {
 16551  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 16552  			}
 16553  		}
 16554  	}
 16555  }
 16556  
 16557  func (x *EvalListRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 16558  	var h codecSelfer100
 16559  	z, r := codec1978.GenHelperDecoder(d)
 16560  	_, _, _ = h, z, r
 16561  	yym1 := z.DecBinary()
 16562  	_ = yym1
 16563  	if false {
 16564  	} else if z.HasExtensions() && z.DecExt(x) {
 16565  	} else {
 16566  		yyct2 := r.ContainerType()
 16567  		if yyct2 == codecSelferValueTypeMap100 {
 16568  			yyl2 := r.ReadMapStart()
 16569  			if yyl2 == 0 {
 16570  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 16571  			} else {
 16572  				x.codecDecodeSelfFromMap(yyl2, d)
 16573  			}
 16574  		} else if yyct2 == codecSelferValueTypeArray100 {
 16575  			yyl2 := r.ReadArrayStart()
 16576  			if yyl2 == 0 {
 16577  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16578  			} else {
 16579  				x.codecDecodeSelfFromArray(yyl2, d)
 16580  			}
 16581  		} else {
 16582  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 16583  		}
 16584  	}
 16585  }
 16586  
 16587  func (x *EvalListRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 16588  	var h codecSelfer100
 16589  	z, r := codec1978.GenHelperDecoder(d)
 16590  	_, _, _ = h, z, r
 16591  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 16592  	_ = yys3Slc
 16593  	var yyhl3 bool = l >= 0
 16594  	for yyj3 := 0; ; yyj3++ {
 16595  		if yyhl3 {
 16596  			if yyj3 >= l {
 16597  				break
 16598  			}
 16599  		} else {
 16600  			if r.CheckBreak() {
 16601  				break
 16602  			}
 16603  		}
 16604  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 16605  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 16606  		yys3 := string(yys3Slc)
 16607  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 16608  		switch yys3 {
 16609  		case "Region":
 16610  			if r.TryDecodeAsNil() {
 16611  				x.Region = ""
 16612  			} else {
 16613  				yyv4 := &x.Region
 16614  				yym5 := z.DecBinary()
 16615  				_ = yym5
 16616  				if false {
 16617  				} else {
 16618  					*((*string)(yyv4)) = r.DecodeString()
 16619  				}
 16620  			}
 16621  		case "Namespace":
 16622  			if r.TryDecodeAsNil() {
 16623  				x.Namespace = ""
 16624  			} else {
 16625  				yyv6 := &x.Namespace
 16626  				yym7 := z.DecBinary()
 16627  				_ = yym7
 16628  				if false {
 16629  				} else {
 16630  					*((*string)(yyv6)) = r.DecodeString()
 16631  				}
 16632  			}
 16633  		case "MinQueryIndex":
 16634  			if r.TryDecodeAsNil() {
 16635  				x.MinQueryIndex = 0
 16636  			} else {
 16637  				yyv8 := &x.MinQueryIndex
 16638  				yym9 := z.DecBinary()
 16639  				_ = yym9
 16640  				if false {
 16641  				} else {
 16642  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 16643  				}
 16644  			}
 16645  		case "MaxQueryTime":
 16646  			if r.TryDecodeAsNil() {
 16647  				x.MaxQueryTime = 0
 16648  			} else {
 16649  				yyv10 := &x.MaxQueryTime
 16650  				yym11 := z.DecBinary()
 16651  				_ = yym11
 16652  				if false {
 16653  				} else if z.HasExtensions() && z.DecExt(yyv10) {
 16654  				} else {
 16655  					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
 16656  				}
 16657  			}
 16658  		case "AllowStale":
 16659  			if r.TryDecodeAsNil() {
 16660  				x.AllowStale = false
 16661  			} else {
 16662  				yyv12 := &x.AllowStale
 16663  				yym13 := z.DecBinary()
 16664  				_ = yym13
 16665  				if false {
 16666  				} else {
 16667  					*((*bool)(yyv12)) = r.DecodeBool()
 16668  				}
 16669  			}
 16670  		case "Prefix":
 16671  			if r.TryDecodeAsNil() {
 16672  				x.Prefix = ""
 16673  			} else {
 16674  				yyv14 := &x.Prefix
 16675  				yym15 := z.DecBinary()
 16676  				_ = yym15
 16677  				if false {
 16678  				} else {
 16679  					*((*string)(yyv14)) = r.DecodeString()
 16680  				}
 16681  			}
 16682  		case "AuthToken":
 16683  			if r.TryDecodeAsNil() {
 16684  				x.AuthToken = ""
 16685  			} else {
 16686  				yyv16 := &x.AuthToken
 16687  				yym17 := z.DecBinary()
 16688  				_ = yym17
 16689  				if false {
 16690  				} else {
 16691  					*((*string)(yyv16)) = r.DecodeString()
 16692  				}
 16693  			}
 16694  		case "Forwarded":
 16695  			if r.TryDecodeAsNil() {
 16696  				x.Forwarded = false
 16697  			} else {
 16698  				yyv18 := &x.Forwarded
 16699  				yym19 := z.DecBinary()
 16700  				_ = yym19
 16701  				if false {
 16702  				} else {
 16703  					*((*bool)(yyv18)) = r.DecodeBool()
 16704  				}
 16705  			}
 16706  		default:
 16707  			z.DecStructFieldNotFound(-1, yys3)
 16708  		} // end switch yys3
 16709  	} // end for yyj3
 16710  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 16711  }
 16712  
 16713  func (x *EvalListRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 16714  	var h codecSelfer100
 16715  	z, r := codec1978.GenHelperDecoder(d)
 16716  	_, _, _ = h, z, r
 16717  	var yyj20 int
 16718  	var yyb20 bool
 16719  	var yyhl20 bool = l >= 0
 16720  	yyj20++
 16721  	if yyhl20 {
 16722  		yyb20 = yyj20 > l
 16723  	} else {
 16724  		yyb20 = r.CheckBreak()
 16725  	}
 16726  	if yyb20 {
 16727  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16728  		return
 16729  	}
 16730  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16731  	if r.TryDecodeAsNil() {
 16732  		x.Region = ""
 16733  	} else {
 16734  		yyv21 := &x.Region
 16735  		yym22 := z.DecBinary()
 16736  		_ = yym22
 16737  		if false {
 16738  		} else {
 16739  			*((*string)(yyv21)) = r.DecodeString()
 16740  		}
 16741  	}
 16742  	yyj20++
 16743  	if yyhl20 {
 16744  		yyb20 = yyj20 > l
 16745  	} else {
 16746  		yyb20 = r.CheckBreak()
 16747  	}
 16748  	if yyb20 {
 16749  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16750  		return
 16751  	}
 16752  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16753  	if r.TryDecodeAsNil() {
 16754  		x.Namespace = ""
 16755  	} else {
 16756  		yyv23 := &x.Namespace
 16757  		yym24 := z.DecBinary()
 16758  		_ = yym24
 16759  		if false {
 16760  		} else {
 16761  			*((*string)(yyv23)) = r.DecodeString()
 16762  		}
 16763  	}
 16764  	yyj20++
 16765  	if yyhl20 {
 16766  		yyb20 = yyj20 > l
 16767  	} else {
 16768  		yyb20 = r.CheckBreak()
 16769  	}
 16770  	if yyb20 {
 16771  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16772  		return
 16773  	}
 16774  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16775  	if r.TryDecodeAsNil() {
 16776  		x.MinQueryIndex = 0
 16777  	} else {
 16778  		yyv25 := &x.MinQueryIndex
 16779  		yym26 := z.DecBinary()
 16780  		_ = yym26
 16781  		if false {
 16782  		} else {
 16783  			*((*uint64)(yyv25)) = uint64(r.DecodeUint(64))
 16784  		}
 16785  	}
 16786  	yyj20++
 16787  	if yyhl20 {
 16788  		yyb20 = yyj20 > l
 16789  	} else {
 16790  		yyb20 = r.CheckBreak()
 16791  	}
 16792  	if yyb20 {
 16793  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16794  		return
 16795  	}
 16796  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16797  	if r.TryDecodeAsNil() {
 16798  		x.MaxQueryTime = 0
 16799  	} else {
 16800  		yyv27 := &x.MaxQueryTime
 16801  		yym28 := z.DecBinary()
 16802  		_ = yym28
 16803  		if false {
 16804  		} else if z.HasExtensions() && z.DecExt(yyv27) {
 16805  		} else {
 16806  			*((*int64)(yyv27)) = int64(r.DecodeInt(64))
 16807  		}
 16808  	}
 16809  	yyj20++
 16810  	if yyhl20 {
 16811  		yyb20 = yyj20 > l
 16812  	} else {
 16813  		yyb20 = r.CheckBreak()
 16814  	}
 16815  	if yyb20 {
 16816  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16817  		return
 16818  	}
 16819  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16820  	if r.TryDecodeAsNil() {
 16821  		x.AllowStale = false
 16822  	} else {
 16823  		yyv29 := &x.AllowStale
 16824  		yym30 := z.DecBinary()
 16825  		_ = yym30
 16826  		if false {
 16827  		} else {
 16828  			*((*bool)(yyv29)) = r.DecodeBool()
 16829  		}
 16830  	}
 16831  	yyj20++
 16832  	if yyhl20 {
 16833  		yyb20 = yyj20 > l
 16834  	} else {
 16835  		yyb20 = r.CheckBreak()
 16836  	}
 16837  	if yyb20 {
 16838  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16839  		return
 16840  	}
 16841  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16842  	if r.TryDecodeAsNil() {
 16843  		x.Prefix = ""
 16844  	} else {
 16845  		yyv31 := &x.Prefix
 16846  		yym32 := z.DecBinary()
 16847  		_ = yym32
 16848  		if false {
 16849  		} else {
 16850  			*((*string)(yyv31)) = r.DecodeString()
 16851  		}
 16852  	}
 16853  	yyj20++
 16854  	if yyhl20 {
 16855  		yyb20 = yyj20 > l
 16856  	} else {
 16857  		yyb20 = r.CheckBreak()
 16858  	}
 16859  	if yyb20 {
 16860  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16861  		return
 16862  	}
 16863  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16864  	if r.TryDecodeAsNil() {
 16865  		x.AuthToken = ""
 16866  	} else {
 16867  		yyv33 := &x.AuthToken
 16868  		yym34 := z.DecBinary()
 16869  		_ = yym34
 16870  		if false {
 16871  		} else {
 16872  			*((*string)(yyv33)) = r.DecodeString()
 16873  		}
 16874  	}
 16875  	yyj20++
 16876  	if yyhl20 {
 16877  		yyb20 = yyj20 > l
 16878  	} else {
 16879  		yyb20 = r.CheckBreak()
 16880  	}
 16881  	if yyb20 {
 16882  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16883  		return
 16884  	}
 16885  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16886  	if r.TryDecodeAsNil() {
 16887  		x.Forwarded = false
 16888  	} else {
 16889  		yyv35 := &x.Forwarded
 16890  		yym36 := z.DecBinary()
 16891  		_ = yym36
 16892  		if false {
 16893  		} else {
 16894  			*((*bool)(yyv35)) = r.DecodeBool()
 16895  		}
 16896  	}
 16897  	for {
 16898  		yyj20++
 16899  		if yyhl20 {
 16900  			yyb20 = yyj20 > l
 16901  		} else {
 16902  			yyb20 = r.CheckBreak()
 16903  		}
 16904  		if yyb20 {
 16905  			break
 16906  		}
 16907  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 16908  		z.DecStructFieldNotFound(yyj20-1, "")
 16909  	}
 16910  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 16911  }
 16912  
 16913  func (x *PlanRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 16914  	var h codecSelfer100
 16915  	z, r := codec1978.GenHelperEncoder(e)
 16916  	_, _, _ = h, z, r
 16917  	if x == nil {
 16918  		r.EncodeNil()
 16919  	} else {
 16920  		yym1 := z.EncBinary()
 16921  		_ = yym1
 16922  		if false {
 16923  		} else if z.HasExtensions() && z.EncExt(x) {
 16924  		} else {
 16925  			yysep2 := !z.EncBinary()
 16926  			yy2arr2 := z.EncBasicHandle().StructToArray
 16927  			var yyq2 [5]bool
 16928  			_, _, _ = yysep2, yyq2, yy2arr2
 16929  			const yyr2 bool = false
 16930  			var yynn2 int
 16931  			if yyr2 || yy2arr2 {
 16932  				r.EncodeArrayStart(5)
 16933  			} else {
 16934  				yynn2 = 5
 16935  				for _, b := range yyq2 {
 16936  					if b {
 16937  						yynn2++
 16938  					}
 16939  				}
 16940  				r.EncodeMapStart(yynn2)
 16941  				yynn2 = 0
 16942  			}
 16943  			if yyr2 || yy2arr2 {
 16944  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 16945  				if x.Plan == nil {
 16946  					r.EncodeNil()
 16947  				} else {
 16948  					x.Plan.CodecEncodeSelf(e)
 16949  				}
 16950  			} else {
 16951  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 16952  				r.EncodeString(codecSelferC_UTF8100, string("Plan"))
 16953  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 16954  				if x.Plan == nil {
 16955  					r.EncodeNil()
 16956  				} else {
 16957  					x.Plan.CodecEncodeSelf(e)
 16958  				}
 16959  			}
 16960  			if yyr2 || yy2arr2 {
 16961  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 16962  				yym7 := z.EncBinary()
 16963  				_ = yym7
 16964  				if false {
 16965  				} else {
 16966  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 16967  				}
 16968  			} else {
 16969  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 16970  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 16971  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 16972  				yym8 := z.EncBinary()
 16973  				_ = yym8
 16974  				if false {
 16975  				} else {
 16976  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 16977  				}
 16978  			}
 16979  			if yyr2 || yy2arr2 {
 16980  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 16981  				yym10 := z.EncBinary()
 16982  				_ = yym10
 16983  				if false {
 16984  				} else {
 16985  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 16986  				}
 16987  			} else {
 16988  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 16989  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 16990  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 16991  				yym11 := z.EncBinary()
 16992  				_ = yym11
 16993  				if false {
 16994  				} else {
 16995  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 16996  				}
 16997  			}
 16998  			if yyr2 || yy2arr2 {
 16999  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 17000  				yym13 := z.EncBinary()
 17001  				_ = yym13
 17002  				if false {
 17003  				} else {
 17004  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 17005  				}
 17006  			} else {
 17007  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 17008  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 17009  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 17010  				yym14 := z.EncBinary()
 17011  				_ = yym14
 17012  				if false {
 17013  				} else {
 17014  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 17015  				}
 17016  			}
 17017  			if yyr2 || yy2arr2 {
 17018  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 17019  				yym16 := z.EncBinary()
 17020  				_ = yym16
 17021  				if false {
 17022  				} else {
 17023  					r.EncodeBool(bool(x.Forwarded))
 17024  				}
 17025  			} else {
 17026  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 17027  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 17028  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 17029  				yym17 := z.EncBinary()
 17030  				_ = yym17
 17031  				if false {
 17032  				} else {
 17033  					r.EncodeBool(bool(x.Forwarded))
 17034  				}
 17035  			}
 17036  			if yyr2 || yy2arr2 {
 17037  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 17038  			} else {
 17039  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 17040  			}
 17041  		}
 17042  	}
 17043  }
 17044  
 17045  func (x *PlanRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 17046  	var h codecSelfer100
 17047  	z, r := codec1978.GenHelperDecoder(d)
 17048  	_, _, _ = h, z, r
 17049  	yym1 := z.DecBinary()
 17050  	_ = yym1
 17051  	if false {
 17052  	} else if z.HasExtensions() && z.DecExt(x) {
 17053  	} else {
 17054  		yyct2 := r.ContainerType()
 17055  		if yyct2 == codecSelferValueTypeMap100 {
 17056  			yyl2 := r.ReadMapStart()
 17057  			if yyl2 == 0 {
 17058  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 17059  			} else {
 17060  				x.codecDecodeSelfFromMap(yyl2, d)
 17061  			}
 17062  		} else if yyct2 == codecSelferValueTypeArray100 {
 17063  			yyl2 := r.ReadArrayStart()
 17064  			if yyl2 == 0 {
 17065  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17066  			} else {
 17067  				x.codecDecodeSelfFromArray(yyl2, d)
 17068  			}
 17069  		} else {
 17070  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 17071  		}
 17072  	}
 17073  }
 17074  
 17075  func (x *PlanRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 17076  	var h codecSelfer100
 17077  	z, r := codec1978.GenHelperDecoder(d)
 17078  	_, _, _ = h, z, r
 17079  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 17080  	_ = yys3Slc
 17081  	var yyhl3 bool = l >= 0
 17082  	for yyj3 := 0; ; yyj3++ {
 17083  		if yyhl3 {
 17084  			if yyj3 >= l {
 17085  				break
 17086  			}
 17087  		} else {
 17088  			if r.CheckBreak() {
 17089  				break
 17090  			}
 17091  		}
 17092  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 17093  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 17094  		yys3 := string(yys3Slc)
 17095  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 17096  		switch yys3 {
 17097  		case "Plan":
 17098  			if r.TryDecodeAsNil() {
 17099  				if x.Plan != nil {
 17100  					x.Plan = nil
 17101  				}
 17102  			} else {
 17103  				if x.Plan == nil {
 17104  					x.Plan = new(Plan)
 17105  				}
 17106  				x.Plan.CodecDecodeSelf(d)
 17107  			}
 17108  		case "Region":
 17109  			if r.TryDecodeAsNil() {
 17110  				x.Region = ""
 17111  			} else {
 17112  				yyv5 := &x.Region
 17113  				yym6 := z.DecBinary()
 17114  				_ = yym6
 17115  				if false {
 17116  				} else {
 17117  					*((*string)(yyv5)) = r.DecodeString()
 17118  				}
 17119  			}
 17120  		case "Namespace":
 17121  			if r.TryDecodeAsNil() {
 17122  				x.Namespace = ""
 17123  			} else {
 17124  				yyv7 := &x.Namespace
 17125  				yym8 := z.DecBinary()
 17126  				_ = yym8
 17127  				if false {
 17128  				} else {
 17129  					*((*string)(yyv7)) = r.DecodeString()
 17130  				}
 17131  			}
 17132  		case "AuthToken":
 17133  			if r.TryDecodeAsNil() {
 17134  				x.AuthToken = ""
 17135  			} else {
 17136  				yyv9 := &x.AuthToken
 17137  				yym10 := z.DecBinary()
 17138  				_ = yym10
 17139  				if false {
 17140  				} else {
 17141  					*((*string)(yyv9)) = r.DecodeString()
 17142  				}
 17143  			}
 17144  		case "Forwarded":
 17145  			if r.TryDecodeAsNil() {
 17146  				x.Forwarded = false
 17147  			} else {
 17148  				yyv11 := &x.Forwarded
 17149  				yym12 := z.DecBinary()
 17150  				_ = yym12
 17151  				if false {
 17152  				} else {
 17153  					*((*bool)(yyv11)) = r.DecodeBool()
 17154  				}
 17155  			}
 17156  		default:
 17157  			z.DecStructFieldNotFound(-1, yys3)
 17158  		} // end switch yys3
 17159  	} // end for yyj3
 17160  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 17161  }
 17162  
 17163  func (x *PlanRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 17164  	var h codecSelfer100
 17165  	z, r := codec1978.GenHelperDecoder(d)
 17166  	_, _, _ = h, z, r
 17167  	var yyj13 int
 17168  	var yyb13 bool
 17169  	var yyhl13 bool = l >= 0
 17170  	yyj13++
 17171  	if yyhl13 {
 17172  		yyb13 = yyj13 > l
 17173  	} else {
 17174  		yyb13 = r.CheckBreak()
 17175  	}
 17176  	if yyb13 {
 17177  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17178  		return
 17179  	}
 17180  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17181  	if r.TryDecodeAsNil() {
 17182  		if x.Plan != nil {
 17183  			x.Plan = nil
 17184  		}
 17185  	} else {
 17186  		if x.Plan == nil {
 17187  			x.Plan = new(Plan)
 17188  		}
 17189  		x.Plan.CodecDecodeSelf(d)
 17190  	}
 17191  	yyj13++
 17192  	if yyhl13 {
 17193  		yyb13 = yyj13 > l
 17194  	} else {
 17195  		yyb13 = r.CheckBreak()
 17196  	}
 17197  	if yyb13 {
 17198  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17199  		return
 17200  	}
 17201  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17202  	if r.TryDecodeAsNil() {
 17203  		x.Region = ""
 17204  	} else {
 17205  		yyv15 := &x.Region
 17206  		yym16 := z.DecBinary()
 17207  		_ = yym16
 17208  		if false {
 17209  		} else {
 17210  			*((*string)(yyv15)) = r.DecodeString()
 17211  		}
 17212  	}
 17213  	yyj13++
 17214  	if yyhl13 {
 17215  		yyb13 = yyj13 > l
 17216  	} else {
 17217  		yyb13 = r.CheckBreak()
 17218  	}
 17219  	if yyb13 {
 17220  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17221  		return
 17222  	}
 17223  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17224  	if r.TryDecodeAsNil() {
 17225  		x.Namespace = ""
 17226  	} else {
 17227  		yyv17 := &x.Namespace
 17228  		yym18 := z.DecBinary()
 17229  		_ = yym18
 17230  		if false {
 17231  		} else {
 17232  			*((*string)(yyv17)) = r.DecodeString()
 17233  		}
 17234  	}
 17235  	yyj13++
 17236  	if yyhl13 {
 17237  		yyb13 = yyj13 > l
 17238  	} else {
 17239  		yyb13 = r.CheckBreak()
 17240  	}
 17241  	if yyb13 {
 17242  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17243  		return
 17244  	}
 17245  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17246  	if r.TryDecodeAsNil() {
 17247  		x.AuthToken = ""
 17248  	} else {
 17249  		yyv19 := &x.AuthToken
 17250  		yym20 := z.DecBinary()
 17251  		_ = yym20
 17252  		if false {
 17253  		} else {
 17254  			*((*string)(yyv19)) = r.DecodeString()
 17255  		}
 17256  	}
 17257  	yyj13++
 17258  	if yyhl13 {
 17259  		yyb13 = yyj13 > l
 17260  	} else {
 17261  		yyb13 = r.CheckBreak()
 17262  	}
 17263  	if yyb13 {
 17264  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17265  		return
 17266  	}
 17267  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17268  	if r.TryDecodeAsNil() {
 17269  		x.Forwarded = false
 17270  	} else {
 17271  		yyv21 := &x.Forwarded
 17272  		yym22 := z.DecBinary()
 17273  		_ = yym22
 17274  		if false {
 17275  		} else {
 17276  			*((*bool)(yyv21)) = r.DecodeBool()
 17277  		}
 17278  	}
 17279  	for {
 17280  		yyj13++
 17281  		if yyhl13 {
 17282  			yyb13 = yyj13 > l
 17283  		} else {
 17284  			yyb13 = r.CheckBreak()
 17285  		}
 17286  		if yyb13 {
 17287  			break
 17288  		}
 17289  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17290  		z.DecStructFieldNotFound(yyj13-1, "")
 17291  	}
 17292  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17293  }
 17294  
 17295  func (x *ApplyPlanResultsRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 17296  	var h codecSelfer100
 17297  	z, r := codec1978.GenHelperEncoder(e)
 17298  	_, _, _ = h, z, r
 17299  	if x == nil {
 17300  		r.EncodeNil()
 17301  	} else {
 17302  		yym1 := z.EncBinary()
 17303  		_ = yym1
 17304  		if false {
 17305  		} else if z.HasExtensions() && z.EncExt(x) {
 17306  		} else {
 17307  			yysep2 := !z.EncBinary()
 17308  			yy2arr2 := z.EncBasicHandle().StructToArray
 17309  			var yyq2 [10]bool
 17310  			_, _, _ = yysep2, yyq2, yy2arr2
 17311  			const yyr2 bool = false
 17312  			var yynn2 int
 17313  			if yyr2 || yy2arr2 {
 17314  				r.EncodeArrayStart(10)
 17315  			} else {
 17316  				yynn2 = 10
 17317  				for _, b := range yyq2 {
 17318  					if b {
 17319  						yynn2++
 17320  					}
 17321  				}
 17322  				r.EncodeMapStart(yynn2)
 17323  				yynn2 = 0
 17324  			}
 17325  			if yyr2 || yy2arr2 {
 17326  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 17327  				if x.Alloc == nil {
 17328  					r.EncodeNil()
 17329  				} else {
 17330  					yym4 := z.EncBinary()
 17331  					_ = yym4
 17332  					if false {
 17333  					} else {
 17334  						h.encSlicePtrtoAllocation(([]*Allocation)(x.Alloc), e)
 17335  					}
 17336  				}
 17337  			} else {
 17338  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 17339  				r.EncodeString(codecSelferC_UTF8100, string("Alloc"))
 17340  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 17341  				if x.Alloc == nil {
 17342  					r.EncodeNil()
 17343  				} else {
 17344  					yym5 := z.EncBinary()
 17345  					_ = yym5
 17346  					if false {
 17347  					} else {
 17348  						h.encSlicePtrtoAllocation(([]*Allocation)(x.Alloc), e)
 17349  					}
 17350  				}
 17351  			}
 17352  			if yyr2 || yy2arr2 {
 17353  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 17354  				if x.Evals == nil {
 17355  					r.EncodeNil()
 17356  				} else {
 17357  					yym7 := z.EncBinary()
 17358  					_ = yym7
 17359  					if false {
 17360  					} else {
 17361  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.Evals), e)
 17362  					}
 17363  				}
 17364  			} else {
 17365  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 17366  				r.EncodeString(codecSelferC_UTF8100, string("Evals"))
 17367  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 17368  				if x.Evals == nil {
 17369  					r.EncodeNil()
 17370  				} else {
 17371  					yym8 := z.EncBinary()
 17372  					_ = yym8
 17373  					if false {
 17374  					} else {
 17375  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.Evals), e)
 17376  					}
 17377  				}
 17378  			}
 17379  			var yyn9 bool
 17380  			if x.AllocUpdateRequest.Job == nil {
 17381  				yyn9 = true
 17382  				goto LABEL9
 17383  			}
 17384  		LABEL9:
 17385  			if yyr2 || yy2arr2 {
 17386  				if yyn9 {
 17387  					r.EncodeNil()
 17388  				} else {
 17389  					z.EncSendContainerState(codecSelfer_containerArrayElem100)
 17390  					if x.Job == nil {
 17391  						r.EncodeNil()
 17392  					} else {
 17393  						x.Job.CodecEncodeSelf(e)
 17394  					}
 17395  				}
 17396  			} else {
 17397  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 17398  				r.EncodeString(codecSelferC_UTF8100, string("Job"))
 17399  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 17400  				if yyn9 {
 17401  					r.EncodeNil()
 17402  				} else {
 17403  					if x.Job == nil {
 17404  						r.EncodeNil()
 17405  					} else {
 17406  						x.Job.CodecEncodeSelf(e)
 17407  					}
 17408  				}
 17409  			}
 17410  			if yyr2 || yy2arr2 {
 17411  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 17412  				yym13 := z.EncBinary()
 17413  				_ = yym13
 17414  				if false {
 17415  				} else {
 17416  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 17417  				}
 17418  			} else {
 17419  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 17420  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 17421  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 17422  				yym14 := z.EncBinary()
 17423  				_ = yym14
 17424  				if false {
 17425  				} else {
 17426  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 17427  				}
 17428  			}
 17429  			if yyr2 || yy2arr2 {
 17430  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 17431  				yym16 := z.EncBinary()
 17432  				_ = yym16
 17433  				if false {
 17434  				} else {
 17435  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 17436  				}
 17437  			} else {
 17438  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 17439  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 17440  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 17441  				yym17 := z.EncBinary()
 17442  				_ = yym17
 17443  				if false {
 17444  				} else {
 17445  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 17446  				}
 17447  			}
 17448  			if yyr2 || yy2arr2 {
 17449  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 17450  				yym19 := z.EncBinary()
 17451  				_ = yym19
 17452  				if false {
 17453  				} else {
 17454  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 17455  				}
 17456  			} else {
 17457  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 17458  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 17459  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 17460  				yym20 := z.EncBinary()
 17461  				_ = yym20
 17462  				if false {
 17463  				} else {
 17464  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 17465  				}
 17466  			}
 17467  			if yyr2 || yy2arr2 {
 17468  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 17469  				yym22 := z.EncBinary()
 17470  				_ = yym22
 17471  				if false {
 17472  				} else {
 17473  					r.EncodeBool(bool(x.Forwarded))
 17474  				}
 17475  			} else {
 17476  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 17477  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 17478  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 17479  				yym23 := z.EncBinary()
 17480  				_ = yym23
 17481  				if false {
 17482  				} else {
 17483  					r.EncodeBool(bool(x.Forwarded))
 17484  				}
 17485  			}
 17486  			if yyr2 || yy2arr2 {
 17487  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 17488  				if x.Deployment == nil {
 17489  					r.EncodeNil()
 17490  				} else {
 17491  					x.Deployment.CodecEncodeSelf(e)
 17492  				}
 17493  			} else {
 17494  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 17495  				r.EncodeString(codecSelferC_UTF8100, string("Deployment"))
 17496  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 17497  				if x.Deployment == nil {
 17498  					r.EncodeNil()
 17499  				} else {
 17500  					x.Deployment.CodecEncodeSelf(e)
 17501  				}
 17502  			}
 17503  			if yyr2 || yy2arr2 {
 17504  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 17505  				if x.DeploymentUpdates == nil {
 17506  					r.EncodeNil()
 17507  				} else {
 17508  					yym28 := z.EncBinary()
 17509  					_ = yym28
 17510  					if false {
 17511  					} else {
 17512  						h.encSlicePtrtoDeploymentStatusUpdate(([]*DeploymentStatusUpdate)(x.DeploymentUpdates), e)
 17513  					}
 17514  				}
 17515  			} else {
 17516  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 17517  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentUpdates"))
 17518  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 17519  				if x.DeploymentUpdates == nil {
 17520  					r.EncodeNil()
 17521  				} else {
 17522  					yym29 := z.EncBinary()
 17523  					_ = yym29
 17524  					if false {
 17525  					} else {
 17526  						h.encSlicePtrtoDeploymentStatusUpdate(([]*DeploymentStatusUpdate)(x.DeploymentUpdates), e)
 17527  					}
 17528  				}
 17529  			}
 17530  			if yyr2 || yy2arr2 {
 17531  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 17532  				yym31 := z.EncBinary()
 17533  				_ = yym31
 17534  				if false {
 17535  				} else {
 17536  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 17537  				}
 17538  			} else {
 17539  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 17540  				r.EncodeString(codecSelferC_UTF8100, string("EvalID"))
 17541  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 17542  				yym32 := z.EncBinary()
 17543  				_ = yym32
 17544  				if false {
 17545  				} else {
 17546  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 17547  				}
 17548  			}
 17549  			if yyr2 || yy2arr2 {
 17550  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 17551  			} else {
 17552  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 17553  			}
 17554  		}
 17555  	}
 17556  }
 17557  
 17558  func (x *ApplyPlanResultsRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 17559  	var h codecSelfer100
 17560  	z, r := codec1978.GenHelperDecoder(d)
 17561  	_, _, _ = h, z, r
 17562  	yym1 := z.DecBinary()
 17563  	_ = yym1
 17564  	if false {
 17565  	} else if z.HasExtensions() && z.DecExt(x) {
 17566  	} else {
 17567  		yyct2 := r.ContainerType()
 17568  		if yyct2 == codecSelferValueTypeMap100 {
 17569  			yyl2 := r.ReadMapStart()
 17570  			if yyl2 == 0 {
 17571  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 17572  			} else {
 17573  				x.codecDecodeSelfFromMap(yyl2, d)
 17574  			}
 17575  		} else if yyct2 == codecSelferValueTypeArray100 {
 17576  			yyl2 := r.ReadArrayStart()
 17577  			if yyl2 == 0 {
 17578  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17579  			} else {
 17580  				x.codecDecodeSelfFromArray(yyl2, d)
 17581  			}
 17582  		} else {
 17583  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 17584  		}
 17585  	}
 17586  }
 17587  
 17588  func (x *ApplyPlanResultsRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 17589  	var h codecSelfer100
 17590  	z, r := codec1978.GenHelperDecoder(d)
 17591  	_, _, _ = h, z, r
 17592  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 17593  	_ = yys3Slc
 17594  	var yyhl3 bool = l >= 0
 17595  	for yyj3 := 0; ; yyj3++ {
 17596  		if yyhl3 {
 17597  			if yyj3 >= l {
 17598  				break
 17599  			}
 17600  		} else {
 17601  			if r.CheckBreak() {
 17602  				break
 17603  			}
 17604  		}
 17605  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 17606  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 17607  		yys3 := string(yys3Slc)
 17608  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 17609  		switch yys3 {
 17610  		case "Alloc":
 17611  			if r.TryDecodeAsNil() {
 17612  				x.Alloc = nil
 17613  			} else {
 17614  				yyv4 := &x.Alloc
 17615  				yym5 := z.DecBinary()
 17616  				_ = yym5
 17617  				if false {
 17618  				} else {
 17619  					h.decSlicePtrtoAllocation((*[]*Allocation)(yyv4), d)
 17620  				}
 17621  			}
 17622  		case "Evals":
 17623  			if r.TryDecodeAsNil() {
 17624  				x.Evals = nil
 17625  			} else {
 17626  				yyv6 := &x.Evals
 17627  				yym7 := z.DecBinary()
 17628  				_ = yym7
 17629  				if false {
 17630  				} else {
 17631  					h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv6), d)
 17632  				}
 17633  			}
 17634  		case "Job":
 17635  			if x.AllocUpdateRequest.Job == nil {
 17636  				x.AllocUpdateRequest.Job = new(Job)
 17637  			}
 17638  			if r.TryDecodeAsNil() {
 17639  				if x.Job != nil {
 17640  					x.Job = nil
 17641  				}
 17642  			} else {
 17643  				if x.Job == nil {
 17644  					x.Job = new(Job)
 17645  				}
 17646  				x.Job.CodecDecodeSelf(d)
 17647  			}
 17648  		case "Region":
 17649  			if r.TryDecodeAsNil() {
 17650  				x.Region = ""
 17651  			} else {
 17652  				yyv9 := &x.Region
 17653  				yym10 := z.DecBinary()
 17654  				_ = yym10
 17655  				if false {
 17656  				} else {
 17657  					*((*string)(yyv9)) = r.DecodeString()
 17658  				}
 17659  			}
 17660  		case "Namespace":
 17661  			if r.TryDecodeAsNil() {
 17662  				x.Namespace = ""
 17663  			} else {
 17664  				yyv11 := &x.Namespace
 17665  				yym12 := z.DecBinary()
 17666  				_ = yym12
 17667  				if false {
 17668  				} else {
 17669  					*((*string)(yyv11)) = r.DecodeString()
 17670  				}
 17671  			}
 17672  		case "AuthToken":
 17673  			if r.TryDecodeAsNil() {
 17674  				x.AuthToken = ""
 17675  			} else {
 17676  				yyv13 := &x.AuthToken
 17677  				yym14 := z.DecBinary()
 17678  				_ = yym14
 17679  				if false {
 17680  				} else {
 17681  					*((*string)(yyv13)) = r.DecodeString()
 17682  				}
 17683  			}
 17684  		case "Forwarded":
 17685  			if r.TryDecodeAsNil() {
 17686  				x.Forwarded = false
 17687  			} else {
 17688  				yyv15 := &x.Forwarded
 17689  				yym16 := z.DecBinary()
 17690  				_ = yym16
 17691  				if false {
 17692  				} else {
 17693  					*((*bool)(yyv15)) = r.DecodeBool()
 17694  				}
 17695  			}
 17696  		case "Deployment":
 17697  			if r.TryDecodeAsNil() {
 17698  				if x.Deployment != nil {
 17699  					x.Deployment = nil
 17700  				}
 17701  			} else {
 17702  				if x.Deployment == nil {
 17703  					x.Deployment = new(Deployment)
 17704  				}
 17705  				x.Deployment.CodecDecodeSelf(d)
 17706  			}
 17707  		case "DeploymentUpdates":
 17708  			if r.TryDecodeAsNil() {
 17709  				x.DeploymentUpdates = nil
 17710  			} else {
 17711  				yyv18 := &x.DeploymentUpdates
 17712  				yym19 := z.DecBinary()
 17713  				_ = yym19
 17714  				if false {
 17715  				} else {
 17716  					h.decSlicePtrtoDeploymentStatusUpdate((*[]*DeploymentStatusUpdate)(yyv18), d)
 17717  				}
 17718  			}
 17719  		case "EvalID":
 17720  			if r.TryDecodeAsNil() {
 17721  				x.EvalID = ""
 17722  			} else {
 17723  				yyv20 := &x.EvalID
 17724  				yym21 := z.DecBinary()
 17725  				_ = yym21
 17726  				if false {
 17727  				} else {
 17728  					*((*string)(yyv20)) = r.DecodeString()
 17729  				}
 17730  			}
 17731  		default:
 17732  			z.DecStructFieldNotFound(-1, yys3)
 17733  		} // end switch yys3
 17734  	} // end for yyj3
 17735  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 17736  }
 17737  
 17738  func (x *ApplyPlanResultsRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 17739  	var h codecSelfer100
 17740  	z, r := codec1978.GenHelperDecoder(d)
 17741  	_, _, _ = h, z, r
 17742  	var yyj22 int
 17743  	var yyb22 bool
 17744  	var yyhl22 bool = l >= 0
 17745  	yyj22++
 17746  	if yyhl22 {
 17747  		yyb22 = yyj22 > l
 17748  	} else {
 17749  		yyb22 = r.CheckBreak()
 17750  	}
 17751  	if yyb22 {
 17752  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17753  		return
 17754  	}
 17755  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17756  	if r.TryDecodeAsNil() {
 17757  		x.Alloc = nil
 17758  	} else {
 17759  		yyv23 := &x.Alloc
 17760  		yym24 := z.DecBinary()
 17761  		_ = yym24
 17762  		if false {
 17763  		} else {
 17764  			h.decSlicePtrtoAllocation((*[]*Allocation)(yyv23), d)
 17765  		}
 17766  	}
 17767  	yyj22++
 17768  	if yyhl22 {
 17769  		yyb22 = yyj22 > l
 17770  	} else {
 17771  		yyb22 = r.CheckBreak()
 17772  	}
 17773  	if yyb22 {
 17774  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17775  		return
 17776  	}
 17777  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17778  	if r.TryDecodeAsNil() {
 17779  		x.Evals = nil
 17780  	} else {
 17781  		yyv25 := &x.Evals
 17782  		yym26 := z.DecBinary()
 17783  		_ = yym26
 17784  		if false {
 17785  		} else {
 17786  			h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv25), d)
 17787  		}
 17788  	}
 17789  	if x.AllocUpdateRequest.Job == nil {
 17790  		x.AllocUpdateRequest.Job = new(Job)
 17791  	}
 17792  	yyj22++
 17793  	if yyhl22 {
 17794  		yyb22 = yyj22 > l
 17795  	} else {
 17796  		yyb22 = r.CheckBreak()
 17797  	}
 17798  	if yyb22 {
 17799  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17800  		return
 17801  	}
 17802  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17803  	if r.TryDecodeAsNil() {
 17804  		if x.Job != nil {
 17805  			x.Job = nil
 17806  		}
 17807  	} else {
 17808  		if x.Job == nil {
 17809  			x.Job = new(Job)
 17810  		}
 17811  		x.Job.CodecDecodeSelf(d)
 17812  	}
 17813  	yyj22++
 17814  	if yyhl22 {
 17815  		yyb22 = yyj22 > l
 17816  	} else {
 17817  		yyb22 = r.CheckBreak()
 17818  	}
 17819  	if yyb22 {
 17820  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17821  		return
 17822  	}
 17823  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17824  	if r.TryDecodeAsNil() {
 17825  		x.Region = ""
 17826  	} else {
 17827  		yyv28 := &x.Region
 17828  		yym29 := z.DecBinary()
 17829  		_ = yym29
 17830  		if false {
 17831  		} else {
 17832  			*((*string)(yyv28)) = r.DecodeString()
 17833  		}
 17834  	}
 17835  	yyj22++
 17836  	if yyhl22 {
 17837  		yyb22 = yyj22 > l
 17838  	} else {
 17839  		yyb22 = r.CheckBreak()
 17840  	}
 17841  	if yyb22 {
 17842  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17843  		return
 17844  	}
 17845  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17846  	if r.TryDecodeAsNil() {
 17847  		x.Namespace = ""
 17848  	} else {
 17849  		yyv30 := &x.Namespace
 17850  		yym31 := z.DecBinary()
 17851  		_ = yym31
 17852  		if false {
 17853  		} else {
 17854  			*((*string)(yyv30)) = r.DecodeString()
 17855  		}
 17856  	}
 17857  	yyj22++
 17858  	if yyhl22 {
 17859  		yyb22 = yyj22 > l
 17860  	} else {
 17861  		yyb22 = r.CheckBreak()
 17862  	}
 17863  	if yyb22 {
 17864  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17865  		return
 17866  	}
 17867  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17868  	if r.TryDecodeAsNil() {
 17869  		x.AuthToken = ""
 17870  	} else {
 17871  		yyv32 := &x.AuthToken
 17872  		yym33 := z.DecBinary()
 17873  		_ = yym33
 17874  		if false {
 17875  		} else {
 17876  			*((*string)(yyv32)) = r.DecodeString()
 17877  		}
 17878  	}
 17879  	yyj22++
 17880  	if yyhl22 {
 17881  		yyb22 = yyj22 > l
 17882  	} else {
 17883  		yyb22 = r.CheckBreak()
 17884  	}
 17885  	if yyb22 {
 17886  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17887  		return
 17888  	}
 17889  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17890  	if r.TryDecodeAsNil() {
 17891  		x.Forwarded = false
 17892  	} else {
 17893  		yyv34 := &x.Forwarded
 17894  		yym35 := z.DecBinary()
 17895  		_ = yym35
 17896  		if false {
 17897  		} else {
 17898  			*((*bool)(yyv34)) = r.DecodeBool()
 17899  		}
 17900  	}
 17901  	yyj22++
 17902  	if yyhl22 {
 17903  		yyb22 = yyj22 > l
 17904  	} else {
 17905  		yyb22 = r.CheckBreak()
 17906  	}
 17907  	if yyb22 {
 17908  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17909  		return
 17910  	}
 17911  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17912  	if r.TryDecodeAsNil() {
 17913  		if x.Deployment != nil {
 17914  			x.Deployment = nil
 17915  		}
 17916  	} else {
 17917  		if x.Deployment == nil {
 17918  			x.Deployment = new(Deployment)
 17919  		}
 17920  		x.Deployment.CodecDecodeSelf(d)
 17921  	}
 17922  	yyj22++
 17923  	if yyhl22 {
 17924  		yyb22 = yyj22 > l
 17925  	} else {
 17926  		yyb22 = r.CheckBreak()
 17927  	}
 17928  	if yyb22 {
 17929  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17930  		return
 17931  	}
 17932  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17933  	if r.TryDecodeAsNil() {
 17934  		x.DeploymentUpdates = nil
 17935  	} else {
 17936  		yyv37 := &x.DeploymentUpdates
 17937  		yym38 := z.DecBinary()
 17938  		_ = yym38
 17939  		if false {
 17940  		} else {
 17941  			h.decSlicePtrtoDeploymentStatusUpdate((*[]*DeploymentStatusUpdate)(yyv37), d)
 17942  		}
 17943  	}
 17944  	yyj22++
 17945  	if yyhl22 {
 17946  		yyb22 = yyj22 > l
 17947  	} else {
 17948  		yyb22 = r.CheckBreak()
 17949  	}
 17950  	if yyb22 {
 17951  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17952  		return
 17953  	}
 17954  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17955  	if r.TryDecodeAsNil() {
 17956  		x.EvalID = ""
 17957  	} else {
 17958  		yyv39 := &x.EvalID
 17959  		yym40 := z.DecBinary()
 17960  		_ = yym40
 17961  		if false {
 17962  		} else {
 17963  			*((*string)(yyv39)) = r.DecodeString()
 17964  		}
 17965  	}
 17966  	for {
 17967  		yyj22++
 17968  		if yyhl22 {
 17969  			yyb22 = yyj22 > l
 17970  		} else {
 17971  			yyb22 = r.CheckBreak()
 17972  		}
 17973  		if yyb22 {
 17974  			break
 17975  		}
 17976  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 17977  		z.DecStructFieldNotFound(yyj22-1, "")
 17978  	}
 17979  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 17980  }
 17981  
 17982  func (x *AllocUpdateRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 17983  	var h codecSelfer100
 17984  	z, r := codec1978.GenHelperEncoder(e)
 17985  	_, _, _ = h, z, r
 17986  	if x == nil {
 17987  		r.EncodeNil()
 17988  	} else {
 17989  		yym1 := z.EncBinary()
 17990  		_ = yym1
 17991  		if false {
 17992  		} else if z.HasExtensions() && z.EncExt(x) {
 17993  		} else {
 17994  			yysep2 := !z.EncBinary()
 17995  			yy2arr2 := z.EncBasicHandle().StructToArray
 17996  			var yyq2 [7]bool
 17997  			_, _, _ = yysep2, yyq2, yy2arr2
 17998  			const yyr2 bool = false
 17999  			var yynn2 int
 18000  			if yyr2 || yy2arr2 {
 18001  				r.EncodeArrayStart(7)
 18002  			} else {
 18003  				yynn2 = 7
 18004  				for _, b := range yyq2 {
 18005  					if b {
 18006  						yynn2++
 18007  					}
 18008  				}
 18009  				r.EncodeMapStart(yynn2)
 18010  				yynn2 = 0
 18011  			}
 18012  			if yyr2 || yy2arr2 {
 18013  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 18014  				if x.Alloc == nil {
 18015  					r.EncodeNil()
 18016  				} else {
 18017  					yym4 := z.EncBinary()
 18018  					_ = yym4
 18019  					if false {
 18020  					} else {
 18021  						h.encSlicePtrtoAllocation(([]*Allocation)(x.Alloc), e)
 18022  					}
 18023  				}
 18024  			} else {
 18025  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 18026  				r.EncodeString(codecSelferC_UTF8100, string("Alloc"))
 18027  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 18028  				if x.Alloc == nil {
 18029  					r.EncodeNil()
 18030  				} else {
 18031  					yym5 := z.EncBinary()
 18032  					_ = yym5
 18033  					if false {
 18034  					} else {
 18035  						h.encSlicePtrtoAllocation(([]*Allocation)(x.Alloc), e)
 18036  					}
 18037  				}
 18038  			}
 18039  			if yyr2 || yy2arr2 {
 18040  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 18041  				if x.Evals == nil {
 18042  					r.EncodeNil()
 18043  				} else {
 18044  					yym7 := z.EncBinary()
 18045  					_ = yym7
 18046  					if false {
 18047  					} else {
 18048  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.Evals), e)
 18049  					}
 18050  				}
 18051  			} else {
 18052  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 18053  				r.EncodeString(codecSelferC_UTF8100, string("Evals"))
 18054  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 18055  				if x.Evals == nil {
 18056  					r.EncodeNil()
 18057  				} else {
 18058  					yym8 := z.EncBinary()
 18059  					_ = yym8
 18060  					if false {
 18061  					} else {
 18062  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.Evals), e)
 18063  					}
 18064  				}
 18065  			}
 18066  			if yyr2 || yy2arr2 {
 18067  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 18068  				if x.Job == nil {
 18069  					r.EncodeNil()
 18070  				} else {
 18071  					x.Job.CodecEncodeSelf(e)
 18072  				}
 18073  			} else {
 18074  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 18075  				r.EncodeString(codecSelferC_UTF8100, string("Job"))
 18076  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 18077  				if x.Job == nil {
 18078  					r.EncodeNil()
 18079  				} else {
 18080  					x.Job.CodecEncodeSelf(e)
 18081  				}
 18082  			}
 18083  			if yyr2 || yy2arr2 {
 18084  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 18085  				yym13 := z.EncBinary()
 18086  				_ = yym13
 18087  				if false {
 18088  				} else {
 18089  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 18090  				}
 18091  			} else {
 18092  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 18093  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 18094  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 18095  				yym14 := z.EncBinary()
 18096  				_ = yym14
 18097  				if false {
 18098  				} else {
 18099  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 18100  				}
 18101  			}
 18102  			if yyr2 || yy2arr2 {
 18103  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 18104  				yym16 := z.EncBinary()
 18105  				_ = yym16
 18106  				if false {
 18107  				} else {
 18108  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 18109  				}
 18110  			} else {
 18111  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 18112  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 18113  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 18114  				yym17 := z.EncBinary()
 18115  				_ = yym17
 18116  				if false {
 18117  				} else {
 18118  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 18119  				}
 18120  			}
 18121  			if yyr2 || yy2arr2 {
 18122  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 18123  				yym19 := z.EncBinary()
 18124  				_ = yym19
 18125  				if false {
 18126  				} else {
 18127  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 18128  				}
 18129  			} else {
 18130  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 18131  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 18132  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 18133  				yym20 := z.EncBinary()
 18134  				_ = yym20
 18135  				if false {
 18136  				} else {
 18137  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 18138  				}
 18139  			}
 18140  			if yyr2 || yy2arr2 {
 18141  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 18142  				yym22 := z.EncBinary()
 18143  				_ = yym22
 18144  				if false {
 18145  				} else {
 18146  					r.EncodeBool(bool(x.Forwarded))
 18147  				}
 18148  			} else {
 18149  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 18150  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 18151  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 18152  				yym23 := z.EncBinary()
 18153  				_ = yym23
 18154  				if false {
 18155  				} else {
 18156  					r.EncodeBool(bool(x.Forwarded))
 18157  				}
 18158  			}
 18159  			if yyr2 || yy2arr2 {
 18160  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 18161  			} else {
 18162  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 18163  			}
 18164  		}
 18165  	}
 18166  }
 18167  
 18168  func (x *AllocUpdateRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 18169  	var h codecSelfer100
 18170  	z, r := codec1978.GenHelperDecoder(d)
 18171  	_, _, _ = h, z, r
 18172  	yym1 := z.DecBinary()
 18173  	_ = yym1
 18174  	if false {
 18175  	} else if z.HasExtensions() && z.DecExt(x) {
 18176  	} else {
 18177  		yyct2 := r.ContainerType()
 18178  		if yyct2 == codecSelferValueTypeMap100 {
 18179  			yyl2 := r.ReadMapStart()
 18180  			if yyl2 == 0 {
 18181  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 18182  			} else {
 18183  				x.codecDecodeSelfFromMap(yyl2, d)
 18184  			}
 18185  		} else if yyct2 == codecSelferValueTypeArray100 {
 18186  			yyl2 := r.ReadArrayStart()
 18187  			if yyl2 == 0 {
 18188  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18189  			} else {
 18190  				x.codecDecodeSelfFromArray(yyl2, d)
 18191  			}
 18192  		} else {
 18193  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 18194  		}
 18195  	}
 18196  }
 18197  
 18198  func (x *AllocUpdateRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 18199  	var h codecSelfer100
 18200  	z, r := codec1978.GenHelperDecoder(d)
 18201  	_, _, _ = h, z, r
 18202  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 18203  	_ = yys3Slc
 18204  	var yyhl3 bool = l >= 0
 18205  	for yyj3 := 0; ; yyj3++ {
 18206  		if yyhl3 {
 18207  			if yyj3 >= l {
 18208  				break
 18209  			}
 18210  		} else {
 18211  			if r.CheckBreak() {
 18212  				break
 18213  			}
 18214  		}
 18215  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 18216  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 18217  		yys3 := string(yys3Slc)
 18218  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 18219  		switch yys3 {
 18220  		case "Alloc":
 18221  			if r.TryDecodeAsNil() {
 18222  				x.Alloc = nil
 18223  			} else {
 18224  				yyv4 := &x.Alloc
 18225  				yym5 := z.DecBinary()
 18226  				_ = yym5
 18227  				if false {
 18228  				} else {
 18229  					h.decSlicePtrtoAllocation((*[]*Allocation)(yyv4), d)
 18230  				}
 18231  			}
 18232  		case "Evals":
 18233  			if r.TryDecodeAsNil() {
 18234  				x.Evals = nil
 18235  			} else {
 18236  				yyv6 := &x.Evals
 18237  				yym7 := z.DecBinary()
 18238  				_ = yym7
 18239  				if false {
 18240  				} else {
 18241  					h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv6), d)
 18242  				}
 18243  			}
 18244  		case "Job":
 18245  			if r.TryDecodeAsNil() {
 18246  				if x.Job != nil {
 18247  					x.Job = nil
 18248  				}
 18249  			} else {
 18250  				if x.Job == nil {
 18251  					x.Job = new(Job)
 18252  				}
 18253  				x.Job.CodecDecodeSelf(d)
 18254  			}
 18255  		case "Region":
 18256  			if r.TryDecodeAsNil() {
 18257  				x.Region = ""
 18258  			} else {
 18259  				yyv9 := &x.Region
 18260  				yym10 := z.DecBinary()
 18261  				_ = yym10
 18262  				if false {
 18263  				} else {
 18264  					*((*string)(yyv9)) = r.DecodeString()
 18265  				}
 18266  			}
 18267  		case "Namespace":
 18268  			if r.TryDecodeAsNil() {
 18269  				x.Namespace = ""
 18270  			} else {
 18271  				yyv11 := &x.Namespace
 18272  				yym12 := z.DecBinary()
 18273  				_ = yym12
 18274  				if false {
 18275  				} else {
 18276  					*((*string)(yyv11)) = r.DecodeString()
 18277  				}
 18278  			}
 18279  		case "AuthToken":
 18280  			if r.TryDecodeAsNil() {
 18281  				x.AuthToken = ""
 18282  			} else {
 18283  				yyv13 := &x.AuthToken
 18284  				yym14 := z.DecBinary()
 18285  				_ = yym14
 18286  				if false {
 18287  				} else {
 18288  					*((*string)(yyv13)) = r.DecodeString()
 18289  				}
 18290  			}
 18291  		case "Forwarded":
 18292  			if r.TryDecodeAsNil() {
 18293  				x.Forwarded = false
 18294  			} else {
 18295  				yyv15 := &x.Forwarded
 18296  				yym16 := z.DecBinary()
 18297  				_ = yym16
 18298  				if false {
 18299  				} else {
 18300  					*((*bool)(yyv15)) = r.DecodeBool()
 18301  				}
 18302  			}
 18303  		default:
 18304  			z.DecStructFieldNotFound(-1, yys3)
 18305  		} // end switch yys3
 18306  	} // end for yyj3
 18307  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 18308  }
 18309  
 18310  func (x *AllocUpdateRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 18311  	var h codecSelfer100
 18312  	z, r := codec1978.GenHelperDecoder(d)
 18313  	_, _, _ = h, z, r
 18314  	var yyj17 int
 18315  	var yyb17 bool
 18316  	var yyhl17 bool = l >= 0
 18317  	yyj17++
 18318  	if yyhl17 {
 18319  		yyb17 = yyj17 > l
 18320  	} else {
 18321  		yyb17 = r.CheckBreak()
 18322  	}
 18323  	if yyb17 {
 18324  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18325  		return
 18326  	}
 18327  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 18328  	if r.TryDecodeAsNil() {
 18329  		x.Alloc = nil
 18330  	} else {
 18331  		yyv18 := &x.Alloc
 18332  		yym19 := z.DecBinary()
 18333  		_ = yym19
 18334  		if false {
 18335  		} else {
 18336  			h.decSlicePtrtoAllocation((*[]*Allocation)(yyv18), d)
 18337  		}
 18338  	}
 18339  	yyj17++
 18340  	if yyhl17 {
 18341  		yyb17 = yyj17 > l
 18342  	} else {
 18343  		yyb17 = r.CheckBreak()
 18344  	}
 18345  	if yyb17 {
 18346  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18347  		return
 18348  	}
 18349  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 18350  	if r.TryDecodeAsNil() {
 18351  		x.Evals = nil
 18352  	} else {
 18353  		yyv20 := &x.Evals
 18354  		yym21 := z.DecBinary()
 18355  		_ = yym21
 18356  		if false {
 18357  		} else {
 18358  			h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv20), d)
 18359  		}
 18360  	}
 18361  	yyj17++
 18362  	if yyhl17 {
 18363  		yyb17 = yyj17 > l
 18364  	} else {
 18365  		yyb17 = r.CheckBreak()
 18366  	}
 18367  	if yyb17 {
 18368  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18369  		return
 18370  	}
 18371  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 18372  	if r.TryDecodeAsNil() {
 18373  		if x.Job != nil {
 18374  			x.Job = nil
 18375  		}
 18376  	} else {
 18377  		if x.Job == nil {
 18378  			x.Job = new(Job)
 18379  		}
 18380  		x.Job.CodecDecodeSelf(d)
 18381  	}
 18382  	yyj17++
 18383  	if yyhl17 {
 18384  		yyb17 = yyj17 > l
 18385  	} else {
 18386  		yyb17 = r.CheckBreak()
 18387  	}
 18388  	if yyb17 {
 18389  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18390  		return
 18391  	}
 18392  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 18393  	if r.TryDecodeAsNil() {
 18394  		x.Region = ""
 18395  	} else {
 18396  		yyv23 := &x.Region
 18397  		yym24 := z.DecBinary()
 18398  		_ = yym24
 18399  		if false {
 18400  		} else {
 18401  			*((*string)(yyv23)) = r.DecodeString()
 18402  		}
 18403  	}
 18404  	yyj17++
 18405  	if yyhl17 {
 18406  		yyb17 = yyj17 > l
 18407  	} else {
 18408  		yyb17 = r.CheckBreak()
 18409  	}
 18410  	if yyb17 {
 18411  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18412  		return
 18413  	}
 18414  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 18415  	if r.TryDecodeAsNil() {
 18416  		x.Namespace = ""
 18417  	} else {
 18418  		yyv25 := &x.Namespace
 18419  		yym26 := z.DecBinary()
 18420  		_ = yym26
 18421  		if false {
 18422  		} else {
 18423  			*((*string)(yyv25)) = r.DecodeString()
 18424  		}
 18425  	}
 18426  	yyj17++
 18427  	if yyhl17 {
 18428  		yyb17 = yyj17 > l
 18429  	} else {
 18430  		yyb17 = r.CheckBreak()
 18431  	}
 18432  	if yyb17 {
 18433  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18434  		return
 18435  	}
 18436  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 18437  	if r.TryDecodeAsNil() {
 18438  		x.AuthToken = ""
 18439  	} else {
 18440  		yyv27 := &x.AuthToken
 18441  		yym28 := z.DecBinary()
 18442  		_ = yym28
 18443  		if false {
 18444  		} else {
 18445  			*((*string)(yyv27)) = r.DecodeString()
 18446  		}
 18447  	}
 18448  	yyj17++
 18449  	if yyhl17 {
 18450  		yyb17 = yyj17 > l
 18451  	} else {
 18452  		yyb17 = r.CheckBreak()
 18453  	}
 18454  	if yyb17 {
 18455  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18456  		return
 18457  	}
 18458  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 18459  	if r.TryDecodeAsNil() {
 18460  		x.Forwarded = false
 18461  	} else {
 18462  		yyv29 := &x.Forwarded
 18463  		yym30 := z.DecBinary()
 18464  		_ = yym30
 18465  		if false {
 18466  		} else {
 18467  			*((*bool)(yyv29)) = r.DecodeBool()
 18468  		}
 18469  	}
 18470  	for {
 18471  		yyj17++
 18472  		if yyhl17 {
 18473  			yyb17 = yyj17 > l
 18474  		} else {
 18475  			yyb17 = r.CheckBreak()
 18476  		}
 18477  		if yyb17 {
 18478  			break
 18479  		}
 18480  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 18481  		z.DecStructFieldNotFound(yyj17-1, "")
 18482  	}
 18483  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18484  }
 18485  
 18486  func (x *AllocUpdateDesiredTransitionRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 18487  	var h codecSelfer100
 18488  	z, r := codec1978.GenHelperEncoder(e)
 18489  	_, _, _ = h, z, r
 18490  	if x == nil {
 18491  		r.EncodeNil()
 18492  	} else {
 18493  		yym1 := z.EncBinary()
 18494  		_ = yym1
 18495  		if false {
 18496  		} else if z.HasExtensions() && z.EncExt(x) {
 18497  		} else {
 18498  			yysep2 := !z.EncBinary()
 18499  			yy2arr2 := z.EncBasicHandle().StructToArray
 18500  			var yyq2 [6]bool
 18501  			_, _, _ = yysep2, yyq2, yy2arr2
 18502  			const yyr2 bool = false
 18503  			var yynn2 int
 18504  			if yyr2 || yy2arr2 {
 18505  				r.EncodeArrayStart(6)
 18506  			} else {
 18507  				yynn2 = 6
 18508  				for _, b := range yyq2 {
 18509  					if b {
 18510  						yynn2++
 18511  					}
 18512  				}
 18513  				r.EncodeMapStart(yynn2)
 18514  				yynn2 = 0
 18515  			}
 18516  			if yyr2 || yy2arr2 {
 18517  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 18518  				if x.Allocs == nil {
 18519  					r.EncodeNil()
 18520  				} else {
 18521  					yym4 := z.EncBinary()
 18522  					_ = yym4
 18523  					if false {
 18524  					} else {
 18525  						h.encMapstringPtrtoDesiredTransition((map[string]*DesiredTransition)(x.Allocs), e)
 18526  					}
 18527  				}
 18528  			} else {
 18529  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 18530  				r.EncodeString(codecSelferC_UTF8100, string("Allocs"))
 18531  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 18532  				if x.Allocs == nil {
 18533  					r.EncodeNil()
 18534  				} else {
 18535  					yym5 := z.EncBinary()
 18536  					_ = yym5
 18537  					if false {
 18538  					} else {
 18539  						h.encMapstringPtrtoDesiredTransition((map[string]*DesiredTransition)(x.Allocs), e)
 18540  					}
 18541  				}
 18542  			}
 18543  			if yyr2 || yy2arr2 {
 18544  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 18545  				if x.Evals == nil {
 18546  					r.EncodeNil()
 18547  				} else {
 18548  					yym7 := z.EncBinary()
 18549  					_ = yym7
 18550  					if false {
 18551  					} else {
 18552  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.Evals), e)
 18553  					}
 18554  				}
 18555  			} else {
 18556  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 18557  				r.EncodeString(codecSelferC_UTF8100, string("Evals"))
 18558  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 18559  				if x.Evals == nil {
 18560  					r.EncodeNil()
 18561  				} else {
 18562  					yym8 := z.EncBinary()
 18563  					_ = yym8
 18564  					if false {
 18565  					} else {
 18566  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.Evals), e)
 18567  					}
 18568  				}
 18569  			}
 18570  			if yyr2 || yy2arr2 {
 18571  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 18572  				yym10 := z.EncBinary()
 18573  				_ = yym10
 18574  				if false {
 18575  				} else {
 18576  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 18577  				}
 18578  			} else {
 18579  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 18580  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 18581  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 18582  				yym11 := z.EncBinary()
 18583  				_ = yym11
 18584  				if false {
 18585  				} else {
 18586  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 18587  				}
 18588  			}
 18589  			if yyr2 || yy2arr2 {
 18590  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 18591  				yym13 := z.EncBinary()
 18592  				_ = yym13
 18593  				if false {
 18594  				} else {
 18595  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 18596  				}
 18597  			} else {
 18598  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 18599  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 18600  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 18601  				yym14 := z.EncBinary()
 18602  				_ = yym14
 18603  				if false {
 18604  				} else {
 18605  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 18606  				}
 18607  			}
 18608  			if yyr2 || yy2arr2 {
 18609  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 18610  				yym16 := z.EncBinary()
 18611  				_ = yym16
 18612  				if false {
 18613  				} else {
 18614  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 18615  				}
 18616  			} else {
 18617  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 18618  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 18619  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 18620  				yym17 := z.EncBinary()
 18621  				_ = yym17
 18622  				if false {
 18623  				} else {
 18624  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 18625  				}
 18626  			}
 18627  			if yyr2 || yy2arr2 {
 18628  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 18629  				yym19 := z.EncBinary()
 18630  				_ = yym19
 18631  				if false {
 18632  				} else {
 18633  					r.EncodeBool(bool(x.Forwarded))
 18634  				}
 18635  			} else {
 18636  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 18637  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 18638  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 18639  				yym20 := z.EncBinary()
 18640  				_ = yym20
 18641  				if false {
 18642  				} else {
 18643  					r.EncodeBool(bool(x.Forwarded))
 18644  				}
 18645  			}
 18646  			if yyr2 || yy2arr2 {
 18647  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 18648  			} else {
 18649  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 18650  			}
 18651  		}
 18652  	}
 18653  }
 18654  
 18655  func (x *AllocUpdateDesiredTransitionRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 18656  	var h codecSelfer100
 18657  	z, r := codec1978.GenHelperDecoder(d)
 18658  	_, _, _ = h, z, r
 18659  	yym1 := z.DecBinary()
 18660  	_ = yym1
 18661  	if false {
 18662  	} else if z.HasExtensions() && z.DecExt(x) {
 18663  	} else {
 18664  		yyct2 := r.ContainerType()
 18665  		if yyct2 == codecSelferValueTypeMap100 {
 18666  			yyl2 := r.ReadMapStart()
 18667  			if yyl2 == 0 {
 18668  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 18669  			} else {
 18670  				x.codecDecodeSelfFromMap(yyl2, d)
 18671  			}
 18672  		} else if yyct2 == codecSelferValueTypeArray100 {
 18673  			yyl2 := r.ReadArrayStart()
 18674  			if yyl2 == 0 {
 18675  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18676  			} else {
 18677  				x.codecDecodeSelfFromArray(yyl2, d)
 18678  			}
 18679  		} else {
 18680  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 18681  		}
 18682  	}
 18683  }
 18684  
 18685  func (x *AllocUpdateDesiredTransitionRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 18686  	var h codecSelfer100
 18687  	z, r := codec1978.GenHelperDecoder(d)
 18688  	_, _, _ = h, z, r
 18689  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 18690  	_ = yys3Slc
 18691  	var yyhl3 bool = l >= 0
 18692  	for yyj3 := 0; ; yyj3++ {
 18693  		if yyhl3 {
 18694  			if yyj3 >= l {
 18695  				break
 18696  			}
 18697  		} else {
 18698  			if r.CheckBreak() {
 18699  				break
 18700  			}
 18701  		}
 18702  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 18703  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 18704  		yys3 := string(yys3Slc)
 18705  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 18706  		switch yys3 {
 18707  		case "Allocs":
 18708  			if r.TryDecodeAsNil() {
 18709  				x.Allocs = nil
 18710  			} else {
 18711  				yyv4 := &x.Allocs
 18712  				yym5 := z.DecBinary()
 18713  				_ = yym5
 18714  				if false {
 18715  				} else {
 18716  					h.decMapstringPtrtoDesiredTransition((*map[string]*DesiredTransition)(yyv4), d)
 18717  				}
 18718  			}
 18719  		case "Evals":
 18720  			if r.TryDecodeAsNil() {
 18721  				x.Evals = nil
 18722  			} else {
 18723  				yyv6 := &x.Evals
 18724  				yym7 := z.DecBinary()
 18725  				_ = yym7
 18726  				if false {
 18727  				} else {
 18728  					h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv6), d)
 18729  				}
 18730  			}
 18731  		case "Region":
 18732  			if r.TryDecodeAsNil() {
 18733  				x.Region = ""
 18734  			} else {
 18735  				yyv8 := &x.Region
 18736  				yym9 := z.DecBinary()
 18737  				_ = yym9
 18738  				if false {
 18739  				} else {
 18740  					*((*string)(yyv8)) = r.DecodeString()
 18741  				}
 18742  			}
 18743  		case "Namespace":
 18744  			if r.TryDecodeAsNil() {
 18745  				x.Namespace = ""
 18746  			} else {
 18747  				yyv10 := &x.Namespace
 18748  				yym11 := z.DecBinary()
 18749  				_ = yym11
 18750  				if false {
 18751  				} else {
 18752  					*((*string)(yyv10)) = r.DecodeString()
 18753  				}
 18754  			}
 18755  		case "AuthToken":
 18756  			if r.TryDecodeAsNil() {
 18757  				x.AuthToken = ""
 18758  			} else {
 18759  				yyv12 := &x.AuthToken
 18760  				yym13 := z.DecBinary()
 18761  				_ = yym13
 18762  				if false {
 18763  				} else {
 18764  					*((*string)(yyv12)) = r.DecodeString()
 18765  				}
 18766  			}
 18767  		case "Forwarded":
 18768  			if r.TryDecodeAsNil() {
 18769  				x.Forwarded = false
 18770  			} else {
 18771  				yyv14 := &x.Forwarded
 18772  				yym15 := z.DecBinary()
 18773  				_ = yym15
 18774  				if false {
 18775  				} else {
 18776  					*((*bool)(yyv14)) = r.DecodeBool()
 18777  				}
 18778  			}
 18779  		default:
 18780  			z.DecStructFieldNotFound(-1, yys3)
 18781  		} // end switch yys3
 18782  	} // end for yyj3
 18783  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 18784  }
 18785  
 18786  func (x *AllocUpdateDesiredTransitionRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 18787  	var h codecSelfer100
 18788  	z, r := codec1978.GenHelperDecoder(d)
 18789  	_, _, _ = h, z, r
 18790  	var yyj16 int
 18791  	var yyb16 bool
 18792  	var yyhl16 bool = l >= 0
 18793  	yyj16++
 18794  	if yyhl16 {
 18795  		yyb16 = yyj16 > l
 18796  	} else {
 18797  		yyb16 = r.CheckBreak()
 18798  	}
 18799  	if yyb16 {
 18800  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18801  		return
 18802  	}
 18803  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 18804  	if r.TryDecodeAsNil() {
 18805  		x.Allocs = nil
 18806  	} else {
 18807  		yyv17 := &x.Allocs
 18808  		yym18 := z.DecBinary()
 18809  		_ = yym18
 18810  		if false {
 18811  		} else {
 18812  			h.decMapstringPtrtoDesiredTransition((*map[string]*DesiredTransition)(yyv17), d)
 18813  		}
 18814  	}
 18815  	yyj16++
 18816  	if yyhl16 {
 18817  		yyb16 = yyj16 > l
 18818  	} else {
 18819  		yyb16 = r.CheckBreak()
 18820  	}
 18821  	if yyb16 {
 18822  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18823  		return
 18824  	}
 18825  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 18826  	if r.TryDecodeAsNil() {
 18827  		x.Evals = nil
 18828  	} else {
 18829  		yyv19 := &x.Evals
 18830  		yym20 := z.DecBinary()
 18831  		_ = yym20
 18832  		if false {
 18833  		} else {
 18834  			h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv19), d)
 18835  		}
 18836  	}
 18837  	yyj16++
 18838  	if yyhl16 {
 18839  		yyb16 = yyj16 > l
 18840  	} else {
 18841  		yyb16 = r.CheckBreak()
 18842  	}
 18843  	if yyb16 {
 18844  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18845  		return
 18846  	}
 18847  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 18848  	if r.TryDecodeAsNil() {
 18849  		x.Region = ""
 18850  	} else {
 18851  		yyv21 := &x.Region
 18852  		yym22 := z.DecBinary()
 18853  		_ = yym22
 18854  		if false {
 18855  		} else {
 18856  			*((*string)(yyv21)) = r.DecodeString()
 18857  		}
 18858  	}
 18859  	yyj16++
 18860  	if yyhl16 {
 18861  		yyb16 = yyj16 > l
 18862  	} else {
 18863  		yyb16 = r.CheckBreak()
 18864  	}
 18865  	if yyb16 {
 18866  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18867  		return
 18868  	}
 18869  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 18870  	if r.TryDecodeAsNil() {
 18871  		x.Namespace = ""
 18872  	} else {
 18873  		yyv23 := &x.Namespace
 18874  		yym24 := z.DecBinary()
 18875  		_ = yym24
 18876  		if false {
 18877  		} else {
 18878  			*((*string)(yyv23)) = r.DecodeString()
 18879  		}
 18880  	}
 18881  	yyj16++
 18882  	if yyhl16 {
 18883  		yyb16 = yyj16 > l
 18884  	} else {
 18885  		yyb16 = r.CheckBreak()
 18886  	}
 18887  	if yyb16 {
 18888  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18889  		return
 18890  	}
 18891  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 18892  	if r.TryDecodeAsNil() {
 18893  		x.AuthToken = ""
 18894  	} else {
 18895  		yyv25 := &x.AuthToken
 18896  		yym26 := z.DecBinary()
 18897  		_ = yym26
 18898  		if false {
 18899  		} else {
 18900  			*((*string)(yyv25)) = r.DecodeString()
 18901  		}
 18902  	}
 18903  	yyj16++
 18904  	if yyhl16 {
 18905  		yyb16 = yyj16 > l
 18906  	} else {
 18907  		yyb16 = r.CheckBreak()
 18908  	}
 18909  	if yyb16 {
 18910  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18911  		return
 18912  	}
 18913  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 18914  	if r.TryDecodeAsNil() {
 18915  		x.Forwarded = false
 18916  	} else {
 18917  		yyv27 := &x.Forwarded
 18918  		yym28 := z.DecBinary()
 18919  		_ = yym28
 18920  		if false {
 18921  		} else {
 18922  			*((*bool)(yyv27)) = r.DecodeBool()
 18923  		}
 18924  	}
 18925  	for {
 18926  		yyj16++
 18927  		if yyhl16 {
 18928  			yyb16 = yyj16 > l
 18929  		} else {
 18930  			yyb16 = r.CheckBreak()
 18931  		}
 18932  		if yyb16 {
 18933  			break
 18934  		}
 18935  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 18936  		z.DecStructFieldNotFound(yyj16-1, "")
 18937  	}
 18938  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 18939  }
 18940  
 18941  func (x *AllocListRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 18942  	var h codecSelfer100
 18943  	z, r := codec1978.GenHelperEncoder(e)
 18944  	_, _, _ = h, z, r
 18945  	if x == nil {
 18946  		r.EncodeNil()
 18947  	} else {
 18948  		yym1 := z.EncBinary()
 18949  		_ = yym1
 18950  		if false {
 18951  		} else if z.HasExtensions() && z.EncExt(x) {
 18952  		} else {
 18953  			yysep2 := !z.EncBinary()
 18954  			yy2arr2 := z.EncBasicHandle().StructToArray
 18955  			var yyq2 [8]bool
 18956  			_, _, _ = yysep2, yyq2, yy2arr2
 18957  			const yyr2 bool = false
 18958  			var yynn2 int
 18959  			if yyr2 || yy2arr2 {
 18960  				r.EncodeArrayStart(8)
 18961  			} else {
 18962  				yynn2 = 8
 18963  				for _, b := range yyq2 {
 18964  					if b {
 18965  						yynn2++
 18966  					}
 18967  				}
 18968  				r.EncodeMapStart(yynn2)
 18969  				yynn2 = 0
 18970  			}
 18971  			if yyr2 || yy2arr2 {
 18972  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 18973  				yym4 := z.EncBinary()
 18974  				_ = yym4
 18975  				if false {
 18976  				} else {
 18977  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 18978  				}
 18979  			} else {
 18980  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 18981  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 18982  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 18983  				yym5 := z.EncBinary()
 18984  				_ = yym5
 18985  				if false {
 18986  				} else {
 18987  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 18988  				}
 18989  			}
 18990  			if yyr2 || yy2arr2 {
 18991  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 18992  				yym7 := z.EncBinary()
 18993  				_ = yym7
 18994  				if false {
 18995  				} else {
 18996  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 18997  				}
 18998  			} else {
 18999  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19000  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 19001  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19002  				yym8 := z.EncBinary()
 19003  				_ = yym8
 19004  				if false {
 19005  				} else {
 19006  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 19007  				}
 19008  			}
 19009  			if yyr2 || yy2arr2 {
 19010  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 19011  				yym10 := z.EncBinary()
 19012  				_ = yym10
 19013  				if false {
 19014  				} else {
 19015  					r.EncodeUint(uint64(x.MinQueryIndex))
 19016  				}
 19017  			} else {
 19018  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19019  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 19020  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19021  				yym11 := z.EncBinary()
 19022  				_ = yym11
 19023  				if false {
 19024  				} else {
 19025  					r.EncodeUint(uint64(x.MinQueryIndex))
 19026  				}
 19027  			}
 19028  			if yyr2 || yy2arr2 {
 19029  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 19030  				yym13 := z.EncBinary()
 19031  				_ = yym13
 19032  				if false {
 19033  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 19034  				} else {
 19035  					r.EncodeInt(int64(x.MaxQueryTime))
 19036  				}
 19037  			} else {
 19038  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19039  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 19040  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19041  				yym14 := z.EncBinary()
 19042  				_ = yym14
 19043  				if false {
 19044  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 19045  				} else {
 19046  					r.EncodeInt(int64(x.MaxQueryTime))
 19047  				}
 19048  			}
 19049  			if yyr2 || yy2arr2 {
 19050  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 19051  				yym16 := z.EncBinary()
 19052  				_ = yym16
 19053  				if false {
 19054  				} else {
 19055  					r.EncodeBool(bool(x.AllowStale))
 19056  				}
 19057  			} else {
 19058  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19059  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 19060  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19061  				yym17 := z.EncBinary()
 19062  				_ = yym17
 19063  				if false {
 19064  				} else {
 19065  					r.EncodeBool(bool(x.AllowStale))
 19066  				}
 19067  			}
 19068  			if yyr2 || yy2arr2 {
 19069  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 19070  				yym19 := z.EncBinary()
 19071  				_ = yym19
 19072  				if false {
 19073  				} else {
 19074  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 19075  				}
 19076  			} else {
 19077  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19078  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 19079  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19080  				yym20 := z.EncBinary()
 19081  				_ = yym20
 19082  				if false {
 19083  				} else {
 19084  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 19085  				}
 19086  			}
 19087  			if yyr2 || yy2arr2 {
 19088  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 19089  				yym22 := z.EncBinary()
 19090  				_ = yym22
 19091  				if false {
 19092  				} else {
 19093  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 19094  				}
 19095  			} else {
 19096  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19097  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 19098  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19099  				yym23 := z.EncBinary()
 19100  				_ = yym23
 19101  				if false {
 19102  				} else {
 19103  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 19104  				}
 19105  			}
 19106  			if yyr2 || yy2arr2 {
 19107  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 19108  				yym25 := z.EncBinary()
 19109  				_ = yym25
 19110  				if false {
 19111  				} else {
 19112  					r.EncodeBool(bool(x.Forwarded))
 19113  				}
 19114  			} else {
 19115  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19116  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 19117  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19118  				yym26 := z.EncBinary()
 19119  				_ = yym26
 19120  				if false {
 19121  				} else {
 19122  					r.EncodeBool(bool(x.Forwarded))
 19123  				}
 19124  			}
 19125  			if yyr2 || yy2arr2 {
 19126  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 19127  			} else {
 19128  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 19129  			}
 19130  		}
 19131  	}
 19132  }
 19133  
 19134  func (x *AllocListRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 19135  	var h codecSelfer100
 19136  	z, r := codec1978.GenHelperDecoder(d)
 19137  	_, _, _ = h, z, r
 19138  	yym1 := z.DecBinary()
 19139  	_ = yym1
 19140  	if false {
 19141  	} else if z.HasExtensions() && z.DecExt(x) {
 19142  	} else {
 19143  		yyct2 := r.ContainerType()
 19144  		if yyct2 == codecSelferValueTypeMap100 {
 19145  			yyl2 := r.ReadMapStart()
 19146  			if yyl2 == 0 {
 19147  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 19148  			} else {
 19149  				x.codecDecodeSelfFromMap(yyl2, d)
 19150  			}
 19151  		} else if yyct2 == codecSelferValueTypeArray100 {
 19152  			yyl2 := r.ReadArrayStart()
 19153  			if yyl2 == 0 {
 19154  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19155  			} else {
 19156  				x.codecDecodeSelfFromArray(yyl2, d)
 19157  			}
 19158  		} else {
 19159  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 19160  		}
 19161  	}
 19162  }
 19163  
 19164  func (x *AllocListRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 19165  	var h codecSelfer100
 19166  	z, r := codec1978.GenHelperDecoder(d)
 19167  	_, _, _ = h, z, r
 19168  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 19169  	_ = yys3Slc
 19170  	var yyhl3 bool = l >= 0
 19171  	for yyj3 := 0; ; yyj3++ {
 19172  		if yyhl3 {
 19173  			if yyj3 >= l {
 19174  				break
 19175  			}
 19176  		} else {
 19177  			if r.CheckBreak() {
 19178  				break
 19179  			}
 19180  		}
 19181  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 19182  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 19183  		yys3 := string(yys3Slc)
 19184  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 19185  		switch yys3 {
 19186  		case "Region":
 19187  			if r.TryDecodeAsNil() {
 19188  				x.Region = ""
 19189  			} else {
 19190  				yyv4 := &x.Region
 19191  				yym5 := z.DecBinary()
 19192  				_ = yym5
 19193  				if false {
 19194  				} else {
 19195  					*((*string)(yyv4)) = r.DecodeString()
 19196  				}
 19197  			}
 19198  		case "Namespace":
 19199  			if r.TryDecodeAsNil() {
 19200  				x.Namespace = ""
 19201  			} else {
 19202  				yyv6 := &x.Namespace
 19203  				yym7 := z.DecBinary()
 19204  				_ = yym7
 19205  				if false {
 19206  				} else {
 19207  					*((*string)(yyv6)) = r.DecodeString()
 19208  				}
 19209  			}
 19210  		case "MinQueryIndex":
 19211  			if r.TryDecodeAsNil() {
 19212  				x.MinQueryIndex = 0
 19213  			} else {
 19214  				yyv8 := &x.MinQueryIndex
 19215  				yym9 := z.DecBinary()
 19216  				_ = yym9
 19217  				if false {
 19218  				} else {
 19219  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 19220  				}
 19221  			}
 19222  		case "MaxQueryTime":
 19223  			if r.TryDecodeAsNil() {
 19224  				x.MaxQueryTime = 0
 19225  			} else {
 19226  				yyv10 := &x.MaxQueryTime
 19227  				yym11 := z.DecBinary()
 19228  				_ = yym11
 19229  				if false {
 19230  				} else if z.HasExtensions() && z.DecExt(yyv10) {
 19231  				} else {
 19232  					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
 19233  				}
 19234  			}
 19235  		case "AllowStale":
 19236  			if r.TryDecodeAsNil() {
 19237  				x.AllowStale = false
 19238  			} else {
 19239  				yyv12 := &x.AllowStale
 19240  				yym13 := z.DecBinary()
 19241  				_ = yym13
 19242  				if false {
 19243  				} else {
 19244  					*((*bool)(yyv12)) = r.DecodeBool()
 19245  				}
 19246  			}
 19247  		case "Prefix":
 19248  			if r.TryDecodeAsNil() {
 19249  				x.Prefix = ""
 19250  			} else {
 19251  				yyv14 := &x.Prefix
 19252  				yym15 := z.DecBinary()
 19253  				_ = yym15
 19254  				if false {
 19255  				} else {
 19256  					*((*string)(yyv14)) = r.DecodeString()
 19257  				}
 19258  			}
 19259  		case "AuthToken":
 19260  			if r.TryDecodeAsNil() {
 19261  				x.AuthToken = ""
 19262  			} else {
 19263  				yyv16 := &x.AuthToken
 19264  				yym17 := z.DecBinary()
 19265  				_ = yym17
 19266  				if false {
 19267  				} else {
 19268  					*((*string)(yyv16)) = r.DecodeString()
 19269  				}
 19270  			}
 19271  		case "Forwarded":
 19272  			if r.TryDecodeAsNil() {
 19273  				x.Forwarded = false
 19274  			} else {
 19275  				yyv18 := &x.Forwarded
 19276  				yym19 := z.DecBinary()
 19277  				_ = yym19
 19278  				if false {
 19279  				} else {
 19280  					*((*bool)(yyv18)) = r.DecodeBool()
 19281  				}
 19282  			}
 19283  		default:
 19284  			z.DecStructFieldNotFound(-1, yys3)
 19285  		} // end switch yys3
 19286  	} // end for yyj3
 19287  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 19288  }
 19289  
 19290  func (x *AllocListRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 19291  	var h codecSelfer100
 19292  	z, r := codec1978.GenHelperDecoder(d)
 19293  	_, _, _ = h, z, r
 19294  	var yyj20 int
 19295  	var yyb20 bool
 19296  	var yyhl20 bool = l >= 0
 19297  	yyj20++
 19298  	if yyhl20 {
 19299  		yyb20 = yyj20 > l
 19300  	} else {
 19301  		yyb20 = r.CheckBreak()
 19302  	}
 19303  	if yyb20 {
 19304  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19305  		return
 19306  	}
 19307  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 19308  	if r.TryDecodeAsNil() {
 19309  		x.Region = ""
 19310  	} else {
 19311  		yyv21 := &x.Region
 19312  		yym22 := z.DecBinary()
 19313  		_ = yym22
 19314  		if false {
 19315  		} else {
 19316  			*((*string)(yyv21)) = r.DecodeString()
 19317  		}
 19318  	}
 19319  	yyj20++
 19320  	if yyhl20 {
 19321  		yyb20 = yyj20 > l
 19322  	} else {
 19323  		yyb20 = r.CheckBreak()
 19324  	}
 19325  	if yyb20 {
 19326  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19327  		return
 19328  	}
 19329  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 19330  	if r.TryDecodeAsNil() {
 19331  		x.Namespace = ""
 19332  	} else {
 19333  		yyv23 := &x.Namespace
 19334  		yym24 := z.DecBinary()
 19335  		_ = yym24
 19336  		if false {
 19337  		} else {
 19338  			*((*string)(yyv23)) = r.DecodeString()
 19339  		}
 19340  	}
 19341  	yyj20++
 19342  	if yyhl20 {
 19343  		yyb20 = yyj20 > l
 19344  	} else {
 19345  		yyb20 = r.CheckBreak()
 19346  	}
 19347  	if yyb20 {
 19348  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19349  		return
 19350  	}
 19351  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 19352  	if r.TryDecodeAsNil() {
 19353  		x.MinQueryIndex = 0
 19354  	} else {
 19355  		yyv25 := &x.MinQueryIndex
 19356  		yym26 := z.DecBinary()
 19357  		_ = yym26
 19358  		if false {
 19359  		} else {
 19360  			*((*uint64)(yyv25)) = uint64(r.DecodeUint(64))
 19361  		}
 19362  	}
 19363  	yyj20++
 19364  	if yyhl20 {
 19365  		yyb20 = yyj20 > l
 19366  	} else {
 19367  		yyb20 = r.CheckBreak()
 19368  	}
 19369  	if yyb20 {
 19370  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19371  		return
 19372  	}
 19373  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 19374  	if r.TryDecodeAsNil() {
 19375  		x.MaxQueryTime = 0
 19376  	} else {
 19377  		yyv27 := &x.MaxQueryTime
 19378  		yym28 := z.DecBinary()
 19379  		_ = yym28
 19380  		if false {
 19381  		} else if z.HasExtensions() && z.DecExt(yyv27) {
 19382  		} else {
 19383  			*((*int64)(yyv27)) = int64(r.DecodeInt(64))
 19384  		}
 19385  	}
 19386  	yyj20++
 19387  	if yyhl20 {
 19388  		yyb20 = yyj20 > l
 19389  	} else {
 19390  		yyb20 = r.CheckBreak()
 19391  	}
 19392  	if yyb20 {
 19393  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19394  		return
 19395  	}
 19396  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 19397  	if r.TryDecodeAsNil() {
 19398  		x.AllowStale = false
 19399  	} else {
 19400  		yyv29 := &x.AllowStale
 19401  		yym30 := z.DecBinary()
 19402  		_ = yym30
 19403  		if false {
 19404  		} else {
 19405  			*((*bool)(yyv29)) = r.DecodeBool()
 19406  		}
 19407  	}
 19408  	yyj20++
 19409  	if yyhl20 {
 19410  		yyb20 = yyj20 > l
 19411  	} else {
 19412  		yyb20 = r.CheckBreak()
 19413  	}
 19414  	if yyb20 {
 19415  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19416  		return
 19417  	}
 19418  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 19419  	if r.TryDecodeAsNil() {
 19420  		x.Prefix = ""
 19421  	} else {
 19422  		yyv31 := &x.Prefix
 19423  		yym32 := z.DecBinary()
 19424  		_ = yym32
 19425  		if false {
 19426  		} else {
 19427  			*((*string)(yyv31)) = r.DecodeString()
 19428  		}
 19429  	}
 19430  	yyj20++
 19431  	if yyhl20 {
 19432  		yyb20 = yyj20 > l
 19433  	} else {
 19434  		yyb20 = r.CheckBreak()
 19435  	}
 19436  	if yyb20 {
 19437  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19438  		return
 19439  	}
 19440  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 19441  	if r.TryDecodeAsNil() {
 19442  		x.AuthToken = ""
 19443  	} else {
 19444  		yyv33 := &x.AuthToken
 19445  		yym34 := z.DecBinary()
 19446  		_ = yym34
 19447  		if false {
 19448  		} else {
 19449  			*((*string)(yyv33)) = r.DecodeString()
 19450  		}
 19451  	}
 19452  	yyj20++
 19453  	if yyhl20 {
 19454  		yyb20 = yyj20 > l
 19455  	} else {
 19456  		yyb20 = r.CheckBreak()
 19457  	}
 19458  	if yyb20 {
 19459  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19460  		return
 19461  	}
 19462  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 19463  	if r.TryDecodeAsNil() {
 19464  		x.Forwarded = false
 19465  	} else {
 19466  		yyv35 := &x.Forwarded
 19467  		yym36 := z.DecBinary()
 19468  		_ = yym36
 19469  		if false {
 19470  		} else {
 19471  			*((*bool)(yyv35)) = r.DecodeBool()
 19472  		}
 19473  	}
 19474  	for {
 19475  		yyj20++
 19476  		if yyhl20 {
 19477  			yyb20 = yyj20 > l
 19478  		} else {
 19479  			yyb20 = r.CheckBreak()
 19480  		}
 19481  		if yyb20 {
 19482  			break
 19483  		}
 19484  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 19485  		z.DecStructFieldNotFound(yyj20-1, "")
 19486  	}
 19487  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19488  }
 19489  
 19490  func (x *AllocSpecificRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 19491  	var h codecSelfer100
 19492  	z, r := codec1978.GenHelperEncoder(e)
 19493  	_, _, _ = h, z, r
 19494  	if x == nil {
 19495  		r.EncodeNil()
 19496  	} else {
 19497  		yym1 := z.EncBinary()
 19498  		_ = yym1
 19499  		if false {
 19500  		} else if z.HasExtensions() && z.EncExt(x) {
 19501  		} else {
 19502  			yysep2 := !z.EncBinary()
 19503  			yy2arr2 := z.EncBasicHandle().StructToArray
 19504  			var yyq2 [9]bool
 19505  			_, _, _ = yysep2, yyq2, yy2arr2
 19506  			const yyr2 bool = false
 19507  			var yynn2 int
 19508  			if yyr2 || yy2arr2 {
 19509  				r.EncodeArrayStart(9)
 19510  			} else {
 19511  				yynn2 = 9
 19512  				for _, b := range yyq2 {
 19513  					if b {
 19514  						yynn2++
 19515  					}
 19516  				}
 19517  				r.EncodeMapStart(yynn2)
 19518  				yynn2 = 0
 19519  			}
 19520  			if yyr2 || yy2arr2 {
 19521  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 19522  				yym4 := z.EncBinary()
 19523  				_ = yym4
 19524  				if false {
 19525  				} else {
 19526  					r.EncodeString(codecSelferC_UTF8100, string(x.AllocID))
 19527  				}
 19528  			} else {
 19529  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19530  				r.EncodeString(codecSelferC_UTF8100, string("AllocID"))
 19531  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19532  				yym5 := z.EncBinary()
 19533  				_ = yym5
 19534  				if false {
 19535  				} else {
 19536  					r.EncodeString(codecSelferC_UTF8100, string(x.AllocID))
 19537  				}
 19538  			}
 19539  			if yyr2 || yy2arr2 {
 19540  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 19541  				yym7 := z.EncBinary()
 19542  				_ = yym7
 19543  				if false {
 19544  				} else {
 19545  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 19546  				}
 19547  			} else {
 19548  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19549  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 19550  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19551  				yym8 := z.EncBinary()
 19552  				_ = yym8
 19553  				if false {
 19554  				} else {
 19555  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 19556  				}
 19557  			}
 19558  			if yyr2 || yy2arr2 {
 19559  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 19560  				yym10 := z.EncBinary()
 19561  				_ = yym10
 19562  				if false {
 19563  				} else {
 19564  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 19565  				}
 19566  			} else {
 19567  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19568  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 19569  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19570  				yym11 := z.EncBinary()
 19571  				_ = yym11
 19572  				if false {
 19573  				} else {
 19574  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 19575  				}
 19576  			}
 19577  			if yyr2 || yy2arr2 {
 19578  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 19579  				yym13 := z.EncBinary()
 19580  				_ = yym13
 19581  				if false {
 19582  				} else {
 19583  					r.EncodeUint(uint64(x.MinQueryIndex))
 19584  				}
 19585  			} else {
 19586  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19587  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 19588  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19589  				yym14 := z.EncBinary()
 19590  				_ = yym14
 19591  				if false {
 19592  				} else {
 19593  					r.EncodeUint(uint64(x.MinQueryIndex))
 19594  				}
 19595  			}
 19596  			if yyr2 || yy2arr2 {
 19597  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 19598  				yym16 := z.EncBinary()
 19599  				_ = yym16
 19600  				if false {
 19601  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 19602  				} else {
 19603  					r.EncodeInt(int64(x.MaxQueryTime))
 19604  				}
 19605  			} else {
 19606  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19607  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 19608  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19609  				yym17 := z.EncBinary()
 19610  				_ = yym17
 19611  				if false {
 19612  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 19613  				} else {
 19614  					r.EncodeInt(int64(x.MaxQueryTime))
 19615  				}
 19616  			}
 19617  			if yyr2 || yy2arr2 {
 19618  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 19619  				yym19 := z.EncBinary()
 19620  				_ = yym19
 19621  				if false {
 19622  				} else {
 19623  					r.EncodeBool(bool(x.AllowStale))
 19624  				}
 19625  			} else {
 19626  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19627  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 19628  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19629  				yym20 := z.EncBinary()
 19630  				_ = yym20
 19631  				if false {
 19632  				} else {
 19633  					r.EncodeBool(bool(x.AllowStale))
 19634  				}
 19635  			}
 19636  			if yyr2 || yy2arr2 {
 19637  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 19638  				yym22 := z.EncBinary()
 19639  				_ = yym22
 19640  				if false {
 19641  				} else {
 19642  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 19643  				}
 19644  			} else {
 19645  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19646  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 19647  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19648  				yym23 := z.EncBinary()
 19649  				_ = yym23
 19650  				if false {
 19651  				} else {
 19652  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 19653  				}
 19654  			}
 19655  			if yyr2 || yy2arr2 {
 19656  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 19657  				yym25 := z.EncBinary()
 19658  				_ = yym25
 19659  				if false {
 19660  				} else {
 19661  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 19662  				}
 19663  			} else {
 19664  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19665  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 19666  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19667  				yym26 := z.EncBinary()
 19668  				_ = yym26
 19669  				if false {
 19670  				} else {
 19671  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 19672  				}
 19673  			}
 19674  			if yyr2 || yy2arr2 {
 19675  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 19676  				yym28 := z.EncBinary()
 19677  				_ = yym28
 19678  				if false {
 19679  				} else {
 19680  					r.EncodeBool(bool(x.Forwarded))
 19681  				}
 19682  			} else {
 19683  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 19684  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 19685  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 19686  				yym29 := z.EncBinary()
 19687  				_ = yym29
 19688  				if false {
 19689  				} else {
 19690  					r.EncodeBool(bool(x.Forwarded))
 19691  				}
 19692  			}
 19693  			if yyr2 || yy2arr2 {
 19694  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 19695  			} else {
 19696  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 19697  			}
 19698  		}
 19699  	}
 19700  }
 19701  
 19702  func (x *AllocSpecificRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 19703  	var h codecSelfer100
 19704  	z, r := codec1978.GenHelperDecoder(d)
 19705  	_, _, _ = h, z, r
 19706  	yym1 := z.DecBinary()
 19707  	_ = yym1
 19708  	if false {
 19709  	} else if z.HasExtensions() && z.DecExt(x) {
 19710  	} else {
 19711  		yyct2 := r.ContainerType()
 19712  		if yyct2 == codecSelferValueTypeMap100 {
 19713  			yyl2 := r.ReadMapStart()
 19714  			if yyl2 == 0 {
 19715  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 19716  			} else {
 19717  				x.codecDecodeSelfFromMap(yyl2, d)
 19718  			}
 19719  		} else if yyct2 == codecSelferValueTypeArray100 {
 19720  			yyl2 := r.ReadArrayStart()
 19721  			if yyl2 == 0 {
 19722  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19723  			} else {
 19724  				x.codecDecodeSelfFromArray(yyl2, d)
 19725  			}
 19726  		} else {
 19727  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 19728  		}
 19729  	}
 19730  }
 19731  
 19732  func (x *AllocSpecificRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 19733  	var h codecSelfer100
 19734  	z, r := codec1978.GenHelperDecoder(d)
 19735  	_, _, _ = h, z, r
 19736  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 19737  	_ = yys3Slc
 19738  	var yyhl3 bool = l >= 0
 19739  	for yyj3 := 0; ; yyj3++ {
 19740  		if yyhl3 {
 19741  			if yyj3 >= l {
 19742  				break
 19743  			}
 19744  		} else {
 19745  			if r.CheckBreak() {
 19746  				break
 19747  			}
 19748  		}
 19749  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 19750  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 19751  		yys3 := string(yys3Slc)
 19752  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 19753  		switch yys3 {
 19754  		case "AllocID":
 19755  			if r.TryDecodeAsNil() {
 19756  				x.AllocID = ""
 19757  			} else {
 19758  				yyv4 := &x.AllocID
 19759  				yym5 := z.DecBinary()
 19760  				_ = yym5
 19761  				if false {
 19762  				} else {
 19763  					*((*string)(yyv4)) = r.DecodeString()
 19764  				}
 19765  			}
 19766  		case "Region":
 19767  			if r.TryDecodeAsNil() {
 19768  				x.Region = ""
 19769  			} else {
 19770  				yyv6 := &x.Region
 19771  				yym7 := z.DecBinary()
 19772  				_ = yym7
 19773  				if false {
 19774  				} else {
 19775  					*((*string)(yyv6)) = r.DecodeString()
 19776  				}
 19777  			}
 19778  		case "Namespace":
 19779  			if r.TryDecodeAsNil() {
 19780  				x.Namespace = ""
 19781  			} else {
 19782  				yyv8 := &x.Namespace
 19783  				yym9 := z.DecBinary()
 19784  				_ = yym9
 19785  				if false {
 19786  				} else {
 19787  					*((*string)(yyv8)) = r.DecodeString()
 19788  				}
 19789  			}
 19790  		case "MinQueryIndex":
 19791  			if r.TryDecodeAsNil() {
 19792  				x.MinQueryIndex = 0
 19793  			} else {
 19794  				yyv10 := &x.MinQueryIndex
 19795  				yym11 := z.DecBinary()
 19796  				_ = yym11
 19797  				if false {
 19798  				} else {
 19799  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 19800  				}
 19801  			}
 19802  		case "MaxQueryTime":
 19803  			if r.TryDecodeAsNil() {
 19804  				x.MaxQueryTime = 0
 19805  			} else {
 19806  				yyv12 := &x.MaxQueryTime
 19807  				yym13 := z.DecBinary()
 19808  				_ = yym13
 19809  				if false {
 19810  				} else if z.HasExtensions() && z.DecExt(yyv12) {
 19811  				} else {
 19812  					*((*int64)(yyv12)) = int64(r.DecodeInt(64))
 19813  				}
 19814  			}
 19815  		case "AllowStale":
 19816  			if r.TryDecodeAsNil() {
 19817  				x.AllowStale = false
 19818  			} else {
 19819  				yyv14 := &x.AllowStale
 19820  				yym15 := z.DecBinary()
 19821  				_ = yym15
 19822  				if false {
 19823  				} else {
 19824  					*((*bool)(yyv14)) = r.DecodeBool()
 19825  				}
 19826  			}
 19827  		case "Prefix":
 19828  			if r.TryDecodeAsNil() {
 19829  				x.Prefix = ""
 19830  			} else {
 19831  				yyv16 := &x.Prefix
 19832  				yym17 := z.DecBinary()
 19833  				_ = yym17
 19834  				if false {
 19835  				} else {
 19836  					*((*string)(yyv16)) = r.DecodeString()
 19837  				}
 19838  			}
 19839  		case "AuthToken":
 19840  			if r.TryDecodeAsNil() {
 19841  				x.AuthToken = ""
 19842  			} else {
 19843  				yyv18 := &x.AuthToken
 19844  				yym19 := z.DecBinary()
 19845  				_ = yym19
 19846  				if false {
 19847  				} else {
 19848  					*((*string)(yyv18)) = r.DecodeString()
 19849  				}
 19850  			}
 19851  		case "Forwarded":
 19852  			if r.TryDecodeAsNil() {
 19853  				x.Forwarded = false
 19854  			} else {
 19855  				yyv20 := &x.Forwarded
 19856  				yym21 := z.DecBinary()
 19857  				_ = yym21
 19858  				if false {
 19859  				} else {
 19860  					*((*bool)(yyv20)) = r.DecodeBool()
 19861  				}
 19862  			}
 19863  		default:
 19864  			z.DecStructFieldNotFound(-1, yys3)
 19865  		} // end switch yys3
 19866  	} // end for yyj3
 19867  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 19868  }
 19869  
 19870  func (x *AllocSpecificRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 19871  	var h codecSelfer100
 19872  	z, r := codec1978.GenHelperDecoder(d)
 19873  	_, _, _ = h, z, r
 19874  	var yyj22 int
 19875  	var yyb22 bool
 19876  	var yyhl22 bool = l >= 0
 19877  	yyj22++
 19878  	if yyhl22 {
 19879  		yyb22 = yyj22 > l
 19880  	} else {
 19881  		yyb22 = r.CheckBreak()
 19882  	}
 19883  	if yyb22 {
 19884  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19885  		return
 19886  	}
 19887  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 19888  	if r.TryDecodeAsNil() {
 19889  		x.AllocID = ""
 19890  	} else {
 19891  		yyv23 := &x.AllocID
 19892  		yym24 := z.DecBinary()
 19893  		_ = yym24
 19894  		if false {
 19895  		} else {
 19896  			*((*string)(yyv23)) = r.DecodeString()
 19897  		}
 19898  	}
 19899  	yyj22++
 19900  	if yyhl22 {
 19901  		yyb22 = yyj22 > l
 19902  	} else {
 19903  		yyb22 = r.CheckBreak()
 19904  	}
 19905  	if yyb22 {
 19906  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19907  		return
 19908  	}
 19909  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 19910  	if r.TryDecodeAsNil() {
 19911  		x.Region = ""
 19912  	} else {
 19913  		yyv25 := &x.Region
 19914  		yym26 := z.DecBinary()
 19915  		_ = yym26
 19916  		if false {
 19917  		} else {
 19918  			*((*string)(yyv25)) = r.DecodeString()
 19919  		}
 19920  	}
 19921  	yyj22++
 19922  	if yyhl22 {
 19923  		yyb22 = yyj22 > l
 19924  	} else {
 19925  		yyb22 = r.CheckBreak()
 19926  	}
 19927  	if yyb22 {
 19928  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19929  		return
 19930  	}
 19931  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 19932  	if r.TryDecodeAsNil() {
 19933  		x.Namespace = ""
 19934  	} else {
 19935  		yyv27 := &x.Namespace
 19936  		yym28 := z.DecBinary()
 19937  		_ = yym28
 19938  		if false {
 19939  		} else {
 19940  			*((*string)(yyv27)) = r.DecodeString()
 19941  		}
 19942  	}
 19943  	yyj22++
 19944  	if yyhl22 {
 19945  		yyb22 = yyj22 > l
 19946  	} else {
 19947  		yyb22 = r.CheckBreak()
 19948  	}
 19949  	if yyb22 {
 19950  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19951  		return
 19952  	}
 19953  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 19954  	if r.TryDecodeAsNil() {
 19955  		x.MinQueryIndex = 0
 19956  	} else {
 19957  		yyv29 := &x.MinQueryIndex
 19958  		yym30 := z.DecBinary()
 19959  		_ = yym30
 19960  		if false {
 19961  		} else {
 19962  			*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
 19963  		}
 19964  	}
 19965  	yyj22++
 19966  	if yyhl22 {
 19967  		yyb22 = yyj22 > l
 19968  	} else {
 19969  		yyb22 = r.CheckBreak()
 19970  	}
 19971  	if yyb22 {
 19972  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19973  		return
 19974  	}
 19975  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 19976  	if r.TryDecodeAsNil() {
 19977  		x.MaxQueryTime = 0
 19978  	} else {
 19979  		yyv31 := &x.MaxQueryTime
 19980  		yym32 := z.DecBinary()
 19981  		_ = yym32
 19982  		if false {
 19983  		} else if z.HasExtensions() && z.DecExt(yyv31) {
 19984  		} else {
 19985  			*((*int64)(yyv31)) = int64(r.DecodeInt(64))
 19986  		}
 19987  	}
 19988  	yyj22++
 19989  	if yyhl22 {
 19990  		yyb22 = yyj22 > l
 19991  	} else {
 19992  		yyb22 = r.CheckBreak()
 19993  	}
 19994  	if yyb22 {
 19995  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 19996  		return
 19997  	}
 19998  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 19999  	if r.TryDecodeAsNil() {
 20000  		x.AllowStale = false
 20001  	} else {
 20002  		yyv33 := &x.AllowStale
 20003  		yym34 := z.DecBinary()
 20004  		_ = yym34
 20005  		if false {
 20006  		} else {
 20007  			*((*bool)(yyv33)) = r.DecodeBool()
 20008  		}
 20009  	}
 20010  	yyj22++
 20011  	if yyhl22 {
 20012  		yyb22 = yyj22 > l
 20013  	} else {
 20014  		yyb22 = r.CheckBreak()
 20015  	}
 20016  	if yyb22 {
 20017  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20018  		return
 20019  	}
 20020  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20021  	if r.TryDecodeAsNil() {
 20022  		x.Prefix = ""
 20023  	} else {
 20024  		yyv35 := &x.Prefix
 20025  		yym36 := z.DecBinary()
 20026  		_ = yym36
 20027  		if false {
 20028  		} else {
 20029  			*((*string)(yyv35)) = r.DecodeString()
 20030  		}
 20031  	}
 20032  	yyj22++
 20033  	if yyhl22 {
 20034  		yyb22 = yyj22 > l
 20035  	} else {
 20036  		yyb22 = r.CheckBreak()
 20037  	}
 20038  	if yyb22 {
 20039  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20040  		return
 20041  	}
 20042  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20043  	if r.TryDecodeAsNil() {
 20044  		x.AuthToken = ""
 20045  	} else {
 20046  		yyv37 := &x.AuthToken
 20047  		yym38 := z.DecBinary()
 20048  		_ = yym38
 20049  		if false {
 20050  		} else {
 20051  			*((*string)(yyv37)) = r.DecodeString()
 20052  		}
 20053  	}
 20054  	yyj22++
 20055  	if yyhl22 {
 20056  		yyb22 = yyj22 > l
 20057  	} else {
 20058  		yyb22 = r.CheckBreak()
 20059  	}
 20060  	if yyb22 {
 20061  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20062  		return
 20063  	}
 20064  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20065  	if r.TryDecodeAsNil() {
 20066  		x.Forwarded = false
 20067  	} else {
 20068  		yyv39 := &x.Forwarded
 20069  		yym40 := z.DecBinary()
 20070  		_ = yym40
 20071  		if false {
 20072  		} else {
 20073  			*((*bool)(yyv39)) = r.DecodeBool()
 20074  		}
 20075  	}
 20076  	for {
 20077  		yyj22++
 20078  		if yyhl22 {
 20079  			yyb22 = yyj22 > l
 20080  		} else {
 20081  			yyb22 = r.CheckBreak()
 20082  		}
 20083  		if yyb22 {
 20084  			break
 20085  		}
 20086  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20087  		z.DecStructFieldNotFound(yyj22-1, "")
 20088  	}
 20089  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20090  }
 20091  
 20092  func (x *AllocsGetRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 20093  	var h codecSelfer100
 20094  	z, r := codec1978.GenHelperEncoder(e)
 20095  	_, _, _ = h, z, r
 20096  	if x == nil {
 20097  		r.EncodeNil()
 20098  	} else {
 20099  		yym1 := z.EncBinary()
 20100  		_ = yym1
 20101  		if false {
 20102  		} else if z.HasExtensions() && z.EncExt(x) {
 20103  		} else {
 20104  			yysep2 := !z.EncBinary()
 20105  			yy2arr2 := z.EncBasicHandle().StructToArray
 20106  			var yyq2 [9]bool
 20107  			_, _, _ = yysep2, yyq2, yy2arr2
 20108  			const yyr2 bool = false
 20109  			var yynn2 int
 20110  			if yyr2 || yy2arr2 {
 20111  				r.EncodeArrayStart(9)
 20112  			} else {
 20113  				yynn2 = 9
 20114  				for _, b := range yyq2 {
 20115  					if b {
 20116  						yynn2++
 20117  					}
 20118  				}
 20119  				r.EncodeMapStart(yynn2)
 20120  				yynn2 = 0
 20121  			}
 20122  			if yyr2 || yy2arr2 {
 20123  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 20124  				if x.AllocIDs == nil {
 20125  					r.EncodeNil()
 20126  				} else {
 20127  					yym4 := z.EncBinary()
 20128  					_ = yym4
 20129  					if false {
 20130  					} else {
 20131  						z.F.EncSliceStringV(x.AllocIDs, false, e)
 20132  					}
 20133  				}
 20134  			} else {
 20135  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 20136  				r.EncodeString(codecSelferC_UTF8100, string("AllocIDs"))
 20137  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 20138  				if x.AllocIDs == nil {
 20139  					r.EncodeNil()
 20140  				} else {
 20141  					yym5 := z.EncBinary()
 20142  					_ = yym5
 20143  					if false {
 20144  					} else {
 20145  						z.F.EncSliceStringV(x.AllocIDs, false, e)
 20146  					}
 20147  				}
 20148  			}
 20149  			if yyr2 || yy2arr2 {
 20150  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 20151  				yym7 := z.EncBinary()
 20152  				_ = yym7
 20153  				if false {
 20154  				} else {
 20155  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 20156  				}
 20157  			} else {
 20158  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 20159  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 20160  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 20161  				yym8 := z.EncBinary()
 20162  				_ = yym8
 20163  				if false {
 20164  				} else {
 20165  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 20166  				}
 20167  			}
 20168  			if yyr2 || yy2arr2 {
 20169  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 20170  				yym10 := z.EncBinary()
 20171  				_ = yym10
 20172  				if false {
 20173  				} else {
 20174  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 20175  				}
 20176  			} else {
 20177  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 20178  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 20179  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 20180  				yym11 := z.EncBinary()
 20181  				_ = yym11
 20182  				if false {
 20183  				} else {
 20184  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 20185  				}
 20186  			}
 20187  			if yyr2 || yy2arr2 {
 20188  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 20189  				yym13 := z.EncBinary()
 20190  				_ = yym13
 20191  				if false {
 20192  				} else {
 20193  					r.EncodeUint(uint64(x.MinQueryIndex))
 20194  				}
 20195  			} else {
 20196  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 20197  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 20198  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 20199  				yym14 := z.EncBinary()
 20200  				_ = yym14
 20201  				if false {
 20202  				} else {
 20203  					r.EncodeUint(uint64(x.MinQueryIndex))
 20204  				}
 20205  			}
 20206  			if yyr2 || yy2arr2 {
 20207  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 20208  				yym16 := z.EncBinary()
 20209  				_ = yym16
 20210  				if false {
 20211  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 20212  				} else {
 20213  					r.EncodeInt(int64(x.MaxQueryTime))
 20214  				}
 20215  			} else {
 20216  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 20217  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 20218  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 20219  				yym17 := z.EncBinary()
 20220  				_ = yym17
 20221  				if false {
 20222  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 20223  				} else {
 20224  					r.EncodeInt(int64(x.MaxQueryTime))
 20225  				}
 20226  			}
 20227  			if yyr2 || yy2arr2 {
 20228  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 20229  				yym19 := z.EncBinary()
 20230  				_ = yym19
 20231  				if false {
 20232  				} else {
 20233  					r.EncodeBool(bool(x.AllowStale))
 20234  				}
 20235  			} else {
 20236  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 20237  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 20238  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 20239  				yym20 := z.EncBinary()
 20240  				_ = yym20
 20241  				if false {
 20242  				} else {
 20243  					r.EncodeBool(bool(x.AllowStale))
 20244  				}
 20245  			}
 20246  			if yyr2 || yy2arr2 {
 20247  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 20248  				yym22 := z.EncBinary()
 20249  				_ = yym22
 20250  				if false {
 20251  				} else {
 20252  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 20253  				}
 20254  			} else {
 20255  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 20256  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 20257  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 20258  				yym23 := z.EncBinary()
 20259  				_ = yym23
 20260  				if false {
 20261  				} else {
 20262  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 20263  				}
 20264  			}
 20265  			if yyr2 || yy2arr2 {
 20266  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 20267  				yym25 := z.EncBinary()
 20268  				_ = yym25
 20269  				if false {
 20270  				} else {
 20271  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 20272  				}
 20273  			} else {
 20274  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 20275  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 20276  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 20277  				yym26 := z.EncBinary()
 20278  				_ = yym26
 20279  				if false {
 20280  				} else {
 20281  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 20282  				}
 20283  			}
 20284  			if yyr2 || yy2arr2 {
 20285  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 20286  				yym28 := z.EncBinary()
 20287  				_ = yym28
 20288  				if false {
 20289  				} else {
 20290  					r.EncodeBool(bool(x.Forwarded))
 20291  				}
 20292  			} else {
 20293  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 20294  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 20295  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 20296  				yym29 := z.EncBinary()
 20297  				_ = yym29
 20298  				if false {
 20299  				} else {
 20300  					r.EncodeBool(bool(x.Forwarded))
 20301  				}
 20302  			}
 20303  			if yyr2 || yy2arr2 {
 20304  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 20305  			} else {
 20306  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 20307  			}
 20308  		}
 20309  	}
 20310  }
 20311  
 20312  func (x *AllocsGetRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 20313  	var h codecSelfer100
 20314  	z, r := codec1978.GenHelperDecoder(d)
 20315  	_, _, _ = h, z, r
 20316  	yym1 := z.DecBinary()
 20317  	_ = yym1
 20318  	if false {
 20319  	} else if z.HasExtensions() && z.DecExt(x) {
 20320  	} else {
 20321  		yyct2 := r.ContainerType()
 20322  		if yyct2 == codecSelferValueTypeMap100 {
 20323  			yyl2 := r.ReadMapStart()
 20324  			if yyl2 == 0 {
 20325  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 20326  			} else {
 20327  				x.codecDecodeSelfFromMap(yyl2, d)
 20328  			}
 20329  		} else if yyct2 == codecSelferValueTypeArray100 {
 20330  			yyl2 := r.ReadArrayStart()
 20331  			if yyl2 == 0 {
 20332  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20333  			} else {
 20334  				x.codecDecodeSelfFromArray(yyl2, d)
 20335  			}
 20336  		} else {
 20337  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 20338  		}
 20339  	}
 20340  }
 20341  
 20342  func (x *AllocsGetRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 20343  	var h codecSelfer100
 20344  	z, r := codec1978.GenHelperDecoder(d)
 20345  	_, _, _ = h, z, r
 20346  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 20347  	_ = yys3Slc
 20348  	var yyhl3 bool = l >= 0
 20349  	for yyj3 := 0; ; yyj3++ {
 20350  		if yyhl3 {
 20351  			if yyj3 >= l {
 20352  				break
 20353  			}
 20354  		} else {
 20355  			if r.CheckBreak() {
 20356  				break
 20357  			}
 20358  		}
 20359  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 20360  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 20361  		yys3 := string(yys3Slc)
 20362  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 20363  		switch yys3 {
 20364  		case "AllocIDs":
 20365  			if r.TryDecodeAsNil() {
 20366  				x.AllocIDs = nil
 20367  			} else {
 20368  				yyv4 := &x.AllocIDs
 20369  				yym5 := z.DecBinary()
 20370  				_ = yym5
 20371  				if false {
 20372  				} else {
 20373  					z.F.DecSliceStringX(yyv4, false, d)
 20374  				}
 20375  			}
 20376  		case "Region":
 20377  			if r.TryDecodeAsNil() {
 20378  				x.Region = ""
 20379  			} else {
 20380  				yyv6 := &x.Region
 20381  				yym7 := z.DecBinary()
 20382  				_ = yym7
 20383  				if false {
 20384  				} else {
 20385  					*((*string)(yyv6)) = r.DecodeString()
 20386  				}
 20387  			}
 20388  		case "Namespace":
 20389  			if r.TryDecodeAsNil() {
 20390  				x.Namespace = ""
 20391  			} else {
 20392  				yyv8 := &x.Namespace
 20393  				yym9 := z.DecBinary()
 20394  				_ = yym9
 20395  				if false {
 20396  				} else {
 20397  					*((*string)(yyv8)) = r.DecodeString()
 20398  				}
 20399  			}
 20400  		case "MinQueryIndex":
 20401  			if r.TryDecodeAsNil() {
 20402  				x.MinQueryIndex = 0
 20403  			} else {
 20404  				yyv10 := &x.MinQueryIndex
 20405  				yym11 := z.DecBinary()
 20406  				_ = yym11
 20407  				if false {
 20408  				} else {
 20409  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 20410  				}
 20411  			}
 20412  		case "MaxQueryTime":
 20413  			if r.TryDecodeAsNil() {
 20414  				x.MaxQueryTime = 0
 20415  			} else {
 20416  				yyv12 := &x.MaxQueryTime
 20417  				yym13 := z.DecBinary()
 20418  				_ = yym13
 20419  				if false {
 20420  				} else if z.HasExtensions() && z.DecExt(yyv12) {
 20421  				} else {
 20422  					*((*int64)(yyv12)) = int64(r.DecodeInt(64))
 20423  				}
 20424  			}
 20425  		case "AllowStale":
 20426  			if r.TryDecodeAsNil() {
 20427  				x.AllowStale = false
 20428  			} else {
 20429  				yyv14 := &x.AllowStale
 20430  				yym15 := z.DecBinary()
 20431  				_ = yym15
 20432  				if false {
 20433  				} else {
 20434  					*((*bool)(yyv14)) = r.DecodeBool()
 20435  				}
 20436  			}
 20437  		case "Prefix":
 20438  			if r.TryDecodeAsNil() {
 20439  				x.Prefix = ""
 20440  			} else {
 20441  				yyv16 := &x.Prefix
 20442  				yym17 := z.DecBinary()
 20443  				_ = yym17
 20444  				if false {
 20445  				} else {
 20446  					*((*string)(yyv16)) = r.DecodeString()
 20447  				}
 20448  			}
 20449  		case "AuthToken":
 20450  			if r.TryDecodeAsNil() {
 20451  				x.AuthToken = ""
 20452  			} else {
 20453  				yyv18 := &x.AuthToken
 20454  				yym19 := z.DecBinary()
 20455  				_ = yym19
 20456  				if false {
 20457  				} else {
 20458  					*((*string)(yyv18)) = r.DecodeString()
 20459  				}
 20460  			}
 20461  		case "Forwarded":
 20462  			if r.TryDecodeAsNil() {
 20463  				x.Forwarded = false
 20464  			} else {
 20465  				yyv20 := &x.Forwarded
 20466  				yym21 := z.DecBinary()
 20467  				_ = yym21
 20468  				if false {
 20469  				} else {
 20470  					*((*bool)(yyv20)) = r.DecodeBool()
 20471  				}
 20472  			}
 20473  		default:
 20474  			z.DecStructFieldNotFound(-1, yys3)
 20475  		} // end switch yys3
 20476  	} // end for yyj3
 20477  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 20478  }
 20479  
 20480  func (x *AllocsGetRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 20481  	var h codecSelfer100
 20482  	z, r := codec1978.GenHelperDecoder(d)
 20483  	_, _, _ = h, z, r
 20484  	var yyj22 int
 20485  	var yyb22 bool
 20486  	var yyhl22 bool = l >= 0
 20487  	yyj22++
 20488  	if yyhl22 {
 20489  		yyb22 = yyj22 > l
 20490  	} else {
 20491  		yyb22 = r.CheckBreak()
 20492  	}
 20493  	if yyb22 {
 20494  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20495  		return
 20496  	}
 20497  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20498  	if r.TryDecodeAsNil() {
 20499  		x.AllocIDs = nil
 20500  	} else {
 20501  		yyv23 := &x.AllocIDs
 20502  		yym24 := z.DecBinary()
 20503  		_ = yym24
 20504  		if false {
 20505  		} else {
 20506  			z.F.DecSliceStringX(yyv23, false, d)
 20507  		}
 20508  	}
 20509  	yyj22++
 20510  	if yyhl22 {
 20511  		yyb22 = yyj22 > l
 20512  	} else {
 20513  		yyb22 = r.CheckBreak()
 20514  	}
 20515  	if yyb22 {
 20516  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20517  		return
 20518  	}
 20519  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20520  	if r.TryDecodeAsNil() {
 20521  		x.Region = ""
 20522  	} else {
 20523  		yyv25 := &x.Region
 20524  		yym26 := z.DecBinary()
 20525  		_ = yym26
 20526  		if false {
 20527  		} else {
 20528  			*((*string)(yyv25)) = r.DecodeString()
 20529  		}
 20530  	}
 20531  	yyj22++
 20532  	if yyhl22 {
 20533  		yyb22 = yyj22 > l
 20534  	} else {
 20535  		yyb22 = r.CheckBreak()
 20536  	}
 20537  	if yyb22 {
 20538  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20539  		return
 20540  	}
 20541  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20542  	if r.TryDecodeAsNil() {
 20543  		x.Namespace = ""
 20544  	} else {
 20545  		yyv27 := &x.Namespace
 20546  		yym28 := z.DecBinary()
 20547  		_ = yym28
 20548  		if false {
 20549  		} else {
 20550  			*((*string)(yyv27)) = r.DecodeString()
 20551  		}
 20552  	}
 20553  	yyj22++
 20554  	if yyhl22 {
 20555  		yyb22 = yyj22 > l
 20556  	} else {
 20557  		yyb22 = r.CheckBreak()
 20558  	}
 20559  	if yyb22 {
 20560  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20561  		return
 20562  	}
 20563  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20564  	if r.TryDecodeAsNil() {
 20565  		x.MinQueryIndex = 0
 20566  	} else {
 20567  		yyv29 := &x.MinQueryIndex
 20568  		yym30 := z.DecBinary()
 20569  		_ = yym30
 20570  		if false {
 20571  		} else {
 20572  			*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
 20573  		}
 20574  	}
 20575  	yyj22++
 20576  	if yyhl22 {
 20577  		yyb22 = yyj22 > l
 20578  	} else {
 20579  		yyb22 = r.CheckBreak()
 20580  	}
 20581  	if yyb22 {
 20582  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20583  		return
 20584  	}
 20585  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20586  	if r.TryDecodeAsNil() {
 20587  		x.MaxQueryTime = 0
 20588  	} else {
 20589  		yyv31 := &x.MaxQueryTime
 20590  		yym32 := z.DecBinary()
 20591  		_ = yym32
 20592  		if false {
 20593  		} else if z.HasExtensions() && z.DecExt(yyv31) {
 20594  		} else {
 20595  			*((*int64)(yyv31)) = int64(r.DecodeInt(64))
 20596  		}
 20597  	}
 20598  	yyj22++
 20599  	if yyhl22 {
 20600  		yyb22 = yyj22 > l
 20601  	} else {
 20602  		yyb22 = r.CheckBreak()
 20603  	}
 20604  	if yyb22 {
 20605  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20606  		return
 20607  	}
 20608  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20609  	if r.TryDecodeAsNil() {
 20610  		x.AllowStale = false
 20611  	} else {
 20612  		yyv33 := &x.AllowStale
 20613  		yym34 := z.DecBinary()
 20614  		_ = yym34
 20615  		if false {
 20616  		} else {
 20617  			*((*bool)(yyv33)) = r.DecodeBool()
 20618  		}
 20619  	}
 20620  	yyj22++
 20621  	if yyhl22 {
 20622  		yyb22 = yyj22 > l
 20623  	} else {
 20624  		yyb22 = r.CheckBreak()
 20625  	}
 20626  	if yyb22 {
 20627  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20628  		return
 20629  	}
 20630  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20631  	if r.TryDecodeAsNil() {
 20632  		x.Prefix = ""
 20633  	} else {
 20634  		yyv35 := &x.Prefix
 20635  		yym36 := z.DecBinary()
 20636  		_ = yym36
 20637  		if false {
 20638  		} else {
 20639  			*((*string)(yyv35)) = r.DecodeString()
 20640  		}
 20641  	}
 20642  	yyj22++
 20643  	if yyhl22 {
 20644  		yyb22 = yyj22 > l
 20645  	} else {
 20646  		yyb22 = r.CheckBreak()
 20647  	}
 20648  	if yyb22 {
 20649  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20650  		return
 20651  	}
 20652  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20653  	if r.TryDecodeAsNil() {
 20654  		x.AuthToken = ""
 20655  	} else {
 20656  		yyv37 := &x.AuthToken
 20657  		yym38 := z.DecBinary()
 20658  		_ = yym38
 20659  		if false {
 20660  		} else {
 20661  			*((*string)(yyv37)) = r.DecodeString()
 20662  		}
 20663  	}
 20664  	yyj22++
 20665  	if yyhl22 {
 20666  		yyb22 = yyj22 > l
 20667  	} else {
 20668  		yyb22 = r.CheckBreak()
 20669  	}
 20670  	if yyb22 {
 20671  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20672  		return
 20673  	}
 20674  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20675  	if r.TryDecodeAsNil() {
 20676  		x.Forwarded = false
 20677  	} else {
 20678  		yyv39 := &x.Forwarded
 20679  		yym40 := z.DecBinary()
 20680  		_ = yym40
 20681  		if false {
 20682  		} else {
 20683  			*((*bool)(yyv39)) = r.DecodeBool()
 20684  		}
 20685  	}
 20686  	for {
 20687  		yyj22++
 20688  		if yyhl22 {
 20689  			yyb22 = yyj22 > l
 20690  		} else {
 20691  			yyb22 = r.CheckBreak()
 20692  		}
 20693  		if yyb22 {
 20694  			break
 20695  		}
 20696  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20697  		z.DecStructFieldNotFound(yyj22-1, "")
 20698  	}
 20699  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20700  }
 20701  
 20702  func (x *PeriodicForceRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 20703  	var h codecSelfer100
 20704  	z, r := codec1978.GenHelperEncoder(e)
 20705  	_, _, _ = h, z, r
 20706  	if x == nil {
 20707  		r.EncodeNil()
 20708  	} else {
 20709  		yym1 := z.EncBinary()
 20710  		_ = yym1
 20711  		if false {
 20712  		} else if z.HasExtensions() && z.EncExt(x) {
 20713  		} else {
 20714  			yysep2 := !z.EncBinary()
 20715  			yy2arr2 := z.EncBasicHandle().StructToArray
 20716  			var yyq2 [5]bool
 20717  			_, _, _ = yysep2, yyq2, yy2arr2
 20718  			const yyr2 bool = false
 20719  			var yynn2 int
 20720  			if yyr2 || yy2arr2 {
 20721  				r.EncodeArrayStart(5)
 20722  			} else {
 20723  				yynn2 = 5
 20724  				for _, b := range yyq2 {
 20725  					if b {
 20726  						yynn2++
 20727  					}
 20728  				}
 20729  				r.EncodeMapStart(yynn2)
 20730  				yynn2 = 0
 20731  			}
 20732  			if yyr2 || yy2arr2 {
 20733  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 20734  				yym4 := z.EncBinary()
 20735  				_ = yym4
 20736  				if false {
 20737  				} else {
 20738  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 20739  				}
 20740  			} else {
 20741  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 20742  				r.EncodeString(codecSelferC_UTF8100, string("JobID"))
 20743  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 20744  				yym5 := z.EncBinary()
 20745  				_ = yym5
 20746  				if false {
 20747  				} else {
 20748  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 20749  				}
 20750  			}
 20751  			if yyr2 || yy2arr2 {
 20752  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 20753  				yym7 := z.EncBinary()
 20754  				_ = yym7
 20755  				if false {
 20756  				} else {
 20757  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 20758  				}
 20759  			} else {
 20760  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 20761  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 20762  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 20763  				yym8 := z.EncBinary()
 20764  				_ = yym8
 20765  				if false {
 20766  				} else {
 20767  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 20768  				}
 20769  			}
 20770  			if yyr2 || yy2arr2 {
 20771  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 20772  				yym10 := z.EncBinary()
 20773  				_ = yym10
 20774  				if false {
 20775  				} else {
 20776  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 20777  				}
 20778  			} else {
 20779  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 20780  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 20781  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 20782  				yym11 := z.EncBinary()
 20783  				_ = yym11
 20784  				if false {
 20785  				} else {
 20786  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 20787  				}
 20788  			}
 20789  			if yyr2 || yy2arr2 {
 20790  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 20791  				yym13 := z.EncBinary()
 20792  				_ = yym13
 20793  				if false {
 20794  				} else {
 20795  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 20796  				}
 20797  			} else {
 20798  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 20799  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 20800  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 20801  				yym14 := z.EncBinary()
 20802  				_ = yym14
 20803  				if false {
 20804  				} else {
 20805  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 20806  				}
 20807  			}
 20808  			if yyr2 || yy2arr2 {
 20809  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 20810  				yym16 := z.EncBinary()
 20811  				_ = yym16
 20812  				if false {
 20813  				} else {
 20814  					r.EncodeBool(bool(x.Forwarded))
 20815  				}
 20816  			} else {
 20817  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 20818  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 20819  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 20820  				yym17 := z.EncBinary()
 20821  				_ = yym17
 20822  				if false {
 20823  				} else {
 20824  					r.EncodeBool(bool(x.Forwarded))
 20825  				}
 20826  			}
 20827  			if yyr2 || yy2arr2 {
 20828  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 20829  			} else {
 20830  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 20831  			}
 20832  		}
 20833  	}
 20834  }
 20835  
 20836  func (x *PeriodicForceRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 20837  	var h codecSelfer100
 20838  	z, r := codec1978.GenHelperDecoder(d)
 20839  	_, _, _ = h, z, r
 20840  	yym1 := z.DecBinary()
 20841  	_ = yym1
 20842  	if false {
 20843  	} else if z.HasExtensions() && z.DecExt(x) {
 20844  	} else {
 20845  		yyct2 := r.ContainerType()
 20846  		if yyct2 == codecSelferValueTypeMap100 {
 20847  			yyl2 := r.ReadMapStart()
 20848  			if yyl2 == 0 {
 20849  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 20850  			} else {
 20851  				x.codecDecodeSelfFromMap(yyl2, d)
 20852  			}
 20853  		} else if yyct2 == codecSelferValueTypeArray100 {
 20854  			yyl2 := r.ReadArrayStart()
 20855  			if yyl2 == 0 {
 20856  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20857  			} else {
 20858  				x.codecDecodeSelfFromArray(yyl2, d)
 20859  			}
 20860  		} else {
 20861  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 20862  		}
 20863  	}
 20864  }
 20865  
 20866  func (x *PeriodicForceRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 20867  	var h codecSelfer100
 20868  	z, r := codec1978.GenHelperDecoder(d)
 20869  	_, _, _ = h, z, r
 20870  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 20871  	_ = yys3Slc
 20872  	var yyhl3 bool = l >= 0
 20873  	for yyj3 := 0; ; yyj3++ {
 20874  		if yyhl3 {
 20875  			if yyj3 >= l {
 20876  				break
 20877  			}
 20878  		} else {
 20879  			if r.CheckBreak() {
 20880  				break
 20881  			}
 20882  		}
 20883  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 20884  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 20885  		yys3 := string(yys3Slc)
 20886  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 20887  		switch yys3 {
 20888  		case "JobID":
 20889  			if r.TryDecodeAsNil() {
 20890  				x.JobID = ""
 20891  			} else {
 20892  				yyv4 := &x.JobID
 20893  				yym5 := z.DecBinary()
 20894  				_ = yym5
 20895  				if false {
 20896  				} else {
 20897  					*((*string)(yyv4)) = r.DecodeString()
 20898  				}
 20899  			}
 20900  		case "Region":
 20901  			if r.TryDecodeAsNil() {
 20902  				x.Region = ""
 20903  			} else {
 20904  				yyv6 := &x.Region
 20905  				yym7 := z.DecBinary()
 20906  				_ = yym7
 20907  				if false {
 20908  				} else {
 20909  					*((*string)(yyv6)) = r.DecodeString()
 20910  				}
 20911  			}
 20912  		case "Namespace":
 20913  			if r.TryDecodeAsNil() {
 20914  				x.Namespace = ""
 20915  			} else {
 20916  				yyv8 := &x.Namespace
 20917  				yym9 := z.DecBinary()
 20918  				_ = yym9
 20919  				if false {
 20920  				} else {
 20921  					*((*string)(yyv8)) = r.DecodeString()
 20922  				}
 20923  			}
 20924  		case "AuthToken":
 20925  			if r.TryDecodeAsNil() {
 20926  				x.AuthToken = ""
 20927  			} else {
 20928  				yyv10 := &x.AuthToken
 20929  				yym11 := z.DecBinary()
 20930  				_ = yym11
 20931  				if false {
 20932  				} else {
 20933  					*((*string)(yyv10)) = r.DecodeString()
 20934  				}
 20935  			}
 20936  		case "Forwarded":
 20937  			if r.TryDecodeAsNil() {
 20938  				x.Forwarded = false
 20939  			} else {
 20940  				yyv12 := &x.Forwarded
 20941  				yym13 := z.DecBinary()
 20942  				_ = yym13
 20943  				if false {
 20944  				} else {
 20945  					*((*bool)(yyv12)) = r.DecodeBool()
 20946  				}
 20947  			}
 20948  		default:
 20949  			z.DecStructFieldNotFound(-1, yys3)
 20950  		} // end switch yys3
 20951  	} // end for yyj3
 20952  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 20953  }
 20954  
 20955  func (x *PeriodicForceRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 20956  	var h codecSelfer100
 20957  	z, r := codec1978.GenHelperDecoder(d)
 20958  	_, _, _ = h, z, r
 20959  	var yyj14 int
 20960  	var yyb14 bool
 20961  	var yyhl14 bool = l >= 0
 20962  	yyj14++
 20963  	if yyhl14 {
 20964  		yyb14 = yyj14 > l
 20965  	} else {
 20966  		yyb14 = r.CheckBreak()
 20967  	}
 20968  	if yyb14 {
 20969  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20970  		return
 20971  	}
 20972  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20973  	if r.TryDecodeAsNil() {
 20974  		x.JobID = ""
 20975  	} else {
 20976  		yyv15 := &x.JobID
 20977  		yym16 := z.DecBinary()
 20978  		_ = yym16
 20979  		if false {
 20980  		} else {
 20981  			*((*string)(yyv15)) = r.DecodeString()
 20982  		}
 20983  	}
 20984  	yyj14++
 20985  	if yyhl14 {
 20986  		yyb14 = yyj14 > l
 20987  	} else {
 20988  		yyb14 = r.CheckBreak()
 20989  	}
 20990  	if yyb14 {
 20991  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 20992  		return
 20993  	}
 20994  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 20995  	if r.TryDecodeAsNil() {
 20996  		x.Region = ""
 20997  	} else {
 20998  		yyv17 := &x.Region
 20999  		yym18 := z.DecBinary()
 21000  		_ = yym18
 21001  		if false {
 21002  		} else {
 21003  			*((*string)(yyv17)) = r.DecodeString()
 21004  		}
 21005  	}
 21006  	yyj14++
 21007  	if yyhl14 {
 21008  		yyb14 = yyj14 > l
 21009  	} else {
 21010  		yyb14 = r.CheckBreak()
 21011  	}
 21012  	if yyb14 {
 21013  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21014  		return
 21015  	}
 21016  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 21017  	if r.TryDecodeAsNil() {
 21018  		x.Namespace = ""
 21019  	} else {
 21020  		yyv19 := &x.Namespace
 21021  		yym20 := z.DecBinary()
 21022  		_ = yym20
 21023  		if false {
 21024  		} else {
 21025  			*((*string)(yyv19)) = r.DecodeString()
 21026  		}
 21027  	}
 21028  	yyj14++
 21029  	if yyhl14 {
 21030  		yyb14 = yyj14 > l
 21031  	} else {
 21032  		yyb14 = r.CheckBreak()
 21033  	}
 21034  	if yyb14 {
 21035  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21036  		return
 21037  	}
 21038  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 21039  	if r.TryDecodeAsNil() {
 21040  		x.AuthToken = ""
 21041  	} else {
 21042  		yyv21 := &x.AuthToken
 21043  		yym22 := z.DecBinary()
 21044  		_ = yym22
 21045  		if false {
 21046  		} else {
 21047  			*((*string)(yyv21)) = r.DecodeString()
 21048  		}
 21049  	}
 21050  	yyj14++
 21051  	if yyhl14 {
 21052  		yyb14 = yyj14 > l
 21053  	} else {
 21054  		yyb14 = r.CheckBreak()
 21055  	}
 21056  	if yyb14 {
 21057  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21058  		return
 21059  	}
 21060  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 21061  	if r.TryDecodeAsNil() {
 21062  		x.Forwarded = false
 21063  	} else {
 21064  		yyv23 := &x.Forwarded
 21065  		yym24 := z.DecBinary()
 21066  		_ = yym24
 21067  		if false {
 21068  		} else {
 21069  			*((*bool)(yyv23)) = r.DecodeBool()
 21070  		}
 21071  	}
 21072  	for {
 21073  		yyj14++
 21074  		if yyhl14 {
 21075  			yyb14 = yyj14 > l
 21076  		} else {
 21077  			yyb14 = r.CheckBreak()
 21078  		}
 21079  		if yyb14 {
 21080  			break
 21081  		}
 21082  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 21083  		z.DecStructFieldNotFound(yyj14-1, "")
 21084  	}
 21085  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21086  }
 21087  
 21088  func (x *ServerMembersResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 21089  	var h codecSelfer100
 21090  	z, r := codec1978.GenHelperEncoder(e)
 21091  	_, _, _ = h, z, r
 21092  	if x == nil {
 21093  		r.EncodeNil()
 21094  	} else {
 21095  		yym1 := z.EncBinary()
 21096  		_ = yym1
 21097  		if false {
 21098  		} else if z.HasExtensions() && z.EncExt(x) {
 21099  		} else {
 21100  			yysep2 := !z.EncBinary()
 21101  			yy2arr2 := z.EncBasicHandle().StructToArray
 21102  			var yyq2 [4]bool
 21103  			_, _, _ = yysep2, yyq2, yy2arr2
 21104  			const yyr2 bool = false
 21105  			var yynn2 int
 21106  			if yyr2 || yy2arr2 {
 21107  				r.EncodeArrayStart(4)
 21108  			} else {
 21109  				yynn2 = 4
 21110  				for _, b := range yyq2 {
 21111  					if b {
 21112  						yynn2++
 21113  					}
 21114  				}
 21115  				r.EncodeMapStart(yynn2)
 21116  				yynn2 = 0
 21117  			}
 21118  			if yyr2 || yy2arr2 {
 21119  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 21120  				yym4 := z.EncBinary()
 21121  				_ = yym4
 21122  				if false {
 21123  				} else {
 21124  					r.EncodeString(codecSelferC_UTF8100, string(x.ServerName))
 21125  				}
 21126  			} else {
 21127  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 21128  				r.EncodeString(codecSelferC_UTF8100, string("ServerName"))
 21129  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 21130  				yym5 := z.EncBinary()
 21131  				_ = yym5
 21132  				if false {
 21133  				} else {
 21134  					r.EncodeString(codecSelferC_UTF8100, string(x.ServerName))
 21135  				}
 21136  			}
 21137  			if yyr2 || yy2arr2 {
 21138  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 21139  				yym7 := z.EncBinary()
 21140  				_ = yym7
 21141  				if false {
 21142  				} else {
 21143  					r.EncodeString(codecSelferC_UTF8100, string(x.ServerRegion))
 21144  				}
 21145  			} else {
 21146  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 21147  				r.EncodeString(codecSelferC_UTF8100, string("ServerRegion"))
 21148  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 21149  				yym8 := z.EncBinary()
 21150  				_ = yym8
 21151  				if false {
 21152  				} else {
 21153  					r.EncodeString(codecSelferC_UTF8100, string(x.ServerRegion))
 21154  				}
 21155  			}
 21156  			if yyr2 || yy2arr2 {
 21157  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 21158  				yym10 := z.EncBinary()
 21159  				_ = yym10
 21160  				if false {
 21161  				} else {
 21162  					r.EncodeString(codecSelferC_UTF8100, string(x.ServerDC))
 21163  				}
 21164  			} else {
 21165  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 21166  				r.EncodeString(codecSelferC_UTF8100, string("ServerDC"))
 21167  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 21168  				yym11 := z.EncBinary()
 21169  				_ = yym11
 21170  				if false {
 21171  				} else {
 21172  					r.EncodeString(codecSelferC_UTF8100, string(x.ServerDC))
 21173  				}
 21174  			}
 21175  			if yyr2 || yy2arr2 {
 21176  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 21177  				if x.Members == nil {
 21178  					r.EncodeNil()
 21179  				} else {
 21180  					yym13 := z.EncBinary()
 21181  					_ = yym13
 21182  					if false {
 21183  					} else {
 21184  						h.encSlicePtrtoServerMember(([]*ServerMember)(x.Members), e)
 21185  					}
 21186  				}
 21187  			} else {
 21188  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 21189  				r.EncodeString(codecSelferC_UTF8100, string("Members"))
 21190  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 21191  				if x.Members == nil {
 21192  					r.EncodeNil()
 21193  				} else {
 21194  					yym14 := z.EncBinary()
 21195  					_ = yym14
 21196  					if false {
 21197  					} else {
 21198  						h.encSlicePtrtoServerMember(([]*ServerMember)(x.Members), e)
 21199  					}
 21200  				}
 21201  			}
 21202  			if yyr2 || yy2arr2 {
 21203  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 21204  			} else {
 21205  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 21206  			}
 21207  		}
 21208  	}
 21209  }
 21210  
 21211  func (x *ServerMembersResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 21212  	var h codecSelfer100
 21213  	z, r := codec1978.GenHelperDecoder(d)
 21214  	_, _, _ = h, z, r
 21215  	yym1 := z.DecBinary()
 21216  	_ = yym1
 21217  	if false {
 21218  	} else if z.HasExtensions() && z.DecExt(x) {
 21219  	} else {
 21220  		yyct2 := r.ContainerType()
 21221  		if yyct2 == codecSelferValueTypeMap100 {
 21222  			yyl2 := r.ReadMapStart()
 21223  			if yyl2 == 0 {
 21224  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 21225  			} else {
 21226  				x.codecDecodeSelfFromMap(yyl2, d)
 21227  			}
 21228  		} else if yyct2 == codecSelferValueTypeArray100 {
 21229  			yyl2 := r.ReadArrayStart()
 21230  			if yyl2 == 0 {
 21231  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21232  			} else {
 21233  				x.codecDecodeSelfFromArray(yyl2, d)
 21234  			}
 21235  		} else {
 21236  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 21237  		}
 21238  	}
 21239  }
 21240  
 21241  func (x *ServerMembersResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 21242  	var h codecSelfer100
 21243  	z, r := codec1978.GenHelperDecoder(d)
 21244  	_, _, _ = h, z, r
 21245  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 21246  	_ = yys3Slc
 21247  	var yyhl3 bool = l >= 0
 21248  	for yyj3 := 0; ; yyj3++ {
 21249  		if yyhl3 {
 21250  			if yyj3 >= l {
 21251  				break
 21252  			}
 21253  		} else {
 21254  			if r.CheckBreak() {
 21255  				break
 21256  			}
 21257  		}
 21258  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 21259  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 21260  		yys3 := string(yys3Slc)
 21261  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 21262  		switch yys3 {
 21263  		case "ServerName":
 21264  			if r.TryDecodeAsNil() {
 21265  				x.ServerName = ""
 21266  			} else {
 21267  				yyv4 := &x.ServerName
 21268  				yym5 := z.DecBinary()
 21269  				_ = yym5
 21270  				if false {
 21271  				} else {
 21272  					*((*string)(yyv4)) = r.DecodeString()
 21273  				}
 21274  			}
 21275  		case "ServerRegion":
 21276  			if r.TryDecodeAsNil() {
 21277  				x.ServerRegion = ""
 21278  			} else {
 21279  				yyv6 := &x.ServerRegion
 21280  				yym7 := z.DecBinary()
 21281  				_ = yym7
 21282  				if false {
 21283  				} else {
 21284  					*((*string)(yyv6)) = r.DecodeString()
 21285  				}
 21286  			}
 21287  		case "ServerDC":
 21288  			if r.TryDecodeAsNil() {
 21289  				x.ServerDC = ""
 21290  			} else {
 21291  				yyv8 := &x.ServerDC
 21292  				yym9 := z.DecBinary()
 21293  				_ = yym9
 21294  				if false {
 21295  				} else {
 21296  					*((*string)(yyv8)) = r.DecodeString()
 21297  				}
 21298  			}
 21299  		case "Members":
 21300  			if r.TryDecodeAsNil() {
 21301  				x.Members = nil
 21302  			} else {
 21303  				yyv10 := &x.Members
 21304  				yym11 := z.DecBinary()
 21305  				_ = yym11
 21306  				if false {
 21307  				} else {
 21308  					h.decSlicePtrtoServerMember((*[]*ServerMember)(yyv10), d)
 21309  				}
 21310  			}
 21311  		default:
 21312  			z.DecStructFieldNotFound(-1, yys3)
 21313  		} // end switch yys3
 21314  	} // end for yyj3
 21315  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 21316  }
 21317  
 21318  func (x *ServerMembersResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 21319  	var h codecSelfer100
 21320  	z, r := codec1978.GenHelperDecoder(d)
 21321  	_, _, _ = h, z, r
 21322  	var yyj12 int
 21323  	var yyb12 bool
 21324  	var yyhl12 bool = l >= 0
 21325  	yyj12++
 21326  	if yyhl12 {
 21327  		yyb12 = yyj12 > l
 21328  	} else {
 21329  		yyb12 = r.CheckBreak()
 21330  	}
 21331  	if yyb12 {
 21332  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21333  		return
 21334  	}
 21335  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 21336  	if r.TryDecodeAsNil() {
 21337  		x.ServerName = ""
 21338  	} else {
 21339  		yyv13 := &x.ServerName
 21340  		yym14 := z.DecBinary()
 21341  		_ = yym14
 21342  		if false {
 21343  		} else {
 21344  			*((*string)(yyv13)) = r.DecodeString()
 21345  		}
 21346  	}
 21347  	yyj12++
 21348  	if yyhl12 {
 21349  		yyb12 = yyj12 > l
 21350  	} else {
 21351  		yyb12 = r.CheckBreak()
 21352  	}
 21353  	if yyb12 {
 21354  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21355  		return
 21356  	}
 21357  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 21358  	if r.TryDecodeAsNil() {
 21359  		x.ServerRegion = ""
 21360  	} else {
 21361  		yyv15 := &x.ServerRegion
 21362  		yym16 := z.DecBinary()
 21363  		_ = yym16
 21364  		if false {
 21365  		} else {
 21366  			*((*string)(yyv15)) = r.DecodeString()
 21367  		}
 21368  	}
 21369  	yyj12++
 21370  	if yyhl12 {
 21371  		yyb12 = yyj12 > l
 21372  	} else {
 21373  		yyb12 = r.CheckBreak()
 21374  	}
 21375  	if yyb12 {
 21376  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21377  		return
 21378  	}
 21379  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 21380  	if r.TryDecodeAsNil() {
 21381  		x.ServerDC = ""
 21382  	} else {
 21383  		yyv17 := &x.ServerDC
 21384  		yym18 := z.DecBinary()
 21385  		_ = yym18
 21386  		if false {
 21387  		} else {
 21388  			*((*string)(yyv17)) = r.DecodeString()
 21389  		}
 21390  	}
 21391  	yyj12++
 21392  	if yyhl12 {
 21393  		yyb12 = yyj12 > l
 21394  	} else {
 21395  		yyb12 = r.CheckBreak()
 21396  	}
 21397  	if yyb12 {
 21398  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21399  		return
 21400  	}
 21401  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 21402  	if r.TryDecodeAsNil() {
 21403  		x.Members = nil
 21404  	} else {
 21405  		yyv19 := &x.Members
 21406  		yym20 := z.DecBinary()
 21407  		_ = yym20
 21408  		if false {
 21409  		} else {
 21410  			h.decSlicePtrtoServerMember((*[]*ServerMember)(yyv19), d)
 21411  		}
 21412  	}
 21413  	for {
 21414  		yyj12++
 21415  		if yyhl12 {
 21416  			yyb12 = yyj12 > l
 21417  		} else {
 21418  			yyb12 = r.CheckBreak()
 21419  		}
 21420  		if yyb12 {
 21421  			break
 21422  		}
 21423  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 21424  		z.DecStructFieldNotFound(yyj12-1, "")
 21425  	}
 21426  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21427  }
 21428  
 21429  func (x *ServerMember) CodecEncodeSelf(e *codec1978.Encoder) {
 21430  	var h codecSelfer100
 21431  	z, r := codec1978.GenHelperEncoder(e)
 21432  	_, _, _ = h, z, r
 21433  	if x == nil {
 21434  		r.EncodeNil()
 21435  	} else {
 21436  		yym1 := z.EncBinary()
 21437  		_ = yym1
 21438  		if false {
 21439  		} else if z.HasExtensions() && z.EncExt(x) {
 21440  		} else {
 21441  			yysep2 := !z.EncBinary()
 21442  			yy2arr2 := z.EncBasicHandle().StructToArray
 21443  			var yyq2 [11]bool
 21444  			_, _, _ = yysep2, yyq2, yy2arr2
 21445  			const yyr2 bool = false
 21446  			var yynn2 int
 21447  			if yyr2 || yy2arr2 {
 21448  				r.EncodeArrayStart(11)
 21449  			} else {
 21450  				yynn2 = 11
 21451  				for _, b := range yyq2 {
 21452  					if b {
 21453  						yynn2++
 21454  					}
 21455  				}
 21456  				r.EncodeMapStart(yynn2)
 21457  				yynn2 = 0
 21458  			}
 21459  			if yyr2 || yy2arr2 {
 21460  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 21461  				yym4 := z.EncBinary()
 21462  				_ = yym4
 21463  				if false {
 21464  				} else {
 21465  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 21466  				}
 21467  			} else {
 21468  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 21469  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 21470  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 21471  				yym5 := z.EncBinary()
 21472  				_ = yym5
 21473  				if false {
 21474  				} else {
 21475  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 21476  				}
 21477  			}
 21478  			if yyr2 || yy2arr2 {
 21479  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 21480  				if x.Addr == nil {
 21481  					r.EncodeNil()
 21482  				} else {
 21483  					yym7 := z.EncBinary()
 21484  					_ = yym7
 21485  					if false {
 21486  					} else if z.HasExtensions() && z.EncExt(x.Addr) {
 21487  					} else if !yym7 {
 21488  						z.EncTextMarshal(x.Addr)
 21489  					} else {
 21490  						h.encnet_IP((net.IP)(x.Addr), e)
 21491  					}
 21492  				}
 21493  			} else {
 21494  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 21495  				r.EncodeString(codecSelferC_UTF8100, string("Addr"))
 21496  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 21497  				if x.Addr == nil {
 21498  					r.EncodeNil()
 21499  				} else {
 21500  					yym8 := z.EncBinary()
 21501  					_ = yym8
 21502  					if false {
 21503  					} else if z.HasExtensions() && z.EncExt(x.Addr) {
 21504  					} else if !yym8 {
 21505  						z.EncTextMarshal(x.Addr)
 21506  					} else {
 21507  						h.encnet_IP((net.IP)(x.Addr), e)
 21508  					}
 21509  				}
 21510  			}
 21511  			if yyr2 || yy2arr2 {
 21512  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 21513  				yym10 := z.EncBinary()
 21514  				_ = yym10
 21515  				if false {
 21516  				} else {
 21517  					r.EncodeUint(uint64(x.Port))
 21518  				}
 21519  			} else {
 21520  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 21521  				r.EncodeString(codecSelferC_UTF8100, string("Port"))
 21522  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 21523  				yym11 := z.EncBinary()
 21524  				_ = yym11
 21525  				if false {
 21526  				} else {
 21527  					r.EncodeUint(uint64(x.Port))
 21528  				}
 21529  			}
 21530  			if yyr2 || yy2arr2 {
 21531  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 21532  				if x.Tags == nil {
 21533  					r.EncodeNil()
 21534  				} else {
 21535  					yym13 := z.EncBinary()
 21536  					_ = yym13
 21537  					if false {
 21538  					} else {
 21539  						z.F.EncMapStringStringV(x.Tags, false, e)
 21540  					}
 21541  				}
 21542  			} else {
 21543  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 21544  				r.EncodeString(codecSelferC_UTF8100, string("Tags"))
 21545  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 21546  				if x.Tags == nil {
 21547  					r.EncodeNil()
 21548  				} else {
 21549  					yym14 := z.EncBinary()
 21550  					_ = yym14
 21551  					if false {
 21552  					} else {
 21553  						z.F.EncMapStringStringV(x.Tags, false, e)
 21554  					}
 21555  				}
 21556  			}
 21557  			if yyr2 || yy2arr2 {
 21558  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 21559  				yym16 := z.EncBinary()
 21560  				_ = yym16
 21561  				if false {
 21562  				} else {
 21563  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 21564  				}
 21565  			} else {
 21566  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 21567  				r.EncodeString(codecSelferC_UTF8100, string("Status"))
 21568  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 21569  				yym17 := z.EncBinary()
 21570  				_ = yym17
 21571  				if false {
 21572  				} else {
 21573  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 21574  				}
 21575  			}
 21576  			if yyr2 || yy2arr2 {
 21577  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 21578  				yym19 := z.EncBinary()
 21579  				_ = yym19
 21580  				if false {
 21581  				} else {
 21582  					r.EncodeUint(uint64(x.ProtocolMin))
 21583  				}
 21584  			} else {
 21585  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 21586  				r.EncodeString(codecSelferC_UTF8100, string("ProtocolMin"))
 21587  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 21588  				yym20 := z.EncBinary()
 21589  				_ = yym20
 21590  				if false {
 21591  				} else {
 21592  					r.EncodeUint(uint64(x.ProtocolMin))
 21593  				}
 21594  			}
 21595  			if yyr2 || yy2arr2 {
 21596  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 21597  				yym22 := z.EncBinary()
 21598  				_ = yym22
 21599  				if false {
 21600  				} else {
 21601  					r.EncodeUint(uint64(x.ProtocolMax))
 21602  				}
 21603  			} else {
 21604  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 21605  				r.EncodeString(codecSelferC_UTF8100, string("ProtocolMax"))
 21606  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 21607  				yym23 := z.EncBinary()
 21608  				_ = yym23
 21609  				if false {
 21610  				} else {
 21611  					r.EncodeUint(uint64(x.ProtocolMax))
 21612  				}
 21613  			}
 21614  			if yyr2 || yy2arr2 {
 21615  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 21616  				yym25 := z.EncBinary()
 21617  				_ = yym25
 21618  				if false {
 21619  				} else {
 21620  					r.EncodeUint(uint64(x.ProtocolCur))
 21621  				}
 21622  			} else {
 21623  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 21624  				r.EncodeString(codecSelferC_UTF8100, string("ProtocolCur"))
 21625  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 21626  				yym26 := z.EncBinary()
 21627  				_ = yym26
 21628  				if false {
 21629  				} else {
 21630  					r.EncodeUint(uint64(x.ProtocolCur))
 21631  				}
 21632  			}
 21633  			if yyr2 || yy2arr2 {
 21634  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 21635  				yym28 := z.EncBinary()
 21636  				_ = yym28
 21637  				if false {
 21638  				} else {
 21639  					r.EncodeUint(uint64(x.DelegateMin))
 21640  				}
 21641  			} else {
 21642  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 21643  				r.EncodeString(codecSelferC_UTF8100, string("DelegateMin"))
 21644  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 21645  				yym29 := z.EncBinary()
 21646  				_ = yym29
 21647  				if false {
 21648  				} else {
 21649  					r.EncodeUint(uint64(x.DelegateMin))
 21650  				}
 21651  			}
 21652  			if yyr2 || yy2arr2 {
 21653  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 21654  				yym31 := z.EncBinary()
 21655  				_ = yym31
 21656  				if false {
 21657  				} else {
 21658  					r.EncodeUint(uint64(x.DelegateMax))
 21659  				}
 21660  			} else {
 21661  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 21662  				r.EncodeString(codecSelferC_UTF8100, string("DelegateMax"))
 21663  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 21664  				yym32 := z.EncBinary()
 21665  				_ = yym32
 21666  				if false {
 21667  				} else {
 21668  					r.EncodeUint(uint64(x.DelegateMax))
 21669  				}
 21670  			}
 21671  			if yyr2 || yy2arr2 {
 21672  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 21673  				yym34 := z.EncBinary()
 21674  				_ = yym34
 21675  				if false {
 21676  				} else {
 21677  					r.EncodeUint(uint64(x.DelegateCur))
 21678  				}
 21679  			} else {
 21680  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 21681  				r.EncodeString(codecSelferC_UTF8100, string("DelegateCur"))
 21682  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 21683  				yym35 := z.EncBinary()
 21684  				_ = yym35
 21685  				if false {
 21686  				} else {
 21687  					r.EncodeUint(uint64(x.DelegateCur))
 21688  				}
 21689  			}
 21690  			if yyr2 || yy2arr2 {
 21691  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 21692  			} else {
 21693  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 21694  			}
 21695  		}
 21696  	}
 21697  }
 21698  
 21699  func (x *ServerMember) CodecDecodeSelf(d *codec1978.Decoder) {
 21700  	var h codecSelfer100
 21701  	z, r := codec1978.GenHelperDecoder(d)
 21702  	_, _, _ = h, z, r
 21703  	yym1 := z.DecBinary()
 21704  	_ = yym1
 21705  	if false {
 21706  	} else if z.HasExtensions() && z.DecExt(x) {
 21707  	} else {
 21708  		yyct2 := r.ContainerType()
 21709  		if yyct2 == codecSelferValueTypeMap100 {
 21710  			yyl2 := r.ReadMapStart()
 21711  			if yyl2 == 0 {
 21712  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 21713  			} else {
 21714  				x.codecDecodeSelfFromMap(yyl2, d)
 21715  			}
 21716  		} else if yyct2 == codecSelferValueTypeArray100 {
 21717  			yyl2 := r.ReadArrayStart()
 21718  			if yyl2 == 0 {
 21719  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21720  			} else {
 21721  				x.codecDecodeSelfFromArray(yyl2, d)
 21722  			}
 21723  		} else {
 21724  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 21725  		}
 21726  	}
 21727  }
 21728  
 21729  func (x *ServerMember) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 21730  	var h codecSelfer100
 21731  	z, r := codec1978.GenHelperDecoder(d)
 21732  	_, _, _ = h, z, r
 21733  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 21734  	_ = yys3Slc
 21735  	var yyhl3 bool = l >= 0
 21736  	for yyj3 := 0; ; yyj3++ {
 21737  		if yyhl3 {
 21738  			if yyj3 >= l {
 21739  				break
 21740  			}
 21741  		} else {
 21742  			if r.CheckBreak() {
 21743  				break
 21744  			}
 21745  		}
 21746  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 21747  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 21748  		yys3 := string(yys3Slc)
 21749  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 21750  		switch yys3 {
 21751  		case "Name":
 21752  			if r.TryDecodeAsNil() {
 21753  				x.Name = ""
 21754  			} else {
 21755  				yyv4 := &x.Name
 21756  				yym5 := z.DecBinary()
 21757  				_ = yym5
 21758  				if false {
 21759  				} else {
 21760  					*((*string)(yyv4)) = r.DecodeString()
 21761  				}
 21762  			}
 21763  		case "Addr":
 21764  			if r.TryDecodeAsNil() {
 21765  				x.Addr = nil
 21766  			} else {
 21767  				yyv6 := &x.Addr
 21768  				yym7 := z.DecBinary()
 21769  				_ = yym7
 21770  				if false {
 21771  				} else if z.HasExtensions() && z.DecExt(yyv6) {
 21772  				} else if !yym7 {
 21773  					z.DecTextUnmarshal(yyv6)
 21774  				} else {
 21775  					h.decnet_IP((*net.IP)(yyv6), d)
 21776  				}
 21777  			}
 21778  		case "Port":
 21779  			if r.TryDecodeAsNil() {
 21780  				x.Port = 0
 21781  			} else {
 21782  				yyv8 := &x.Port
 21783  				yym9 := z.DecBinary()
 21784  				_ = yym9
 21785  				if false {
 21786  				} else {
 21787  					*((*uint16)(yyv8)) = uint16(r.DecodeUint(16))
 21788  				}
 21789  			}
 21790  		case "Tags":
 21791  			if r.TryDecodeAsNil() {
 21792  				x.Tags = nil
 21793  			} else {
 21794  				yyv10 := &x.Tags
 21795  				yym11 := z.DecBinary()
 21796  				_ = yym11
 21797  				if false {
 21798  				} else {
 21799  					z.F.DecMapStringStringX(yyv10, false, d)
 21800  				}
 21801  			}
 21802  		case "Status":
 21803  			if r.TryDecodeAsNil() {
 21804  				x.Status = ""
 21805  			} else {
 21806  				yyv12 := &x.Status
 21807  				yym13 := z.DecBinary()
 21808  				_ = yym13
 21809  				if false {
 21810  				} else {
 21811  					*((*string)(yyv12)) = r.DecodeString()
 21812  				}
 21813  			}
 21814  		case "ProtocolMin":
 21815  			if r.TryDecodeAsNil() {
 21816  				x.ProtocolMin = 0
 21817  			} else {
 21818  				yyv14 := &x.ProtocolMin
 21819  				yym15 := z.DecBinary()
 21820  				_ = yym15
 21821  				if false {
 21822  				} else {
 21823  					*((*uint8)(yyv14)) = uint8(r.DecodeUint(8))
 21824  				}
 21825  			}
 21826  		case "ProtocolMax":
 21827  			if r.TryDecodeAsNil() {
 21828  				x.ProtocolMax = 0
 21829  			} else {
 21830  				yyv16 := &x.ProtocolMax
 21831  				yym17 := z.DecBinary()
 21832  				_ = yym17
 21833  				if false {
 21834  				} else {
 21835  					*((*uint8)(yyv16)) = uint8(r.DecodeUint(8))
 21836  				}
 21837  			}
 21838  		case "ProtocolCur":
 21839  			if r.TryDecodeAsNil() {
 21840  				x.ProtocolCur = 0
 21841  			} else {
 21842  				yyv18 := &x.ProtocolCur
 21843  				yym19 := z.DecBinary()
 21844  				_ = yym19
 21845  				if false {
 21846  				} else {
 21847  					*((*uint8)(yyv18)) = uint8(r.DecodeUint(8))
 21848  				}
 21849  			}
 21850  		case "DelegateMin":
 21851  			if r.TryDecodeAsNil() {
 21852  				x.DelegateMin = 0
 21853  			} else {
 21854  				yyv20 := &x.DelegateMin
 21855  				yym21 := z.DecBinary()
 21856  				_ = yym21
 21857  				if false {
 21858  				} else {
 21859  					*((*uint8)(yyv20)) = uint8(r.DecodeUint(8))
 21860  				}
 21861  			}
 21862  		case "DelegateMax":
 21863  			if r.TryDecodeAsNil() {
 21864  				x.DelegateMax = 0
 21865  			} else {
 21866  				yyv22 := &x.DelegateMax
 21867  				yym23 := z.DecBinary()
 21868  				_ = yym23
 21869  				if false {
 21870  				} else {
 21871  					*((*uint8)(yyv22)) = uint8(r.DecodeUint(8))
 21872  				}
 21873  			}
 21874  		case "DelegateCur":
 21875  			if r.TryDecodeAsNil() {
 21876  				x.DelegateCur = 0
 21877  			} else {
 21878  				yyv24 := &x.DelegateCur
 21879  				yym25 := z.DecBinary()
 21880  				_ = yym25
 21881  				if false {
 21882  				} else {
 21883  					*((*uint8)(yyv24)) = uint8(r.DecodeUint(8))
 21884  				}
 21885  			}
 21886  		default:
 21887  			z.DecStructFieldNotFound(-1, yys3)
 21888  		} // end switch yys3
 21889  	} // end for yyj3
 21890  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 21891  }
 21892  
 21893  func (x *ServerMember) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 21894  	var h codecSelfer100
 21895  	z, r := codec1978.GenHelperDecoder(d)
 21896  	_, _, _ = h, z, r
 21897  	var yyj26 int
 21898  	var yyb26 bool
 21899  	var yyhl26 bool = l >= 0
 21900  	yyj26++
 21901  	if yyhl26 {
 21902  		yyb26 = yyj26 > l
 21903  	} else {
 21904  		yyb26 = r.CheckBreak()
 21905  	}
 21906  	if yyb26 {
 21907  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21908  		return
 21909  	}
 21910  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 21911  	if r.TryDecodeAsNil() {
 21912  		x.Name = ""
 21913  	} else {
 21914  		yyv27 := &x.Name
 21915  		yym28 := z.DecBinary()
 21916  		_ = yym28
 21917  		if false {
 21918  		} else {
 21919  			*((*string)(yyv27)) = r.DecodeString()
 21920  		}
 21921  	}
 21922  	yyj26++
 21923  	if yyhl26 {
 21924  		yyb26 = yyj26 > l
 21925  	} else {
 21926  		yyb26 = r.CheckBreak()
 21927  	}
 21928  	if yyb26 {
 21929  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21930  		return
 21931  	}
 21932  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 21933  	if r.TryDecodeAsNil() {
 21934  		x.Addr = nil
 21935  	} else {
 21936  		yyv29 := &x.Addr
 21937  		yym30 := z.DecBinary()
 21938  		_ = yym30
 21939  		if false {
 21940  		} else if z.HasExtensions() && z.DecExt(yyv29) {
 21941  		} else if !yym30 {
 21942  			z.DecTextUnmarshal(yyv29)
 21943  		} else {
 21944  			h.decnet_IP((*net.IP)(yyv29), d)
 21945  		}
 21946  	}
 21947  	yyj26++
 21948  	if yyhl26 {
 21949  		yyb26 = yyj26 > l
 21950  	} else {
 21951  		yyb26 = r.CheckBreak()
 21952  	}
 21953  	if yyb26 {
 21954  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21955  		return
 21956  	}
 21957  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 21958  	if r.TryDecodeAsNil() {
 21959  		x.Port = 0
 21960  	} else {
 21961  		yyv31 := &x.Port
 21962  		yym32 := z.DecBinary()
 21963  		_ = yym32
 21964  		if false {
 21965  		} else {
 21966  			*((*uint16)(yyv31)) = uint16(r.DecodeUint(16))
 21967  		}
 21968  	}
 21969  	yyj26++
 21970  	if yyhl26 {
 21971  		yyb26 = yyj26 > l
 21972  	} else {
 21973  		yyb26 = r.CheckBreak()
 21974  	}
 21975  	if yyb26 {
 21976  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21977  		return
 21978  	}
 21979  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 21980  	if r.TryDecodeAsNil() {
 21981  		x.Tags = nil
 21982  	} else {
 21983  		yyv33 := &x.Tags
 21984  		yym34 := z.DecBinary()
 21985  		_ = yym34
 21986  		if false {
 21987  		} else {
 21988  			z.F.DecMapStringStringX(yyv33, false, d)
 21989  		}
 21990  	}
 21991  	yyj26++
 21992  	if yyhl26 {
 21993  		yyb26 = yyj26 > l
 21994  	} else {
 21995  		yyb26 = r.CheckBreak()
 21996  	}
 21997  	if yyb26 {
 21998  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 21999  		return
 22000  	}
 22001  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22002  	if r.TryDecodeAsNil() {
 22003  		x.Status = ""
 22004  	} else {
 22005  		yyv35 := &x.Status
 22006  		yym36 := z.DecBinary()
 22007  		_ = yym36
 22008  		if false {
 22009  		} else {
 22010  			*((*string)(yyv35)) = r.DecodeString()
 22011  		}
 22012  	}
 22013  	yyj26++
 22014  	if yyhl26 {
 22015  		yyb26 = yyj26 > l
 22016  	} else {
 22017  		yyb26 = r.CheckBreak()
 22018  	}
 22019  	if yyb26 {
 22020  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22021  		return
 22022  	}
 22023  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22024  	if r.TryDecodeAsNil() {
 22025  		x.ProtocolMin = 0
 22026  	} else {
 22027  		yyv37 := &x.ProtocolMin
 22028  		yym38 := z.DecBinary()
 22029  		_ = yym38
 22030  		if false {
 22031  		} else {
 22032  			*((*uint8)(yyv37)) = uint8(r.DecodeUint(8))
 22033  		}
 22034  	}
 22035  	yyj26++
 22036  	if yyhl26 {
 22037  		yyb26 = yyj26 > l
 22038  	} else {
 22039  		yyb26 = r.CheckBreak()
 22040  	}
 22041  	if yyb26 {
 22042  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22043  		return
 22044  	}
 22045  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22046  	if r.TryDecodeAsNil() {
 22047  		x.ProtocolMax = 0
 22048  	} else {
 22049  		yyv39 := &x.ProtocolMax
 22050  		yym40 := z.DecBinary()
 22051  		_ = yym40
 22052  		if false {
 22053  		} else {
 22054  			*((*uint8)(yyv39)) = uint8(r.DecodeUint(8))
 22055  		}
 22056  	}
 22057  	yyj26++
 22058  	if yyhl26 {
 22059  		yyb26 = yyj26 > l
 22060  	} else {
 22061  		yyb26 = r.CheckBreak()
 22062  	}
 22063  	if yyb26 {
 22064  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22065  		return
 22066  	}
 22067  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22068  	if r.TryDecodeAsNil() {
 22069  		x.ProtocolCur = 0
 22070  	} else {
 22071  		yyv41 := &x.ProtocolCur
 22072  		yym42 := z.DecBinary()
 22073  		_ = yym42
 22074  		if false {
 22075  		} else {
 22076  			*((*uint8)(yyv41)) = uint8(r.DecodeUint(8))
 22077  		}
 22078  	}
 22079  	yyj26++
 22080  	if yyhl26 {
 22081  		yyb26 = yyj26 > l
 22082  	} else {
 22083  		yyb26 = r.CheckBreak()
 22084  	}
 22085  	if yyb26 {
 22086  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22087  		return
 22088  	}
 22089  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22090  	if r.TryDecodeAsNil() {
 22091  		x.DelegateMin = 0
 22092  	} else {
 22093  		yyv43 := &x.DelegateMin
 22094  		yym44 := z.DecBinary()
 22095  		_ = yym44
 22096  		if false {
 22097  		} else {
 22098  			*((*uint8)(yyv43)) = uint8(r.DecodeUint(8))
 22099  		}
 22100  	}
 22101  	yyj26++
 22102  	if yyhl26 {
 22103  		yyb26 = yyj26 > l
 22104  	} else {
 22105  		yyb26 = r.CheckBreak()
 22106  	}
 22107  	if yyb26 {
 22108  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22109  		return
 22110  	}
 22111  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22112  	if r.TryDecodeAsNil() {
 22113  		x.DelegateMax = 0
 22114  	} else {
 22115  		yyv45 := &x.DelegateMax
 22116  		yym46 := z.DecBinary()
 22117  		_ = yym46
 22118  		if false {
 22119  		} else {
 22120  			*((*uint8)(yyv45)) = uint8(r.DecodeUint(8))
 22121  		}
 22122  	}
 22123  	yyj26++
 22124  	if yyhl26 {
 22125  		yyb26 = yyj26 > l
 22126  	} else {
 22127  		yyb26 = r.CheckBreak()
 22128  	}
 22129  	if yyb26 {
 22130  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22131  		return
 22132  	}
 22133  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22134  	if r.TryDecodeAsNil() {
 22135  		x.DelegateCur = 0
 22136  	} else {
 22137  		yyv47 := &x.DelegateCur
 22138  		yym48 := z.DecBinary()
 22139  		_ = yym48
 22140  		if false {
 22141  		} else {
 22142  			*((*uint8)(yyv47)) = uint8(r.DecodeUint(8))
 22143  		}
 22144  	}
 22145  	for {
 22146  		yyj26++
 22147  		if yyhl26 {
 22148  			yyb26 = yyj26 > l
 22149  		} else {
 22150  			yyb26 = r.CheckBreak()
 22151  		}
 22152  		if yyb26 {
 22153  			break
 22154  		}
 22155  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22156  		z.DecStructFieldNotFound(yyj26-1, "")
 22157  	}
 22158  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22159  }
 22160  
 22161  func (x *DeriveVaultTokenRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 22162  	var h codecSelfer100
 22163  	z, r := codec1978.GenHelperEncoder(e)
 22164  	_, _, _ = h, z, r
 22165  	if x == nil {
 22166  		r.EncodeNil()
 22167  	} else {
 22168  		yym1 := z.EncBinary()
 22169  		_ = yym1
 22170  		if false {
 22171  		} else if z.HasExtensions() && z.EncExt(x) {
 22172  		} else {
 22173  			yysep2 := !z.EncBinary()
 22174  			yy2arr2 := z.EncBasicHandle().StructToArray
 22175  			var yyq2 [12]bool
 22176  			_, _, _ = yysep2, yyq2, yy2arr2
 22177  			const yyr2 bool = false
 22178  			var yynn2 int
 22179  			if yyr2 || yy2arr2 {
 22180  				r.EncodeArrayStart(12)
 22181  			} else {
 22182  				yynn2 = 12
 22183  				for _, b := range yyq2 {
 22184  					if b {
 22185  						yynn2++
 22186  					}
 22187  				}
 22188  				r.EncodeMapStart(yynn2)
 22189  				yynn2 = 0
 22190  			}
 22191  			if yyr2 || yy2arr2 {
 22192  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 22193  				yym4 := z.EncBinary()
 22194  				_ = yym4
 22195  				if false {
 22196  				} else {
 22197  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
 22198  				}
 22199  			} else {
 22200  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 22201  				r.EncodeString(codecSelferC_UTF8100, string("NodeID"))
 22202  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 22203  				yym5 := z.EncBinary()
 22204  				_ = yym5
 22205  				if false {
 22206  				} else {
 22207  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
 22208  				}
 22209  			}
 22210  			if yyr2 || yy2arr2 {
 22211  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 22212  				yym7 := z.EncBinary()
 22213  				_ = yym7
 22214  				if false {
 22215  				} else {
 22216  					r.EncodeString(codecSelferC_UTF8100, string(x.SecretID))
 22217  				}
 22218  			} else {
 22219  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 22220  				r.EncodeString(codecSelferC_UTF8100, string("SecretID"))
 22221  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 22222  				yym8 := z.EncBinary()
 22223  				_ = yym8
 22224  				if false {
 22225  				} else {
 22226  					r.EncodeString(codecSelferC_UTF8100, string(x.SecretID))
 22227  				}
 22228  			}
 22229  			if yyr2 || yy2arr2 {
 22230  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 22231  				yym10 := z.EncBinary()
 22232  				_ = yym10
 22233  				if false {
 22234  				} else {
 22235  					r.EncodeString(codecSelferC_UTF8100, string(x.AllocID))
 22236  				}
 22237  			} else {
 22238  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 22239  				r.EncodeString(codecSelferC_UTF8100, string("AllocID"))
 22240  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 22241  				yym11 := z.EncBinary()
 22242  				_ = yym11
 22243  				if false {
 22244  				} else {
 22245  					r.EncodeString(codecSelferC_UTF8100, string(x.AllocID))
 22246  				}
 22247  			}
 22248  			if yyr2 || yy2arr2 {
 22249  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 22250  				if x.Tasks == nil {
 22251  					r.EncodeNil()
 22252  				} else {
 22253  					yym13 := z.EncBinary()
 22254  					_ = yym13
 22255  					if false {
 22256  					} else {
 22257  						z.F.EncSliceStringV(x.Tasks, false, e)
 22258  					}
 22259  				}
 22260  			} else {
 22261  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 22262  				r.EncodeString(codecSelferC_UTF8100, string("Tasks"))
 22263  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 22264  				if x.Tasks == nil {
 22265  					r.EncodeNil()
 22266  				} else {
 22267  					yym14 := z.EncBinary()
 22268  					_ = yym14
 22269  					if false {
 22270  					} else {
 22271  						z.F.EncSliceStringV(x.Tasks, false, e)
 22272  					}
 22273  				}
 22274  			}
 22275  			if yyr2 || yy2arr2 {
 22276  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 22277  				yym16 := z.EncBinary()
 22278  				_ = yym16
 22279  				if false {
 22280  				} else {
 22281  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 22282  				}
 22283  			} else {
 22284  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 22285  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 22286  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 22287  				yym17 := z.EncBinary()
 22288  				_ = yym17
 22289  				if false {
 22290  				} else {
 22291  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 22292  				}
 22293  			}
 22294  			if yyr2 || yy2arr2 {
 22295  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 22296  				yym19 := z.EncBinary()
 22297  				_ = yym19
 22298  				if false {
 22299  				} else {
 22300  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 22301  				}
 22302  			} else {
 22303  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 22304  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 22305  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 22306  				yym20 := z.EncBinary()
 22307  				_ = yym20
 22308  				if false {
 22309  				} else {
 22310  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 22311  				}
 22312  			}
 22313  			if yyr2 || yy2arr2 {
 22314  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 22315  				yym22 := z.EncBinary()
 22316  				_ = yym22
 22317  				if false {
 22318  				} else {
 22319  					r.EncodeUint(uint64(x.MinQueryIndex))
 22320  				}
 22321  			} else {
 22322  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 22323  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 22324  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 22325  				yym23 := z.EncBinary()
 22326  				_ = yym23
 22327  				if false {
 22328  				} else {
 22329  					r.EncodeUint(uint64(x.MinQueryIndex))
 22330  				}
 22331  			}
 22332  			if yyr2 || yy2arr2 {
 22333  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 22334  				yym25 := z.EncBinary()
 22335  				_ = yym25
 22336  				if false {
 22337  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 22338  				} else {
 22339  					r.EncodeInt(int64(x.MaxQueryTime))
 22340  				}
 22341  			} else {
 22342  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 22343  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 22344  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 22345  				yym26 := z.EncBinary()
 22346  				_ = yym26
 22347  				if false {
 22348  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 22349  				} else {
 22350  					r.EncodeInt(int64(x.MaxQueryTime))
 22351  				}
 22352  			}
 22353  			if yyr2 || yy2arr2 {
 22354  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 22355  				yym28 := z.EncBinary()
 22356  				_ = yym28
 22357  				if false {
 22358  				} else {
 22359  					r.EncodeBool(bool(x.AllowStale))
 22360  				}
 22361  			} else {
 22362  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 22363  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 22364  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 22365  				yym29 := z.EncBinary()
 22366  				_ = yym29
 22367  				if false {
 22368  				} else {
 22369  					r.EncodeBool(bool(x.AllowStale))
 22370  				}
 22371  			}
 22372  			if yyr2 || yy2arr2 {
 22373  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 22374  				yym31 := z.EncBinary()
 22375  				_ = yym31
 22376  				if false {
 22377  				} else {
 22378  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 22379  				}
 22380  			} else {
 22381  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 22382  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 22383  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 22384  				yym32 := z.EncBinary()
 22385  				_ = yym32
 22386  				if false {
 22387  				} else {
 22388  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 22389  				}
 22390  			}
 22391  			if yyr2 || yy2arr2 {
 22392  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 22393  				yym34 := z.EncBinary()
 22394  				_ = yym34
 22395  				if false {
 22396  				} else {
 22397  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 22398  				}
 22399  			} else {
 22400  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 22401  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 22402  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 22403  				yym35 := z.EncBinary()
 22404  				_ = yym35
 22405  				if false {
 22406  				} else {
 22407  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 22408  				}
 22409  			}
 22410  			if yyr2 || yy2arr2 {
 22411  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 22412  				yym37 := z.EncBinary()
 22413  				_ = yym37
 22414  				if false {
 22415  				} else {
 22416  					r.EncodeBool(bool(x.Forwarded))
 22417  				}
 22418  			} else {
 22419  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 22420  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 22421  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 22422  				yym38 := z.EncBinary()
 22423  				_ = yym38
 22424  				if false {
 22425  				} else {
 22426  					r.EncodeBool(bool(x.Forwarded))
 22427  				}
 22428  			}
 22429  			if yyr2 || yy2arr2 {
 22430  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 22431  			} else {
 22432  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 22433  			}
 22434  		}
 22435  	}
 22436  }
 22437  
 22438  func (x *DeriveVaultTokenRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 22439  	var h codecSelfer100
 22440  	z, r := codec1978.GenHelperDecoder(d)
 22441  	_, _, _ = h, z, r
 22442  	yym1 := z.DecBinary()
 22443  	_ = yym1
 22444  	if false {
 22445  	} else if z.HasExtensions() && z.DecExt(x) {
 22446  	} else {
 22447  		yyct2 := r.ContainerType()
 22448  		if yyct2 == codecSelferValueTypeMap100 {
 22449  			yyl2 := r.ReadMapStart()
 22450  			if yyl2 == 0 {
 22451  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 22452  			} else {
 22453  				x.codecDecodeSelfFromMap(yyl2, d)
 22454  			}
 22455  		} else if yyct2 == codecSelferValueTypeArray100 {
 22456  			yyl2 := r.ReadArrayStart()
 22457  			if yyl2 == 0 {
 22458  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22459  			} else {
 22460  				x.codecDecodeSelfFromArray(yyl2, d)
 22461  			}
 22462  		} else {
 22463  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 22464  		}
 22465  	}
 22466  }
 22467  
 22468  func (x *DeriveVaultTokenRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 22469  	var h codecSelfer100
 22470  	z, r := codec1978.GenHelperDecoder(d)
 22471  	_, _, _ = h, z, r
 22472  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 22473  	_ = yys3Slc
 22474  	var yyhl3 bool = l >= 0
 22475  	for yyj3 := 0; ; yyj3++ {
 22476  		if yyhl3 {
 22477  			if yyj3 >= l {
 22478  				break
 22479  			}
 22480  		} else {
 22481  			if r.CheckBreak() {
 22482  				break
 22483  			}
 22484  		}
 22485  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 22486  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 22487  		yys3 := string(yys3Slc)
 22488  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 22489  		switch yys3 {
 22490  		case "NodeID":
 22491  			if r.TryDecodeAsNil() {
 22492  				x.NodeID = ""
 22493  			} else {
 22494  				yyv4 := &x.NodeID
 22495  				yym5 := z.DecBinary()
 22496  				_ = yym5
 22497  				if false {
 22498  				} else {
 22499  					*((*string)(yyv4)) = r.DecodeString()
 22500  				}
 22501  			}
 22502  		case "SecretID":
 22503  			if r.TryDecodeAsNil() {
 22504  				x.SecretID = ""
 22505  			} else {
 22506  				yyv6 := &x.SecretID
 22507  				yym7 := z.DecBinary()
 22508  				_ = yym7
 22509  				if false {
 22510  				} else {
 22511  					*((*string)(yyv6)) = r.DecodeString()
 22512  				}
 22513  			}
 22514  		case "AllocID":
 22515  			if r.TryDecodeAsNil() {
 22516  				x.AllocID = ""
 22517  			} else {
 22518  				yyv8 := &x.AllocID
 22519  				yym9 := z.DecBinary()
 22520  				_ = yym9
 22521  				if false {
 22522  				} else {
 22523  					*((*string)(yyv8)) = r.DecodeString()
 22524  				}
 22525  			}
 22526  		case "Tasks":
 22527  			if r.TryDecodeAsNil() {
 22528  				x.Tasks = nil
 22529  			} else {
 22530  				yyv10 := &x.Tasks
 22531  				yym11 := z.DecBinary()
 22532  				_ = yym11
 22533  				if false {
 22534  				} else {
 22535  					z.F.DecSliceStringX(yyv10, false, d)
 22536  				}
 22537  			}
 22538  		case "Region":
 22539  			if r.TryDecodeAsNil() {
 22540  				x.Region = ""
 22541  			} else {
 22542  				yyv12 := &x.Region
 22543  				yym13 := z.DecBinary()
 22544  				_ = yym13
 22545  				if false {
 22546  				} else {
 22547  					*((*string)(yyv12)) = r.DecodeString()
 22548  				}
 22549  			}
 22550  		case "Namespace":
 22551  			if r.TryDecodeAsNil() {
 22552  				x.Namespace = ""
 22553  			} else {
 22554  				yyv14 := &x.Namespace
 22555  				yym15 := z.DecBinary()
 22556  				_ = yym15
 22557  				if false {
 22558  				} else {
 22559  					*((*string)(yyv14)) = r.DecodeString()
 22560  				}
 22561  			}
 22562  		case "MinQueryIndex":
 22563  			if r.TryDecodeAsNil() {
 22564  				x.MinQueryIndex = 0
 22565  			} else {
 22566  				yyv16 := &x.MinQueryIndex
 22567  				yym17 := z.DecBinary()
 22568  				_ = yym17
 22569  				if false {
 22570  				} else {
 22571  					*((*uint64)(yyv16)) = uint64(r.DecodeUint(64))
 22572  				}
 22573  			}
 22574  		case "MaxQueryTime":
 22575  			if r.TryDecodeAsNil() {
 22576  				x.MaxQueryTime = 0
 22577  			} else {
 22578  				yyv18 := &x.MaxQueryTime
 22579  				yym19 := z.DecBinary()
 22580  				_ = yym19
 22581  				if false {
 22582  				} else if z.HasExtensions() && z.DecExt(yyv18) {
 22583  				} else {
 22584  					*((*int64)(yyv18)) = int64(r.DecodeInt(64))
 22585  				}
 22586  			}
 22587  		case "AllowStale":
 22588  			if r.TryDecodeAsNil() {
 22589  				x.AllowStale = false
 22590  			} else {
 22591  				yyv20 := &x.AllowStale
 22592  				yym21 := z.DecBinary()
 22593  				_ = yym21
 22594  				if false {
 22595  				} else {
 22596  					*((*bool)(yyv20)) = r.DecodeBool()
 22597  				}
 22598  			}
 22599  		case "Prefix":
 22600  			if r.TryDecodeAsNil() {
 22601  				x.Prefix = ""
 22602  			} else {
 22603  				yyv22 := &x.Prefix
 22604  				yym23 := z.DecBinary()
 22605  				_ = yym23
 22606  				if false {
 22607  				} else {
 22608  					*((*string)(yyv22)) = r.DecodeString()
 22609  				}
 22610  			}
 22611  		case "AuthToken":
 22612  			if r.TryDecodeAsNil() {
 22613  				x.AuthToken = ""
 22614  			} else {
 22615  				yyv24 := &x.AuthToken
 22616  				yym25 := z.DecBinary()
 22617  				_ = yym25
 22618  				if false {
 22619  				} else {
 22620  					*((*string)(yyv24)) = r.DecodeString()
 22621  				}
 22622  			}
 22623  		case "Forwarded":
 22624  			if r.TryDecodeAsNil() {
 22625  				x.Forwarded = false
 22626  			} else {
 22627  				yyv26 := &x.Forwarded
 22628  				yym27 := z.DecBinary()
 22629  				_ = yym27
 22630  				if false {
 22631  				} else {
 22632  					*((*bool)(yyv26)) = r.DecodeBool()
 22633  				}
 22634  			}
 22635  		default:
 22636  			z.DecStructFieldNotFound(-1, yys3)
 22637  		} // end switch yys3
 22638  	} // end for yyj3
 22639  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 22640  }
 22641  
 22642  func (x *DeriveVaultTokenRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 22643  	var h codecSelfer100
 22644  	z, r := codec1978.GenHelperDecoder(d)
 22645  	_, _, _ = h, z, r
 22646  	var yyj28 int
 22647  	var yyb28 bool
 22648  	var yyhl28 bool = l >= 0
 22649  	yyj28++
 22650  	if yyhl28 {
 22651  		yyb28 = yyj28 > l
 22652  	} else {
 22653  		yyb28 = r.CheckBreak()
 22654  	}
 22655  	if yyb28 {
 22656  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22657  		return
 22658  	}
 22659  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22660  	if r.TryDecodeAsNil() {
 22661  		x.NodeID = ""
 22662  	} else {
 22663  		yyv29 := &x.NodeID
 22664  		yym30 := z.DecBinary()
 22665  		_ = yym30
 22666  		if false {
 22667  		} else {
 22668  			*((*string)(yyv29)) = r.DecodeString()
 22669  		}
 22670  	}
 22671  	yyj28++
 22672  	if yyhl28 {
 22673  		yyb28 = yyj28 > l
 22674  	} else {
 22675  		yyb28 = r.CheckBreak()
 22676  	}
 22677  	if yyb28 {
 22678  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22679  		return
 22680  	}
 22681  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22682  	if r.TryDecodeAsNil() {
 22683  		x.SecretID = ""
 22684  	} else {
 22685  		yyv31 := &x.SecretID
 22686  		yym32 := z.DecBinary()
 22687  		_ = yym32
 22688  		if false {
 22689  		} else {
 22690  			*((*string)(yyv31)) = r.DecodeString()
 22691  		}
 22692  	}
 22693  	yyj28++
 22694  	if yyhl28 {
 22695  		yyb28 = yyj28 > l
 22696  	} else {
 22697  		yyb28 = r.CheckBreak()
 22698  	}
 22699  	if yyb28 {
 22700  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22701  		return
 22702  	}
 22703  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22704  	if r.TryDecodeAsNil() {
 22705  		x.AllocID = ""
 22706  	} else {
 22707  		yyv33 := &x.AllocID
 22708  		yym34 := z.DecBinary()
 22709  		_ = yym34
 22710  		if false {
 22711  		} else {
 22712  			*((*string)(yyv33)) = r.DecodeString()
 22713  		}
 22714  	}
 22715  	yyj28++
 22716  	if yyhl28 {
 22717  		yyb28 = yyj28 > l
 22718  	} else {
 22719  		yyb28 = r.CheckBreak()
 22720  	}
 22721  	if yyb28 {
 22722  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22723  		return
 22724  	}
 22725  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22726  	if r.TryDecodeAsNil() {
 22727  		x.Tasks = nil
 22728  	} else {
 22729  		yyv35 := &x.Tasks
 22730  		yym36 := z.DecBinary()
 22731  		_ = yym36
 22732  		if false {
 22733  		} else {
 22734  			z.F.DecSliceStringX(yyv35, false, d)
 22735  		}
 22736  	}
 22737  	yyj28++
 22738  	if yyhl28 {
 22739  		yyb28 = yyj28 > l
 22740  	} else {
 22741  		yyb28 = r.CheckBreak()
 22742  	}
 22743  	if yyb28 {
 22744  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22745  		return
 22746  	}
 22747  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22748  	if r.TryDecodeAsNil() {
 22749  		x.Region = ""
 22750  	} else {
 22751  		yyv37 := &x.Region
 22752  		yym38 := z.DecBinary()
 22753  		_ = yym38
 22754  		if false {
 22755  		} else {
 22756  			*((*string)(yyv37)) = r.DecodeString()
 22757  		}
 22758  	}
 22759  	yyj28++
 22760  	if yyhl28 {
 22761  		yyb28 = yyj28 > l
 22762  	} else {
 22763  		yyb28 = r.CheckBreak()
 22764  	}
 22765  	if yyb28 {
 22766  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22767  		return
 22768  	}
 22769  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22770  	if r.TryDecodeAsNil() {
 22771  		x.Namespace = ""
 22772  	} else {
 22773  		yyv39 := &x.Namespace
 22774  		yym40 := z.DecBinary()
 22775  		_ = yym40
 22776  		if false {
 22777  		} else {
 22778  			*((*string)(yyv39)) = r.DecodeString()
 22779  		}
 22780  	}
 22781  	yyj28++
 22782  	if yyhl28 {
 22783  		yyb28 = yyj28 > l
 22784  	} else {
 22785  		yyb28 = r.CheckBreak()
 22786  	}
 22787  	if yyb28 {
 22788  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22789  		return
 22790  	}
 22791  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22792  	if r.TryDecodeAsNil() {
 22793  		x.MinQueryIndex = 0
 22794  	} else {
 22795  		yyv41 := &x.MinQueryIndex
 22796  		yym42 := z.DecBinary()
 22797  		_ = yym42
 22798  		if false {
 22799  		} else {
 22800  			*((*uint64)(yyv41)) = uint64(r.DecodeUint(64))
 22801  		}
 22802  	}
 22803  	yyj28++
 22804  	if yyhl28 {
 22805  		yyb28 = yyj28 > l
 22806  	} else {
 22807  		yyb28 = r.CheckBreak()
 22808  	}
 22809  	if yyb28 {
 22810  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22811  		return
 22812  	}
 22813  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22814  	if r.TryDecodeAsNil() {
 22815  		x.MaxQueryTime = 0
 22816  	} else {
 22817  		yyv43 := &x.MaxQueryTime
 22818  		yym44 := z.DecBinary()
 22819  		_ = yym44
 22820  		if false {
 22821  		} else if z.HasExtensions() && z.DecExt(yyv43) {
 22822  		} else {
 22823  			*((*int64)(yyv43)) = int64(r.DecodeInt(64))
 22824  		}
 22825  	}
 22826  	yyj28++
 22827  	if yyhl28 {
 22828  		yyb28 = yyj28 > l
 22829  	} else {
 22830  		yyb28 = r.CheckBreak()
 22831  	}
 22832  	if yyb28 {
 22833  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22834  		return
 22835  	}
 22836  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22837  	if r.TryDecodeAsNil() {
 22838  		x.AllowStale = false
 22839  	} else {
 22840  		yyv45 := &x.AllowStale
 22841  		yym46 := z.DecBinary()
 22842  		_ = yym46
 22843  		if false {
 22844  		} else {
 22845  			*((*bool)(yyv45)) = r.DecodeBool()
 22846  		}
 22847  	}
 22848  	yyj28++
 22849  	if yyhl28 {
 22850  		yyb28 = yyj28 > l
 22851  	} else {
 22852  		yyb28 = r.CheckBreak()
 22853  	}
 22854  	if yyb28 {
 22855  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22856  		return
 22857  	}
 22858  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22859  	if r.TryDecodeAsNil() {
 22860  		x.Prefix = ""
 22861  	} else {
 22862  		yyv47 := &x.Prefix
 22863  		yym48 := z.DecBinary()
 22864  		_ = yym48
 22865  		if false {
 22866  		} else {
 22867  			*((*string)(yyv47)) = r.DecodeString()
 22868  		}
 22869  	}
 22870  	yyj28++
 22871  	if yyhl28 {
 22872  		yyb28 = yyj28 > l
 22873  	} else {
 22874  		yyb28 = r.CheckBreak()
 22875  	}
 22876  	if yyb28 {
 22877  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22878  		return
 22879  	}
 22880  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22881  	if r.TryDecodeAsNil() {
 22882  		x.AuthToken = ""
 22883  	} else {
 22884  		yyv49 := &x.AuthToken
 22885  		yym50 := z.DecBinary()
 22886  		_ = yym50
 22887  		if false {
 22888  		} else {
 22889  			*((*string)(yyv49)) = r.DecodeString()
 22890  		}
 22891  	}
 22892  	yyj28++
 22893  	if yyhl28 {
 22894  		yyb28 = yyj28 > l
 22895  	} else {
 22896  		yyb28 = r.CheckBreak()
 22897  	}
 22898  	if yyb28 {
 22899  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22900  		return
 22901  	}
 22902  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22903  	if r.TryDecodeAsNil() {
 22904  		x.Forwarded = false
 22905  	} else {
 22906  		yyv51 := &x.Forwarded
 22907  		yym52 := z.DecBinary()
 22908  		_ = yym52
 22909  		if false {
 22910  		} else {
 22911  			*((*bool)(yyv51)) = r.DecodeBool()
 22912  		}
 22913  	}
 22914  	for {
 22915  		yyj28++
 22916  		if yyhl28 {
 22917  			yyb28 = yyj28 > l
 22918  		} else {
 22919  			yyb28 = r.CheckBreak()
 22920  		}
 22921  		if yyb28 {
 22922  			break
 22923  		}
 22924  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 22925  		z.DecStructFieldNotFound(yyj28-1, "")
 22926  	}
 22927  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 22928  }
 22929  
 22930  func (x *VaultAccessorsRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 22931  	var h codecSelfer100
 22932  	z, r := codec1978.GenHelperEncoder(e)
 22933  	_, _, _ = h, z, r
 22934  	if x == nil {
 22935  		r.EncodeNil()
 22936  	} else {
 22937  		yym1 := z.EncBinary()
 22938  		_ = yym1
 22939  		if false {
 22940  		} else if z.HasExtensions() && z.EncExt(x) {
 22941  		} else {
 22942  			yysep2 := !z.EncBinary()
 22943  			yy2arr2 := z.EncBasicHandle().StructToArray
 22944  			var yyq2 [1]bool
 22945  			_, _, _ = yysep2, yyq2, yy2arr2
 22946  			const yyr2 bool = false
 22947  			var yynn2 int
 22948  			if yyr2 || yy2arr2 {
 22949  				r.EncodeArrayStart(1)
 22950  			} else {
 22951  				yynn2 = 1
 22952  				for _, b := range yyq2 {
 22953  					if b {
 22954  						yynn2++
 22955  					}
 22956  				}
 22957  				r.EncodeMapStart(yynn2)
 22958  				yynn2 = 0
 22959  			}
 22960  			if yyr2 || yy2arr2 {
 22961  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 22962  				if x.Accessors == nil {
 22963  					r.EncodeNil()
 22964  				} else {
 22965  					yym4 := z.EncBinary()
 22966  					_ = yym4
 22967  					if false {
 22968  					} else {
 22969  						h.encSlicePtrtoVaultAccessor(([]*VaultAccessor)(x.Accessors), e)
 22970  					}
 22971  				}
 22972  			} else {
 22973  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 22974  				r.EncodeString(codecSelferC_UTF8100, string("Accessors"))
 22975  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 22976  				if x.Accessors == nil {
 22977  					r.EncodeNil()
 22978  				} else {
 22979  					yym5 := z.EncBinary()
 22980  					_ = yym5
 22981  					if false {
 22982  					} else {
 22983  						h.encSlicePtrtoVaultAccessor(([]*VaultAccessor)(x.Accessors), e)
 22984  					}
 22985  				}
 22986  			}
 22987  			if yyr2 || yy2arr2 {
 22988  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 22989  			} else {
 22990  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 22991  			}
 22992  		}
 22993  	}
 22994  }
 22995  
 22996  func (x *VaultAccessorsRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 22997  	var h codecSelfer100
 22998  	z, r := codec1978.GenHelperDecoder(d)
 22999  	_, _, _ = h, z, r
 23000  	yym1 := z.DecBinary()
 23001  	_ = yym1
 23002  	if false {
 23003  	} else if z.HasExtensions() && z.DecExt(x) {
 23004  	} else {
 23005  		yyct2 := r.ContainerType()
 23006  		if yyct2 == codecSelferValueTypeMap100 {
 23007  			yyl2 := r.ReadMapStart()
 23008  			if yyl2 == 0 {
 23009  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 23010  			} else {
 23011  				x.codecDecodeSelfFromMap(yyl2, d)
 23012  			}
 23013  		} else if yyct2 == codecSelferValueTypeArray100 {
 23014  			yyl2 := r.ReadArrayStart()
 23015  			if yyl2 == 0 {
 23016  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23017  			} else {
 23018  				x.codecDecodeSelfFromArray(yyl2, d)
 23019  			}
 23020  		} else {
 23021  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 23022  		}
 23023  	}
 23024  }
 23025  
 23026  func (x *VaultAccessorsRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 23027  	var h codecSelfer100
 23028  	z, r := codec1978.GenHelperDecoder(d)
 23029  	_, _, _ = h, z, r
 23030  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 23031  	_ = yys3Slc
 23032  	var yyhl3 bool = l >= 0
 23033  	for yyj3 := 0; ; yyj3++ {
 23034  		if yyhl3 {
 23035  			if yyj3 >= l {
 23036  				break
 23037  			}
 23038  		} else {
 23039  			if r.CheckBreak() {
 23040  				break
 23041  			}
 23042  		}
 23043  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 23044  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 23045  		yys3 := string(yys3Slc)
 23046  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 23047  		switch yys3 {
 23048  		case "Accessors":
 23049  			if r.TryDecodeAsNil() {
 23050  				x.Accessors = nil
 23051  			} else {
 23052  				yyv4 := &x.Accessors
 23053  				yym5 := z.DecBinary()
 23054  				_ = yym5
 23055  				if false {
 23056  				} else {
 23057  					h.decSlicePtrtoVaultAccessor((*[]*VaultAccessor)(yyv4), d)
 23058  				}
 23059  			}
 23060  		default:
 23061  			z.DecStructFieldNotFound(-1, yys3)
 23062  		} // end switch yys3
 23063  	} // end for yyj3
 23064  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 23065  }
 23066  
 23067  func (x *VaultAccessorsRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 23068  	var h codecSelfer100
 23069  	z, r := codec1978.GenHelperDecoder(d)
 23070  	_, _, _ = h, z, r
 23071  	var yyj6 int
 23072  	var yyb6 bool
 23073  	var yyhl6 bool = l >= 0
 23074  	yyj6++
 23075  	if yyhl6 {
 23076  		yyb6 = yyj6 > l
 23077  	} else {
 23078  		yyb6 = r.CheckBreak()
 23079  	}
 23080  	if yyb6 {
 23081  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23082  		return
 23083  	}
 23084  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 23085  	if r.TryDecodeAsNil() {
 23086  		x.Accessors = nil
 23087  	} else {
 23088  		yyv7 := &x.Accessors
 23089  		yym8 := z.DecBinary()
 23090  		_ = yym8
 23091  		if false {
 23092  		} else {
 23093  			h.decSlicePtrtoVaultAccessor((*[]*VaultAccessor)(yyv7), d)
 23094  		}
 23095  	}
 23096  	for {
 23097  		yyj6++
 23098  		if yyhl6 {
 23099  			yyb6 = yyj6 > l
 23100  		} else {
 23101  			yyb6 = r.CheckBreak()
 23102  		}
 23103  		if yyb6 {
 23104  			break
 23105  		}
 23106  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 23107  		z.DecStructFieldNotFound(yyj6-1, "")
 23108  	}
 23109  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23110  }
 23111  
 23112  func (x *VaultAccessor) CodecEncodeSelf(e *codec1978.Encoder) {
 23113  	var h codecSelfer100
 23114  	z, r := codec1978.GenHelperEncoder(e)
 23115  	_, _, _ = h, z, r
 23116  	if x == nil {
 23117  		r.EncodeNil()
 23118  	} else {
 23119  		yym1 := z.EncBinary()
 23120  		_ = yym1
 23121  		if false {
 23122  		} else if z.HasExtensions() && z.EncExt(x) {
 23123  		} else {
 23124  			yysep2 := !z.EncBinary()
 23125  			yy2arr2 := z.EncBasicHandle().StructToArray
 23126  			var yyq2 [6]bool
 23127  			_, _, _ = yysep2, yyq2, yy2arr2
 23128  			const yyr2 bool = false
 23129  			var yynn2 int
 23130  			if yyr2 || yy2arr2 {
 23131  				r.EncodeArrayStart(6)
 23132  			} else {
 23133  				yynn2 = 6
 23134  				for _, b := range yyq2 {
 23135  					if b {
 23136  						yynn2++
 23137  					}
 23138  				}
 23139  				r.EncodeMapStart(yynn2)
 23140  				yynn2 = 0
 23141  			}
 23142  			if yyr2 || yy2arr2 {
 23143  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 23144  				yym4 := z.EncBinary()
 23145  				_ = yym4
 23146  				if false {
 23147  				} else {
 23148  					r.EncodeString(codecSelferC_UTF8100, string(x.AllocID))
 23149  				}
 23150  			} else {
 23151  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 23152  				r.EncodeString(codecSelferC_UTF8100, string("AllocID"))
 23153  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 23154  				yym5 := z.EncBinary()
 23155  				_ = yym5
 23156  				if false {
 23157  				} else {
 23158  					r.EncodeString(codecSelferC_UTF8100, string(x.AllocID))
 23159  				}
 23160  			}
 23161  			if yyr2 || yy2arr2 {
 23162  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 23163  				yym7 := z.EncBinary()
 23164  				_ = yym7
 23165  				if false {
 23166  				} else {
 23167  					r.EncodeString(codecSelferC_UTF8100, string(x.Task))
 23168  				}
 23169  			} else {
 23170  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 23171  				r.EncodeString(codecSelferC_UTF8100, string("Task"))
 23172  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 23173  				yym8 := z.EncBinary()
 23174  				_ = yym8
 23175  				if false {
 23176  				} else {
 23177  					r.EncodeString(codecSelferC_UTF8100, string(x.Task))
 23178  				}
 23179  			}
 23180  			if yyr2 || yy2arr2 {
 23181  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 23182  				yym10 := z.EncBinary()
 23183  				_ = yym10
 23184  				if false {
 23185  				} else {
 23186  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
 23187  				}
 23188  			} else {
 23189  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 23190  				r.EncodeString(codecSelferC_UTF8100, string("NodeID"))
 23191  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 23192  				yym11 := z.EncBinary()
 23193  				_ = yym11
 23194  				if false {
 23195  				} else {
 23196  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
 23197  				}
 23198  			}
 23199  			if yyr2 || yy2arr2 {
 23200  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 23201  				yym13 := z.EncBinary()
 23202  				_ = yym13
 23203  				if false {
 23204  				} else {
 23205  					r.EncodeString(codecSelferC_UTF8100, string(x.Accessor))
 23206  				}
 23207  			} else {
 23208  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 23209  				r.EncodeString(codecSelferC_UTF8100, string("Accessor"))
 23210  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 23211  				yym14 := z.EncBinary()
 23212  				_ = yym14
 23213  				if false {
 23214  				} else {
 23215  					r.EncodeString(codecSelferC_UTF8100, string(x.Accessor))
 23216  				}
 23217  			}
 23218  			if yyr2 || yy2arr2 {
 23219  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 23220  				yym16 := z.EncBinary()
 23221  				_ = yym16
 23222  				if false {
 23223  				} else {
 23224  					r.EncodeInt(int64(x.CreationTTL))
 23225  				}
 23226  			} else {
 23227  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 23228  				r.EncodeString(codecSelferC_UTF8100, string("CreationTTL"))
 23229  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 23230  				yym17 := z.EncBinary()
 23231  				_ = yym17
 23232  				if false {
 23233  				} else {
 23234  					r.EncodeInt(int64(x.CreationTTL))
 23235  				}
 23236  			}
 23237  			if yyr2 || yy2arr2 {
 23238  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 23239  				yym19 := z.EncBinary()
 23240  				_ = yym19
 23241  				if false {
 23242  				} else {
 23243  					r.EncodeUint(uint64(x.CreateIndex))
 23244  				}
 23245  			} else {
 23246  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 23247  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 23248  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 23249  				yym20 := z.EncBinary()
 23250  				_ = yym20
 23251  				if false {
 23252  				} else {
 23253  					r.EncodeUint(uint64(x.CreateIndex))
 23254  				}
 23255  			}
 23256  			if yyr2 || yy2arr2 {
 23257  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 23258  			} else {
 23259  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 23260  			}
 23261  		}
 23262  	}
 23263  }
 23264  
 23265  func (x *VaultAccessor) CodecDecodeSelf(d *codec1978.Decoder) {
 23266  	var h codecSelfer100
 23267  	z, r := codec1978.GenHelperDecoder(d)
 23268  	_, _, _ = h, z, r
 23269  	yym1 := z.DecBinary()
 23270  	_ = yym1
 23271  	if false {
 23272  	} else if z.HasExtensions() && z.DecExt(x) {
 23273  	} else {
 23274  		yyct2 := r.ContainerType()
 23275  		if yyct2 == codecSelferValueTypeMap100 {
 23276  			yyl2 := r.ReadMapStart()
 23277  			if yyl2 == 0 {
 23278  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 23279  			} else {
 23280  				x.codecDecodeSelfFromMap(yyl2, d)
 23281  			}
 23282  		} else if yyct2 == codecSelferValueTypeArray100 {
 23283  			yyl2 := r.ReadArrayStart()
 23284  			if yyl2 == 0 {
 23285  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23286  			} else {
 23287  				x.codecDecodeSelfFromArray(yyl2, d)
 23288  			}
 23289  		} else {
 23290  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 23291  		}
 23292  	}
 23293  }
 23294  
 23295  func (x *VaultAccessor) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 23296  	var h codecSelfer100
 23297  	z, r := codec1978.GenHelperDecoder(d)
 23298  	_, _, _ = h, z, r
 23299  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 23300  	_ = yys3Slc
 23301  	var yyhl3 bool = l >= 0
 23302  	for yyj3 := 0; ; yyj3++ {
 23303  		if yyhl3 {
 23304  			if yyj3 >= l {
 23305  				break
 23306  			}
 23307  		} else {
 23308  			if r.CheckBreak() {
 23309  				break
 23310  			}
 23311  		}
 23312  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 23313  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 23314  		yys3 := string(yys3Slc)
 23315  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 23316  		switch yys3 {
 23317  		case "AllocID":
 23318  			if r.TryDecodeAsNil() {
 23319  				x.AllocID = ""
 23320  			} else {
 23321  				yyv4 := &x.AllocID
 23322  				yym5 := z.DecBinary()
 23323  				_ = yym5
 23324  				if false {
 23325  				} else {
 23326  					*((*string)(yyv4)) = r.DecodeString()
 23327  				}
 23328  			}
 23329  		case "Task":
 23330  			if r.TryDecodeAsNil() {
 23331  				x.Task = ""
 23332  			} else {
 23333  				yyv6 := &x.Task
 23334  				yym7 := z.DecBinary()
 23335  				_ = yym7
 23336  				if false {
 23337  				} else {
 23338  					*((*string)(yyv6)) = r.DecodeString()
 23339  				}
 23340  			}
 23341  		case "NodeID":
 23342  			if r.TryDecodeAsNil() {
 23343  				x.NodeID = ""
 23344  			} else {
 23345  				yyv8 := &x.NodeID
 23346  				yym9 := z.DecBinary()
 23347  				_ = yym9
 23348  				if false {
 23349  				} else {
 23350  					*((*string)(yyv8)) = r.DecodeString()
 23351  				}
 23352  			}
 23353  		case "Accessor":
 23354  			if r.TryDecodeAsNil() {
 23355  				x.Accessor = ""
 23356  			} else {
 23357  				yyv10 := &x.Accessor
 23358  				yym11 := z.DecBinary()
 23359  				_ = yym11
 23360  				if false {
 23361  				} else {
 23362  					*((*string)(yyv10)) = r.DecodeString()
 23363  				}
 23364  			}
 23365  		case "CreationTTL":
 23366  			if r.TryDecodeAsNil() {
 23367  				x.CreationTTL = 0
 23368  			} else {
 23369  				yyv12 := &x.CreationTTL
 23370  				yym13 := z.DecBinary()
 23371  				_ = yym13
 23372  				if false {
 23373  				} else {
 23374  					*((*int)(yyv12)) = int(r.DecodeInt(codecSelferBitsize100))
 23375  				}
 23376  			}
 23377  		case "CreateIndex":
 23378  			if r.TryDecodeAsNil() {
 23379  				x.CreateIndex = 0
 23380  			} else {
 23381  				yyv14 := &x.CreateIndex
 23382  				yym15 := z.DecBinary()
 23383  				_ = yym15
 23384  				if false {
 23385  				} else {
 23386  					*((*uint64)(yyv14)) = uint64(r.DecodeUint(64))
 23387  				}
 23388  			}
 23389  		default:
 23390  			z.DecStructFieldNotFound(-1, yys3)
 23391  		} // end switch yys3
 23392  	} // end for yyj3
 23393  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 23394  }
 23395  
 23396  func (x *VaultAccessor) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 23397  	var h codecSelfer100
 23398  	z, r := codec1978.GenHelperDecoder(d)
 23399  	_, _, _ = h, z, r
 23400  	var yyj16 int
 23401  	var yyb16 bool
 23402  	var yyhl16 bool = l >= 0
 23403  	yyj16++
 23404  	if yyhl16 {
 23405  		yyb16 = yyj16 > l
 23406  	} else {
 23407  		yyb16 = r.CheckBreak()
 23408  	}
 23409  	if yyb16 {
 23410  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23411  		return
 23412  	}
 23413  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 23414  	if r.TryDecodeAsNil() {
 23415  		x.AllocID = ""
 23416  	} else {
 23417  		yyv17 := &x.AllocID
 23418  		yym18 := z.DecBinary()
 23419  		_ = yym18
 23420  		if false {
 23421  		} else {
 23422  			*((*string)(yyv17)) = r.DecodeString()
 23423  		}
 23424  	}
 23425  	yyj16++
 23426  	if yyhl16 {
 23427  		yyb16 = yyj16 > l
 23428  	} else {
 23429  		yyb16 = r.CheckBreak()
 23430  	}
 23431  	if yyb16 {
 23432  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23433  		return
 23434  	}
 23435  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 23436  	if r.TryDecodeAsNil() {
 23437  		x.Task = ""
 23438  	} else {
 23439  		yyv19 := &x.Task
 23440  		yym20 := z.DecBinary()
 23441  		_ = yym20
 23442  		if false {
 23443  		} else {
 23444  			*((*string)(yyv19)) = r.DecodeString()
 23445  		}
 23446  	}
 23447  	yyj16++
 23448  	if yyhl16 {
 23449  		yyb16 = yyj16 > l
 23450  	} else {
 23451  		yyb16 = r.CheckBreak()
 23452  	}
 23453  	if yyb16 {
 23454  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23455  		return
 23456  	}
 23457  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 23458  	if r.TryDecodeAsNil() {
 23459  		x.NodeID = ""
 23460  	} else {
 23461  		yyv21 := &x.NodeID
 23462  		yym22 := z.DecBinary()
 23463  		_ = yym22
 23464  		if false {
 23465  		} else {
 23466  			*((*string)(yyv21)) = r.DecodeString()
 23467  		}
 23468  	}
 23469  	yyj16++
 23470  	if yyhl16 {
 23471  		yyb16 = yyj16 > l
 23472  	} else {
 23473  		yyb16 = r.CheckBreak()
 23474  	}
 23475  	if yyb16 {
 23476  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23477  		return
 23478  	}
 23479  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 23480  	if r.TryDecodeAsNil() {
 23481  		x.Accessor = ""
 23482  	} else {
 23483  		yyv23 := &x.Accessor
 23484  		yym24 := z.DecBinary()
 23485  		_ = yym24
 23486  		if false {
 23487  		} else {
 23488  			*((*string)(yyv23)) = r.DecodeString()
 23489  		}
 23490  	}
 23491  	yyj16++
 23492  	if yyhl16 {
 23493  		yyb16 = yyj16 > l
 23494  	} else {
 23495  		yyb16 = r.CheckBreak()
 23496  	}
 23497  	if yyb16 {
 23498  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23499  		return
 23500  	}
 23501  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 23502  	if r.TryDecodeAsNil() {
 23503  		x.CreationTTL = 0
 23504  	} else {
 23505  		yyv25 := &x.CreationTTL
 23506  		yym26 := z.DecBinary()
 23507  		_ = yym26
 23508  		if false {
 23509  		} else {
 23510  			*((*int)(yyv25)) = int(r.DecodeInt(codecSelferBitsize100))
 23511  		}
 23512  	}
 23513  	yyj16++
 23514  	if yyhl16 {
 23515  		yyb16 = yyj16 > l
 23516  	} else {
 23517  		yyb16 = r.CheckBreak()
 23518  	}
 23519  	if yyb16 {
 23520  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23521  		return
 23522  	}
 23523  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 23524  	if r.TryDecodeAsNil() {
 23525  		x.CreateIndex = 0
 23526  	} else {
 23527  		yyv27 := &x.CreateIndex
 23528  		yym28 := z.DecBinary()
 23529  		_ = yym28
 23530  		if false {
 23531  		} else {
 23532  			*((*uint64)(yyv27)) = uint64(r.DecodeUint(64))
 23533  		}
 23534  	}
 23535  	for {
 23536  		yyj16++
 23537  		if yyhl16 {
 23538  			yyb16 = yyj16 > l
 23539  		} else {
 23540  			yyb16 = r.CheckBreak()
 23541  		}
 23542  		if yyb16 {
 23543  			break
 23544  		}
 23545  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 23546  		z.DecStructFieldNotFound(yyj16-1, "")
 23547  	}
 23548  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23549  }
 23550  
 23551  func (x *DeriveVaultTokenResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 23552  	var h codecSelfer100
 23553  	z, r := codec1978.GenHelperEncoder(e)
 23554  	_, _, _ = h, z, r
 23555  	if x == nil {
 23556  		r.EncodeNil()
 23557  	} else {
 23558  		yym1 := z.EncBinary()
 23559  		_ = yym1
 23560  		if false {
 23561  		} else if z.HasExtensions() && z.EncExt(x) {
 23562  		} else {
 23563  			yysep2 := !z.EncBinary()
 23564  			yy2arr2 := z.EncBasicHandle().StructToArray
 23565  			var yyq2 [5]bool
 23566  			_, _, _ = yysep2, yyq2, yy2arr2
 23567  			const yyr2 bool = false
 23568  			var yynn2 int
 23569  			if yyr2 || yy2arr2 {
 23570  				r.EncodeArrayStart(5)
 23571  			} else {
 23572  				yynn2 = 5
 23573  				for _, b := range yyq2 {
 23574  					if b {
 23575  						yynn2++
 23576  					}
 23577  				}
 23578  				r.EncodeMapStart(yynn2)
 23579  				yynn2 = 0
 23580  			}
 23581  			if yyr2 || yy2arr2 {
 23582  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 23583  				if x.Tasks == nil {
 23584  					r.EncodeNil()
 23585  				} else {
 23586  					yym4 := z.EncBinary()
 23587  					_ = yym4
 23588  					if false {
 23589  					} else {
 23590  						z.F.EncMapStringStringV(x.Tasks, false, e)
 23591  					}
 23592  				}
 23593  			} else {
 23594  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 23595  				r.EncodeString(codecSelferC_UTF8100, string("Tasks"))
 23596  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 23597  				if x.Tasks == nil {
 23598  					r.EncodeNil()
 23599  				} else {
 23600  					yym5 := z.EncBinary()
 23601  					_ = yym5
 23602  					if false {
 23603  					} else {
 23604  						z.F.EncMapStringStringV(x.Tasks, false, e)
 23605  					}
 23606  				}
 23607  			}
 23608  			if yyr2 || yy2arr2 {
 23609  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 23610  				if x.Error == nil {
 23611  					r.EncodeNil()
 23612  				} else {
 23613  					x.Error.CodecEncodeSelf(e)
 23614  				}
 23615  			} else {
 23616  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 23617  				r.EncodeString(codecSelferC_UTF8100, string("Error"))
 23618  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 23619  				if x.Error == nil {
 23620  					r.EncodeNil()
 23621  				} else {
 23622  					x.Error.CodecEncodeSelf(e)
 23623  				}
 23624  			}
 23625  			if yyr2 || yy2arr2 {
 23626  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 23627  				yym10 := z.EncBinary()
 23628  				_ = yym10
 23629  				if false {
 23630  				} else {
 23631  					r.EncodeUint(uint64(x.Index))
 23632  				}
 23633  			} else {
 23634  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 23635  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 23636  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 23637  				yym11 := z.EncBinary()
 23638  				_ = yym11
 23639  				if false {
 23640  				} else {
 23641  					r.EncodeUint(uint64(x.Index))
 23642  				}
 23643  			}
 23644  			if yyr2 || yy2arr2 {
 23645  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 23646  				yym13 := z.EncBinary()
 23647  				_ = yym13
 23648  				if false {
 23649  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 23650  				} else {
 23651  					r.EncodeInt(int64(x.LastContact))
 23652  				}
 23653  			} else {
 23654  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 23655  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 23656  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 23657  				yym14 := z.EncBinary()
 23658  				_ = yym14
 23659  				if false {
 23660  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 23661  				} else {
 23662  					r.EncodeInt(int64(x.LastContact))
 23663  				}
 23664  			}
 23665  			if yyr2 || yy2arr2 {
 23666  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 23667  				yym16 := z.EncBinary()
 23668  				_ = yym16
 23669  				if false {
 23670  				} else {
 23671  					r.EncodeBool(bool(x.KnownLeader))
 23672  				}
 23673  			} else {
 23674  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 23675  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 23676  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 23677  				yym17 := z.EncBinary()
 23678  				_ = yym17
 23679  				if false {
 23680  				} else {
 23681  					r.EncodeBool(bool(x.KnownLeader))
 23682  				}
 23683  			}
 23684  			if yyr2 || yy2arr2 {
 23685  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 23686  			} else {
 23687  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 23688  			}
 23689  		}
 23690  	}
 23691  }
 23692  
 23693  func (x *DeriveVaultTokenResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 23694  	var h codecSelfer100
 23695  	z, r := codec1978.GenHelperDecoder(d)
 23696  	_, _, _ = h, z, r
 23697  	yym1 := z.DecBinary()
 23698  	_ = yym1
 23699  	if false {
 23700  	} else if z.HasExtensions() && z.DecExt(x) {
 23701  	} else {
 23702  		yyct2 := r.ContainerType()
 23703  		if yyct2 == codecSelferValueTypeMap100 {
 23704  			yyl2 := r.ReadMapStart()
 23705  			if yyl2 == 0 {
 23706  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 23707  			} else {
 23708  				x.codecDecodeSelfFromMap(yyl2, d)
 23709  			}
 23710  		} else if yyct2 == codecSelferValueTypeArray100 {
 23711  			yyl2 := r.ReadArrayStart()
 23712  			if yyl2 == 0 {
 23713  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23714  			} else {
 23715  				x.codecDecodeSelfFromArray(yyl2, d)
 23716  			}
 23717  		} else {
 23718  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 23719  		}
 23720  	}
 23721  }
 23722  
 23723  func (x *DeriveVaultTokenResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 23724  	var h codecSelfer100
 23725  	z, r := codec1978.GenHelperDecoder(d)
 23726  	_, _, _ = h, z, r
 23727  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 23728  	_ = yys3Slc
 23729  	var yyhl3 bool = l >= 0
 23730  	for yyj3 := 0; ; yyj3++ {
 23731  		if yyhl3 {
 23732  			if yyj3 >= l {
 23733  				break
 23734  			}
 23735  		} else {
 23736  			if r.CheckBreak() {
 23737  				break
 23738  			}
 23739  		}
 23740  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 23741  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 23742  		yys3 := string(yys3Slc)
 23743  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 23744  		switch yys3 {
 23745  		case "Tasks":
 23746  			if r.TryDecodeAsNil() {
 23747  				x.Tasks = nil
 23748  			} else {
 23749  				yyv4 := &x.Tasks
 23750  				yym5 := z.DecBinary()
 23751  				_ = yym5
 23752  				if false {
 23753  				} else {
 23754  					z.F.DecMapStringStringX(yyv4, false, d)
 23755  				}
 23756  			}
 23757  		case "Error":
 23758  			if r.TryDecodeAsNil() {
 23759  				if x.Error != nil {
 23760  					x.Error = nil
 23761  				}
 23762  			} else {
 23763  				if x.Error == nil {
 23764  					x.Error = new(RecoverableError)
 23765  				}
 23766  				x.Error.CodecDecodeSelf(d)
 23767  			}
 23768  		case "Index":
 23769  			if r.TryDecodeAsNil() {
 23770  				x.Index = 0
 23771  			} else {
 23772  				yyv7 := &x.Index
 23773  				yym8 := z.DecBinary()
 23774  				_ = yym8
 23775  				if false {
 23776  				} else {
 23777  					*((*uint64)(yyv7)) = uint64(r.DecodeUint(64))
 23778  				}
 23779  			}
 23780  		case "LastContact":
 23781  			if r.TryDecodeAsNil() {
 23782  				x.LastContact = 0
 23783  			} else {
 23784  				yyv9 := &x.LastContact
 23785  				yym10 := z.DecBinary()
 23786  				_ = yym10
 23787  				if false {
 23788  				} else if z.HasExtensions() && z.DecExt(yyv9) {
 23789  				} else {
 23790  					*((*int64)(yyv9)) = int64(r.DecodeInt(64))
 23791  				}
 23792  			}
 23793  		case "KnownLeader":
 23794  			if r.TryDecodeAsNil() {
 23795  				x.KnownLeader = false
 23796  			} else {
 23797  				yyv11 := &x.KnownLeader
 23798  				yym12 := z.DecBinary()
 23799  				_ = yym12
 23800  				if false {
 23801  				} else {
 23802  					*((*bool)(yyv11)) = r.DecodeBool()
 23803  				}
 23804  			}
 23805  		default:
 23806  			z.DecStructFieldNotFound(-1, yys3)
 23807  		} // end switch yys3
 23808  	} // end for yyj3
 23809  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 23810  }
 23811  
 23812  func (x *DeriveVaultTokenResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 23813  	var h codecSelfer100
 23814  	z, r := codec1978.GenHelperDecoder(d)
 23815  	_, _, _ = h, z, r
 23816  	var yyj13 int
 23817  	var yyb13 bool
 23818  	var yyhl13 bool = l >= 0
 23819  	yyj13++
 23820  	if yyhl13 {
 23821  		yyb13 = yyj13 > l
 23822  	} else {
 23823  		yyb13 = r.CheckBreak()
 23824  	}
 23825  	if yyb13 {
 23826  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23827  		return
 23828  	}
 23829  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 23830  	if r.TryDecodeAsNil() {
 23831  		x.Tasks = nil
 23832  	} else {
 23833  		yyv14 := &x.Tasks
 23834  		yym15 := z.DecBinary()
 23835  		_ = yym15
 23836  		if false {
 23837  		} else {
 23838  			z.F.DecMapStringStringX(yyv14, false, d)
 23839  		}
 23840  	}
 23841  	yyj13++
 23842  	if yyhl13 {
 23843  		yyb13 = yyj13 > l
 23844  	} else {
 23845  		yyb13 = r.CheckBreak()
 23846  	}
 23847  	if yyb13 {
 23848  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23849  		return
 23850  	}
 23851  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 23852  	if r.TryDecodeAsNil() {
 23853  		if x.Error != nil {
 23854  			x.Error = nil
 23855  		}
 23856  	} else {
 23857  		if x.Error == nil {
 23858  			x.Error = new(RecoverableError)
 23859  		}
 23860  		x.Error.CodecDecodeSelf(d)
 23861  	}
 23862  	yyj13++
 23863  	if yyhl13 {
 23864  		yyb13 = yyj13 > l
 23865  	} else {
 23866  		yyb13 = r.CheckBreak()
 23867  	}
 23868  	if yyb13 {
 23869  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23870  		return
 23871  	}
 23872  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 23873  	if r.TryDecodeAsNil() {
 23874  		x.Index = 0
 23875  	} else {
 23876  		yyv17 := &x.Index
 23877  		yym18 := z.DecBinary()
 23878  		_ = yym18
 23879  		if false {
 23880  		} else {
 23881  			*((*uint64)(yyv17)) = uint64(r.DecodeUint(64))
 23882  		}
 23883  	}
 23884  	yyj13++
 23885  	if yyhl13 {
 23886  		yyb13 = yyj13 > l
 23887  	} else {
 23888  		yyb13 = r.CheckBreak()
 23889  	}
 23890  	if yyb13 {
 23891  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23892  		return
 23893  	}
 23894  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 23895  	if r.TryDecodeAsNil() {
 23896  		x.LastContact = 0
 23897  	} else {
 23898  		yyv19 := &x.LastContact
 23899  		yym20 := z.DecBinary()
 23900  		_ = yym20
 23901  		if false {
 23902  		} else if z.HasExtensions() && z.DecExt(yyv19) {
 23903  		} else {
 23904  			*((*int64)(yyv19)) = int64(r.DecodeInt(64))
 23905  		}
 23906  	}
 23907  	yyj13++
 23908  	if yyhl13 {
 23909  		yyb13 = yyj13 > l
 23910  	} else {
 23911  		yyb13 = r.CheckBreak()
 23912  	}
 23913  	if yyb13 {
 23914  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23915  		return
 23916  	}
 23917  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 23918  	if r.TryDecodeAsNil() {
 23919  		x.KnownLeader = false
 23920  	} else {
 23921  		yyv21 := &x.KnownLeader
 23922  		yym22 := z.DecBinary()
 23923  		_ = yym22
 23924  		if false {
 23925  		} else {
 23926  			*((*bool)(yyv21)) = r.DecodeBool()
 23927  		}
 23928  	}
 23929  	for {
 23930  		yyj13++
 23931  		if yyhl13 {
 23932  			yyb13 = yyj13 > l
 23933  		} else {
 23934  			yyb13 = r.CheckBreak()
 23935  		}
 23936  		if yyb13 {
 23937  			break
 23938  		}
 23939  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 23940  		z.DecStructFieldNotFound(yyj13-1, "")
 23941  	}
 23942  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 23943  }
 23944  
 23945  func (x *GenericRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 23946  	var h codecSelfer100
 23947  	z, r := codec1978.GenHelperEncoder(e)
 23948  	_, _, _ = h, z, r
 23949  	if x == nil {
 23950  		r.EncodeNil()
 23951  	} else {
 23952  		yym1 := z.EncBinary()
 23953  		_ = yym1
 23954  		if false {
 23955  		} else if z.HasExtensions() && z.EncExt(x) {
 23956  		} else {
 23957  			yysep2 := !z.EncBinary()
 23958  			yy2arr2 := z.EncBasicHandle().StructToArray
 23959  			var yyq2 [8]bool
 23960  			_, _, _ = yysep2, yyq2, yy2arr2
 23961  			const yyr2 bool = false
 23962  			var yynn2 int
 23963  			if yyr2 || yy2arr2 {
 23964  				r.EncodeArrayStart(8)
 23965  			} else {
 23966  				yynn2 = 8
 23967  				for _, b := range yyq2 {
 23968  					if b {
 23969  						yynn2++
 23970  					}
 23971  				}
 23972  				r.EncodeMapStart(yynn2)
 23973  				yynn2 = 0
 23974  			}
 23975  			if yyr2 || yy2arr2 {
 23976  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 23977  				yym4 := z.EncBinary()
 23978  				_ = yym4
 23979  				if false {
 23980  				} else {
 23981  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 23982  				}
 23983  			} else {
 23984  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 23985  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 23986  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 23987  				yym5 := z.EncBinary()
 23988  				_ = yym5
 23989  				if false {
 23990  				} else {
 23991  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 23992  				}
 23993  			}
 23994  			if yyr2 || yy2arr2 {
 23995  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 23996  				yym7 := z.EncBinary()
 23997  				_ = yym7
 23998  				if false {
 23999  				} else {
 24000  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 24001  				}
 24002  			} else {
 24003  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 24004  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 24005  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 24006  				yym8 := z.EncBinary()
 24007  				_ = yym8
 24008  				if false {
 24009  				} else {
 24010  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 24011  				}
 24012  			}
 24013  			if yyr2 || yy2arr2 {
 24014  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 24015  				yym10 := z.EncBinary()
 24016  				_ = yym10
 24017  				if false {
 24018  				} else {
 24019  					r.EncodeUint(uint64(x.MinQueryIndex))
 24020  				}
 24021  			} else {
 24022  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 24023  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 24024  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 24025  				yym11 := z.EncBinary()
 24026  				_ = yym11
 24027  				if false {
 24028  				} else {
 24029  					r.EncodeUint(uint64(x.MinQueryIndex))
 24030  				}
 24031  			}
 24032  			if yyr2 || yy2arr2 {
 24033  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 24034  				yym13 := z.EncBinary()
 24035  				_ = yym13
 24036  				if false {
 24037  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 24038  				} else {
 24039  					r.EncodeInt(int64(x.MaxQueryTime))
 24040  				}
 24041  			} else {
 24042  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 24043  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 24044  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 24045  				yym14 := z.EncBinary()
 24046  				_ = yym14
 24047  				if false {
 24048  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 24049  				} else {
 24050  					r.EncodeInt(int64(x.MaxQueryTime))
 24051  				}
 24052  			}
 24053  			if yyr2 || yy2arr2 {
 24054  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 24055  				yym16 := z.EncBinary()
 24056  				_ = yym16
 24057  				if false {
 24058  				} else {
 24059  					r.EncodeBool(bool(x.AllowStale))
 24060  				}
 24061  			} else {
 24062  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 24063  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 24064  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 24065  				yym17 := z.EncBinary()
 24066  				_ = yym17
 24067  				if false {
 24068  				} else {
 24069  					r.EncodeBool(bool(x.AllowStale))
 24070  				}
 24071  			}
 24072  			if yyr2 || yy2arr2 {
 24073  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 24074  				yym19 := z.EncBinary()
 24075  				_ = yym19
 24076  				if false {
 24077  				} else {
 24078  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 24079  				}
 24080  			} else {
 24081  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 24082  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 24083  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 24084  				yym20 := z.EncBinary()
 24085  				_ = yym20
 24086  				if false {
 24087  				} else {
 24088  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 24089  				}
 24090  			}
 24091  			if yyr2 || yy2arr2 {
 24092  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 24093  				yym22 := z.EncBinary()
 24094  				_ = yym22
 24095  				if false {
 24096  				} else {
 24097  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 24098  				}
 24099  			} else {
 24100  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 24101  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 24102  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 24103  				yym23 := z.EncBinary()
 24104  				_ = yym23
 24105  				if false {
 24106  				} else {
 24107  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 24108  				}
 24109  			}
 24110  			if yyr2 || yy2arr2 {
 24111  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 24112  				yym25 := z.EncBinary()
 24113  				_ = yym25
 24114  				if false {
 24115  				} else {
 24116  					r.EncodeBool(bool(x.Forwarded))
 24117  				}
 24118  			} else {
 24119  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 24120  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 24121  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 24122  				yym26 := z.EncBinary()
 24123  				_ = yym26
 24124  				if false {
 24125  				} else {
 24126  					r.EncodeBool(bool(x.Forwarded))
 24127  				}
 24128  			}
 24129  			if yyr2 || yy2arr2 {
 24130  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 24131  			} else {
 24132  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 24133  			}
 24134  		}
 24135  	}
 24136  }
 24137  
 24138  func (x *GenericRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 24139  	var h codecSelfer100
 24140  	z, r := codec1978.GenHelperDecoder(d)
 24141  	_, _, _ = h, z, r
 24142  	yym1 := z.DecBinary()
 24143  	_ = yym1
 24144  	if false {
 24145  	} else if z.HasExtensions() && z.DecExt(x) {
 24146  	} else {
 24147  		yyct2 := r.ContainerType()
 24148  		if yyct2 == codecSelferValueTypeMap100 {
 24149  			yyl2 := r.ReadMapStart()
 24150  			if yyl2 == 0 {
 24151  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 24152  			} else {
 24153  				x.codecDecodeSelfFromMap(yyl2, d)
 24154  			}
 24155  		} else if yyct2 == codecSelferValueTypeArray100 {
 24156  			yyl2 := r.ReadArrayStart()
 24157  			if yyl2 == 0 {
 24158  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24159  			} else {
 24160  				x.codecDecodeSelfFromArray(yyl2, d)
 24161  			}
 24162  		} else {
 24163  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 24164  		}
 24165  	}
 24166  }
 24167  
 24168  func (x *GenericRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 24169  	var h codecSelfer100
 24170  	z, r := codec1978.GenHelperDecoder(d)
 24171  	_, _, _ = h, z, r
 24172  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 24173  	_ = yys3Slc
 24174  	var yyhl3 bool = l >= 0
 24175  	for yyj3 := 0; ; yyj3++ {
 24176  		if yyhl3 {
 24177  			if yyj3 >= l {
 24178  				break
 24179  			}
 24180  		} else {
 24181  			if r.CheckBreak() {
 24182  				break
 24183  			}
 24184  		}
 24185  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 24186  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 24187  		yys3 := string(yys3Slc)
 24188  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 24189  		switch yys3 {
 24190  		case "Region":
 24191  			if r.TryDecodeAsNil() {
 24192  				x.Region = ""
 24193  			} else {
 24194  				yyv4 := &x.Region
 24195  				yym5 := z.DecBinary()
 24196  				_ = yym5
 24197  				if false {
 24198  				} else {
 24199  					*((*string)(yyv4)) = r.DecodeString()
 24200  				}
 24201  			}
 24202  		case "Namespace":
 24203  			if r.TryDecodeAsNil() {
 24204  				x.Namespace = ""
 24205  			} else {
 24206  				yyv6 := &x.Namespace
 24207  				yym7 := z.DecBinary()
 24208  				_ = yym7
 24209  				if false {
 24210  				} else {
 24211  					*((*string)(yyv6)) = r.DecodeString()
 24212  				}
 24213  			}
 24214  		case "MinQueryIndex":
 24215  			if r.TryDecodeAsNil() {
 24216  				x.MinQueryIndex = 0
 24217  			} else {
 24218  				yyv8 := &x.MinQueryIndex
 24219  				yym9 := z.DecBinary()
 24220  				_ = yym9
 24221  				if false {
 24222  				} else {
 24223  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 24224  				}
 24225  			}
 24226  		case "MaxQueryTime":
 24227  			if r.TryDecodeAsNil() {
 24228  				x.MaxQueryTime = 0
 24229  			} else {
 24230  				yyv10 := &x.MaxQueryTime
 24231  				yym11 := z.DecBinary()
 24232  				_ = yym11
 24233  				if false {
 24234  				} else if z.HasExtensions() && z.DecExt(yyv10) {
 24235  				} else {
 24236  					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
 24237  				}
 24238  			}
 24239  		case "AllowStale":
 24240  			if r.TryDecodeAsNil() {
 24241  				x.AllowStale = false
 24242  			} else {
 24243  				yyv12 := &x.AllowStale
 24244  				yym13 := z.DecBinary()
 24245  				_ = yym13
 24246  				if false {
 24247  				} else {
 24248  					*((*bool)(yyv12)) = r.DecodeBool()
 24249  				}
 24250  			}
 24251  		case "Prefix":
 24252  			if r.TryDecodeAsNil() {
 24253  				x.Prefix = ""
 24254  			} else {
 24255  				yyv14 := &x.Prefix
 24256  				yym15 := z.DecBinary()
 24257  				_ = yym15
 24258  				if false {
 24259  				} else {
 24260  					*((*string)(yyv14)) = r.DecodeString()
 24261  				}
 24262  			}
 24263  		case "AuthToken":
 24264  			if r.TryDecodeAsNil() {
 24265  				x.AuthToken = ""
 24266  			} else {
 24267  				yyv16 := &x.AuthToken
 24268  				yym17 := z.DecBinary()
 24269  				_ = yym17
 24270  				if false {
 24271  				} else {
 24272  					*((*string)(yyv16)) = r.DecodeString()
 24273  				}
 24274  			}
 24275  		case "Forwarded":
 24276  			if r.TryDecodeAsNil() {
 24277  				x.Forwarded = false
 24278  			} else {
 24279  				yyv18 := &x.Forwarded
 24280  				yym19 := z.DecBinary()
 24281  				_ = yym19
 24282  				if false {
 24283  				} else {
 24284  					*((*bool)(yyv18)) = r.DecodeBool()
 24285  				}
 24286  			}
 24287  		default:
 24288  			z.DecStructFieldNotFound(-1, yys3)
 24289  		} // end switch yys3
 24290  	} // end for yyj3
 24291  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 24292  }
 24293  
 24294  func (x *GenericRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 24295  	var h codecSelfer100
 24296  	z, r := codec1978.GenHelperDecoder(d)
 24297  	_, _, _ = h, z, r
 24298  	var yyj20 int
 24299  	var yyb20 bool
 24300  	var yyhl20 bool = l >= 0
 24301  	yyj20++
 24302  	if yyhl20 {
 24303  		yyb20 = yyj20 > l
 24304  	} else {
 24305  		yyb20 = r.CheckBreak()
 24306  	}
 24307  	if yyb20 {
 24308  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24309  		return
 24310  	}
 24311  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24312  	if r.TryDecodeAsNil() {
 24313  		x.Region = ""
 24314  	} else {
 24315  		yyv21 := &x.Region
 24316  		yym22 := z.DecBinary()
 24317  		_ = yym22
 24318  		if false {
 24319  		} else {
 24320  			*((*string)(yyv21)) = r.DecodeString()
 24321  		}
 24322  	}
 24323  	yyj20++
 24324  	if yyhl20 {
 24325  		yyb20 = yyj20 > l
 24326  	} else {
 24327  		yyb20 = r.CheckBreak()
 24328  	}
 24329  	if yyb20 {
 24330  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24331  		return
 24332  	}
 24333  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24334  	if r.TryDecodeAsNil() {
 24335  		x.Namespace = ""
 24336  	} else {
 24337  		yyv23 := &x.Namespace
 24338  		yym24 := z.DecBinary()
 24339  		_ = yym24
 24340  		if false {
 24341  		} else {
 24342  			*((*string)(yyv23)) = r.DecodeString()
 24343  		}
 24344  	}
 24345  	yyj20++
 24346  	if yyhl20 {
 24347  		yyb20 = yyj20 > l
 24348  	} else {
 24349  		yyb20 = r.CheckBreak()
 24350  	}
 24351  	if yyb20 {
 24352  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24353  		return
 24354  	}
 24355  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24356  	if r.TryDecodeAsNil() {
 24357  		x.MinQueryIndex = 0
 24358  	} else {
 24359  		yyv25 := &x.MinQueryIndex
 24360  		yym26 := z.DecBinary()
 24361  		_ = yym26
 24362  		if false {
 24363  		} else {
 24364  			*((*uint64)(yyv25)) = uint64(r.DecodeUint(64))
 24365  		}
 24366  	}
 24367  	yyj20++
 24368  	if yyhl20 {
 24369  		yyb20 = yyj20 > l
 24370  	} else {
 24371  		yyb20 = r.CheckBreak()
 24372  	}
 24373  	if yyb20 {
 24374  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24375  		return
 24376  	}
 24377  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24378  	if r.TryDecodeAsNil() {
 24379  		x.MaxQueryTime = 0
 24380  	} else {
 24381  		yyv27 := &x.MaxQueryTime
 24382  		yym28 := z.DecBinary()
 24383  		_ = yym28
 24384  		if false {
 24385  		} else if z.HasExtensions() && z.DecExt(yyv27) {
 24386  		} else {
 24387  			*((*int64)(yyv27)) = int64(r.DecodeInt(64))
 24388  		}
 24389  	}
 24390  	yyj20++
 24391  	if yyhl20 {
 24392  		yyb20 = yyj20 > l
 24393  	} else {
 24394  		yyb20 = r.CheckBreak()
 24395  	}
 24396  	if yyb20 {
 24397  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24398  		return
 24399  	}
 24400  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24401  	if r.TryDecodeAsNil() {
 24402  		x.AllowStale = false
 24403  	} else {
 24404  		yyv29 := &x.AllowStale
 24405  		yym30 := z.DecBinary()
 24406  		_ = yym30
 24407  		if false {
 24408  		} else {
 24409  			*((*bool)(yyv29)) = r.DecodeBool()
 24410  		}
 24411  	}
 24412  	yyj20++
 24413  	if yyhl20 {
 24414  		yyb20 = yyj20 > l
 24415  	} else {
 24416  		yyb20 = r.CheckBreak()
 24417  	}
 24418  	if yyb20 {
 24419  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24420  		return
 24421  	}
 24422  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24423  	if r.TryDecodeAsNil() {
 24424  		x.Prefix = ""
 24425  	} else {
 24426  		yyv31 := &x.Prefix
 24427  		yym32 := z.DecBinary()
 24428  		_ = yym32
 24429  		if false {
 24430  		} else {
 24431  			*((*string)(yyv31)) = r.DecodeString()
 24432  		}
 24433  	}
 24434  	yyj20++
 24435  	if yyhl20 {
 24436  		yyb20 = yyj20 > l
 24437  	} else {
 24438  		yyb20 = r.CheckBreak()
 24439  	}
 24440  	if yyb20 {
 24441  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24442  		return
 24443  	}
 24444  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24445  	if r.TryDecodeAsNil() {
 24446  		x.AuthToken = ""
 24447  	} else {
 24448  		yyv33 := &x.AuthToken
 24449  		yym34 := z.DecBinary()
 24450  		_ = yym34
 24451  		if false {
 24452  		} else {
 24453  			*((*string)(yyv33)) = r.DecodeString()
 24454  		}
 24455  	}
 24456  	yyj20++
 24457  	if yyhl20 {
 24458  		yyb20 = yyj20 > l
 24459  	} else {
 24460  		yyb20 = r.CheckBreak()
 24461  	}
 24462  	if yyb20 {
 24463  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24464  		return
 24465  	}
 24466  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24467  	if r.TryDecodeAsNil() {
 24468  		x.Forwarded = false
 24469  	} else {
 24470  		yyv35 := &x.Forwarded
 24471  		yym36 := z.DecBinary()
 24472  		_ = yym36
 24473  		if false {
 24474  		} else {
 24475  			*((*bool)(yyv35)) = r.DecodeBool()
 24476  		}
 24477  	}
 24478  	for {
 24479  		yyj20++
 24480  		if yyhl20 {
 24481  			yyb20 = yyj20 > l
 24482  		} else {
 24483  			yyb20 = r.CheckBreak()
 24484  		}
 24485  		if yyb20 {
 24486  			break
 24487  		}
 24488  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24489  		z.DecStructFieldNotFound(yyj20-1, "")
 24490  	}
 24491  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24492  }
 24493  
 24494  func (x *DeploymentListRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 24495  	var h codecSelfer100
 24496  	z, r := codec1978.GenHelperEncoder(e)
 24497  	_, _, _ = h, z, r
 24498  	if x == nil {
 24499  		r.EncodeNil()
 24500  	} else {
 24501  		yym1 := z.EncBinary()
 24502  		_ = yym1
 24503  		if false {
 24504  		} else if z.HasExtensions() && z.EncExt(x) {
 24505  		} else {
 24506  			yysep2 := !z.EncBinary()
 24507  			yy2arr2 := z.EncBasicHandle().StructToArray
 24508  			var yyq2 [8]bool
 24509  			_, _, _ = yysep2, yyq2, yy2arr2
 24510  			const yyr2 bool = false
 24511  			var yynn2 int
 24512  			if yyr2 || yy2arr2 {
 24513  				r.EncodeArrayStart(8)
 24514  			} else {
 24515  				yynn2 = 8
 24516  				for _, b := range yyq2 {
 24517  					if b {
 24518  						yynn2++
 24519  					}
 24520  				}
 24521  				r.EncodeMapStart(yynn2)
 24522  				yynn2 = 0
 24523  			}
 24524  			if yyr2 || yy2arr2 {
 24525  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 24526  				yym4 := z.EncBinary()
 24527  				_ = yym4
 24528  				if false {
 24529  				} else {
 24530  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 24531  				}
 24532  			} else {
 24533  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 24534  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 24535  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 24536  				yym5 := z.EncBinary()
 24537  				_ = yym5
 24538  				if false {
 24539  				} else {
 24540  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 24541  				}
 24542  			}
 24543  			if yyr2 || yy2arr2 {
 24544  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 24545  				yym7 := z.EncBinary()
 24546  				_ = yym7
 24547  				if false {
 24548  				} else {
 24549  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 24550  				}
 24551  			} else {
 24552  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 24553  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 24554  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 24555  				yym8 := z.EncBinary()
 24556  				_ = yym8
 24557  				if false {
 24558  				} else {
 24559  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 24560  				}
 24561  			}
 24562  			if yyr2 || yy2arr2 {
 24563  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 24564  				yym10 := z.EncBinary()
 24565  				_ = yym10
 24566  				if false {
 24567  				} else {
 24568  					r.EncodeUint(uint64(x.MinQueryIndex))
 24569  				}
 24570  			} else {
 24571  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 24572  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 24573  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 24574  				yym11 := z.EncBinary()
 24575  				_ = yym11
 24576  				if false {
 24577  				} else {
 24578  					r.EncodeUint(uint64(x.MinQueryIndex))
 24579  				}
 24580  			}
 24581  			if yyr2 || yy2arr2 {
 24582  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 24583  				yym13 := z.EncBinary()
 24584  				_ = yym13
 24585  				if false {
 24586  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 24587  				} else {
 24588  					r.EncodeInt(int64(x.MaxQueryTime))
 24589  				}
 24590  			} else {
 24591  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 24592  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 24593  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 24594  				yym14 := z.EncBinary()
 24595  				_ = yym14
 24596  				if false {
 24597  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 24598  				} else {
 24599  					r.EncodeInt(int64(x.MaxQueryTime))
 24600  				}
 24601  			}
 24602  			if yyr2 || yy2arr2 {
 24603  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 24604  				yym16 := z.EncBinary()
 24605  				_ = yym16
 24606  				if false {
 24607  				} else {
 24608  					r.EncodeBool(bool(x.AllowStale))
 24609  				}
 24610  			} else {
 24611  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 24612  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 24613  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 24614  				yym17 := z.EncBinary()
 24615  				_ = yym17
 24616  				if false {
 24617  				} else {
 24618  					r.EncodeBool(bool(x.AllowStale))
 24619  				}
 24620  			}
 24621  			if yyr2 || yy2arr2 {
 24622  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 24623  				yym19 := z.EncBinary()
 24624  				_ = yym19
 24625  				if false {
 24626  				} else {
 24627  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 24628  				}
 24629  			} else {
 24630  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 24631  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 24632  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 24633  				yym20 := z.EncBinary()
 24634  				_ = yym20
 24635  				if false {
 24636  				} else {
 24637  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 24638  				}
 24639  			}
 24640  			if yyr2 || yy2arr2 {
 24641  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 24642  				yym22 := z.EncBinary()
 24643  				_ = yym22
 24644  				if false {
 24645  				} else {
 24646  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 24647  				}
 24648  			} else {
 24649  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 24650  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 24651  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 24652  				yym23 := z.EncBinary()
 24653  				_ = yym23
 24654  				if false {
 24655  				} else {
 24656  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 24657  				}
 24658  			}
 24659  			if yyr2 || yy2arr2 {
 24660  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 24661  				yym25 := z.EncBinary()
 24662  				_ = yym25
 24663  				if false {
 24664  				} else {
 24665  					r.EncodeBool(bool(x.Forwarded))
 24666  				}
 24667  			} else {
 24668  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 24669  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 24670  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 24671  				yym26 := z.EncBinary()
 24672  				_ = yym26
 24673  				if false {
 24674  				} else {
 24675  					r.EncodeBool(bool(x.Forwarded))
 24676  				}
 24677  			}
 24678  			if yyr2 || yy2arr2 {
 24679  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 24680  			} else {
 24681  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 24682  			}
 24683  		}
 24684  	}
 24685  }
 24686  
 24687  func (x *DeploymentListRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 24688  	var h codecSelfer100
 24689  	z, r := codec1978.GenHelperDecoder(d)
 24690  	_, _, _ = h, z, r
 24691  	yym1 := z.DecBinary()
 24692  	_ = yym1
 24693  	if false {
 24694  	} else if z.HasExtensions() && z.DecExt(x) {
 24695  	} else {
 24696  		yyct2 := r.ContainerType()
 24697  		if yyct2 == codecSelferValueTypeMap100 {
 24698  			yyl2 := r.ReadMapStart()
 24699  			if yyl2 == 0 {
 24700  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 24701  			} else {
 24702  				x.codecDecodeSelfFromMap(yyl2, d)
 24703  			}
 24704  		} else if yyct2 == codecSelferValueTypeArray100 {
 24705  			yyl2 := r.ReadArrayStart()
 24706  			if yyl2 == 0 {
 24707  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24708  			} else {
 24709  				x.codecDecodeSelfFromArray(yyl2, d)
 24710  			}
 24711  		} else {
 24712  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 24713  		}
 24714  	}
 24715  }
 24716  
 24717  func (x *DeploymentListRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 24718  	var h codecSelfer100
 24719  	z, r := codec1978.GenHelperDecoder(d)
 24720  	_, _, _ = h, z, r
 24721  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 24722  	_ = yys3Slc
 24723  	var yyhl3 bool = l >= 0
 24724  	for yyj3 := 0; ; yyj3++ {
 24725  		if yyhl3 {
 24726  			if yyj3 >= l {
 24727  				break
 24728  			}
 24729  		} else {
 24730  			if r.CheckBreak() {
 24731  				break
 24732  			}
 24733  		}
 24734  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 24735  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 24736  		yys3 := string(yys3Slc)
 24737  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 24738  		switch yys3 {
 24739  		case "Region":
 24740  			if r.TryDecodeAsNil() {
 24741  				x.Region = ""
 24742  			} else {
 24743  				yyv4 := &x.Region
 24744  				yym5 := z.DecBinary()
 24745  				_ = yym5
 24746  				if false {
 24747  				} else {
 24748  					*((*string)(yyv4)) = r.DecodeString()
 24749  				}
 24750  			}
 24751  		case "Namespace":
 24752  			if r.TryDecodeAsNil() {
 24753  				x.Namespace = ""
 24754  			} else {
 24755  				yyv6 := &x.Namespace
 24756  				yym7 := z.DecBinary()
 24757  				_ = yym7
 24758  				if false {
 24759  				} else {
 24760  					*((*string)(yyv6)) = r.DecodeString()
 24761  				}
 24762  			}
 24763  		case "MinQueryIndex":
 24764  			if r.TryDecodeAsNil() {
 24765  				x.MinQueryIndex = 0
 24766  			} else {
 24767  				yyv8 := &x.MinQueryIndex
 24768  				yym9 := z.DecBinary()
 24769  				_ = yym9
 24770  				if false {
 24771  				} else {
 24772  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 24773  				}
 24774  			}
 24775  		case "MaxQueryTime":
 24776  			if r.TryDecodeAsNil() {
 24777  				x.MaxQueryTime = 0
 24778  			} else {
 24779  				yyv10 := &x.MaxQueryTime
 24780  				yym11 := z.DecBinary()
 24781  				_ = yym11
 24782  				if false {
 24783  				} else if z.HasExtensions() && z.DecExt(yyv10) {
 24784  				} else {
 24785  					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
 24786  				}
 24787  			}
 24788  		case "AllowStale":
 24789  			if r.TryDecodeAsNil() {
 24790  				x.AllowStale = false
 24791  			} else {
 24792  				yyv12 := &x.AllowStale
 24793  				yym13 := z.DecBinary()
 24794  				_ = yym13
 24795  				if false {
 24796  				} else {
 24797  					*((*bool)(yyv12)) = r.DecodeBool()
 24798  				}
 24799  			}
 24800  		case "Prefix":
 24801  			if r.TryDecodeAsNil() {
 24802  				x.Prefix = ""
 24803  			} else {
 24804  				yyv14 := &x.Prefix
 24805  				yym15 := z.DecBinary()
 24806  				_ = yym15
 24807  				if false {
 24808  				} else {
 24809  					*((*string)(yyv14)) = r.DecodeString()
 24810  				}
 24811  			}
 24812  		case "AuthToken":
 24813  			if r.TryDecodeAsNil() {
 24814  				x.AuthToken = ""
 24815  			} else {
 24816  				yyv16 := &x.AuthToken
 24817  				yym17 := z.DecBinary()
 24818  				_ = yym17
 24819  				if false {
 24820  				} else {
 24821  					*((*string)(yyv16)) = r.DecodeString()
 24822  				}
 24823  			}
 24824  		case "Forwarded":
 24825  			if r.TryDecodeAsNil() {
 24826  				x.Forwarded = false
 24827  			} else {
 24828  				yyv18 := &x.Forwarded
 24829  				yym19 := z.DecBinary()
 24830  				_ = yym19
 24831  				if false {
 24832  				} else {
 24833  					*((*bool)(yyv18)) = r.DecodeBool()
 24834  				}
 24835  			}
 24836  		default:
 24837  			z.DecStructFieldNotFound(-1, yys3)
 24838  		} // end switch yys3
 24839  	} // end for yyj3
 24840  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 24841  }
 24842  
 24843  func (x *DeploymentListRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 24844  	var h codecSelfer100
 24845  	z, r := codec1978.GenHelperDecoder(d)
 24846  	_, _, _ = h, z, r
 24847  	var yyj20 int
 24848  	var yyb20 bool
 24849  	var yyhl20 bool = l >= 0
 24850  	yyj20++
 24851  	if yyhl20 {
 24852  		yyb20 = yyj20 > l
 24853  	} else {
 24854  		yyb20 = r.CheckBreak()
 24855  	}
 24856  	if yyb20 {
 24857  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24858  		return
 24859  	}
 24860  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24861  	if r.TryDecodeAsNil() {
 24862  		x.Region = ""
 24863  	} else {
 24864  		yyv21 := &x.Region
 24865  		yym22 := z.DecBinary()
 24866  		_ = yym22
 24867  		if false {
 24868  		} else {
 24869  			*((*string)(yyv21)) = r.DecodeString()
 24870  		}
 24871  	}
 24872  	yyj20++
 24873  	if yyhl20 {
 24874  		yyb20 = yyj20 > l
 24875  	} else {
 24876  		yyb20 = r.CheckBreak()
 24877  	}
 24878  	if yyb20 {
 24879  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24880  		return
 24881  	}
 24882  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24883  	if r.TryDecodeAsNil() {
 24884  		x.Namespace = ""
 24885  	} else {
 24886  		yyv23 := &x.Namespace
 24887  		yym24 := z.DecBinary()
 24888  		_ = yym24
 24889  		if false {
 24890  		} else {
 24891  			*((*string)(yyv23)) = r.DecodeString()
 24892  		}
 24893  	}
 24894  	yyj20++
 24895  	if yyhl20 {
 24896  		yyb20 = yyj20 > l
 24897  	} else {
 24898  		yyb20 = r.CheckBreak()
 24899  	}
 24900  	if yyb20 {
 24901  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24902  		return
 24903  	}
 24904  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24905  	if r.TryDecodeAsNil() {
 24906  		x.MinQueryIndex = 0
 24907  	} else {
 24908  		yyv25 := &x.MinQueryIndex
 24909  		yym26 := z.DecBinary()
 24910  		_ = yym26
 24911  		if false {
 24912  		} else {
 24913  			*((*uint64)(yyv25)) = uint64(r.DecodeUint(64))
 24914  		}
 24915  	}
 24916  	yyj20++
 24917  	if yyhl20 {
 24918  		yyb20 = yyj20 > l
 24919  	} else {
 24920  		yyb20 = r.CheckBreak()
 24921  	}
 24922  	if yyb20 {
 24923  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24924  		return
 24925  	}
 24926  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24927  	if r.TryDecodeAsNil() {
 24928  		x.MaxQueryTime = 0
 24929  	} else {
 24930  		yyv27 := &x.MaxQueryTime
 24931  		yym28 := z.DecBinary()
 24932  		_ = yym28
 24933  		if false {
 24934  		} else if z.HasExtensions() && z.DecExt(yyv27) {
 24935  		} else {
 24936  			*((*int64)(yyv27)) = int64(r.DecodeInt(64))
 24937  		}
 24938  	}
 24939  	yyj20++
 24940  	if yyhl20 {
 24941  		yyb20 = yyj20 > l
 24942  	} else {
 24943  		yyb20 = r.CheckBreak()
 24944  	}
 24945  	if yyb20 {
 24946  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24947  		return
 24948  	}
 24949  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24950  	if r.TryDecodeAsNil() {
 24951  		x.AllowStale = false
 24952  	} else {
 24953  		yyv29 := &x.AllowStale
 24954  		yym30 := z.DecBinary()
 24955  		_ = yym30
 24956  		if false {
 24957  		} else {
 24958  			*((*bool)(yyv29)) = r.DecodeBool()
 24959  		}
 24960  	}
 24961  	yyj20++
 24962  	if yyhl20 {
 24963  		yyb20 = yyj20 > l
 24964  	} else {
 24965  		yyb20 = r.CheckBreak()
 24966  	}
 24967  	if yyb20 {
 24968  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24969  		return
 24970  	}
 24971  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24972  	if r.TryDecodeAsNil() {
 24973  		x.Prefix = ""
 24974  	} else {
 24975  		yyv31 := &x.Prefix
 24976  		yym32 := z.DecBinary()
 24977  		_ = yym32
 24978  		if false {
 24979  		} else {
 24980  			*((*string)(yyv31)) = r.DecodeString()
 24981  		}
 24982  	}
 24983  	yyj20++
 24984  	if yyhl20 {
 24985  		yyb20 = yyj20 > l
 24986  	} else {
 24987  		yyb20 = r.CheckBreak()
 24988  	}
 24989  	if yyb20 {
 24990  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 24991  		return
 24992  	}
 24993  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 24994  	if r.TryDecodeAsNil() {
 24995  		x.AuthToken = ""
 24996  	} else {
 24997  		yyv33 := &x.AuthToken
 24998  		yym34 := z.DecBinary()
 24999  		_ = yym34
 25000  		if false {
 25001  		} else {
 25002  			*((*string)(yyv33)) = r.DecodeString()
 25003  		}
 25004  	}
 25005  	yyj20++
 25006  	if yyhl20 {
 25007  		yyb20 = yyj20 > l
 25008  	} else {
 25009  		yyb20 = r.CheckBreak()
 25010  	}
 25011  	if yyb20 {
 25012  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 25013  		return
 25014  	}
 25015  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 25016  	if r.TryDecodeAsNil() {
 25017  		x.Forwarded = false
 25018  	} else {
 25019  		yyv35 := &x.Forwarded
 25020  		yym36 := z.DecBinary()
 25021  		_ = yym36
 25022  		if false {
 25023  		} else {
 25024  			*((*bool)(yyv35)) = r.DecodeBool()
 25025  		}
 25026  	}
 25027  	for {
 25028  		yyj20++
 25029  		if yyhl20 {
 25030  			yyb20 = yyj20 > l
 25031  		} else {
 25032  			yyb20 = r.CheckBreak()
 25033  		}
 25034  		if yyb20 {
 25035  			break
 25036  		}
 25037  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 25038  		z.DecStructFieldNotFound(yyj20-1, "")
 25039  	}
 25040  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 25041  }
 25042  
 25043  func (x *DeploymentDeleteRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 25044  	var h codecSelfer100
 25045  	z, r := codec1978.GenHelperEncoder(e)
 25046  	_, _, _ = h, z, r
 25047  	if x == nil {
 25048  		r.EncodeNil()
 25049  	} else {
 25050  		yym1 := z.EncBinary()
 25051  		_ = yym1
 25052  		if false {
 25053  		} else if z.HasExtensions() && z.EncExt(x) {
 25054  		} else {
 25055  			yysep2 := !z.EncBinary()
 25056  			yy2arr2 := z.EncBasicHandle().StructToArray
 25057  			var yyq2 [5]bool
 25058  			_, _, _ = yysep2, yyq2, yy2arr2
 25059  			const yyr2 bool = false
 25060  			var yynn2 int
 25061  			if yyr2 || yy2arr2 {
 25062  				r.EncodeArrayStart(5)
 25063  			} else {
 25064  				yynn2 = 5
 25065  				for _, b := range yyq2 {
 25066  					if b {
 25067  						yynn2++
 25068  					}
 25069  				}
 25070  				r.EncodeMapStart(yynn2)
 25071  				yynn2 = 0
 25072  			}
 25073  			if yyr2 || yy2arr2 {
 25074  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 25075  				if x.Deployments == nil {
 25076  					r.EncodeNil()
 25077  				} else {
 25078  					yym4 := z.EncBinary()
 25079  					_ = yym4
 25080  					if false {
 25081  					} else {
 25082  						z.F.EncSliceStringV(x.Deployments, false, e)
 25083  					}
 25084  				}
 25085  			} else {
 25086  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 25087  				r.EncodeString(codecSelferC_UTF8100, string("Deployments"))
 25088  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 25089  				if x.Deployments == nil {
 25090  					r.EncodeNil()
 25091  				} else {
 25092  					yym5 := z.EncBinary()
 25093  					_ = yym5
 25094  					if false {
 25095  					} else {
 25096  						z.F.EncSliceStringV(x.Deployments, false, e)
 25097  					}
 25098  				}
 25099  			}
 25100  			if yyr2 || yy2arr2 {
 25101  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 25102  				yym7 := z.EncBinary()
 25103  				_ = yym7
 25104  				if false {
 25105  				} else {
 25106  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 25107  				}
 25108  			} else {
 25109  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 25110  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 25111  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 25112  				yym8 := z.EncBinary()
 25113  				_ = yym8
 25114  				if false {
 25115  				} else {
 25116  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 25117  				}
 25118  			}
 25119  			if yyr2 || yy2arr2 {
 25120  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 25121  				yym10 := z.EncBinary()
 25122  				_ = yym10
 25123  				if false {
 25124  				} else {
 25125  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 25126  				}
 25127  			} else {
 25128  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 25129  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 25130  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 25131  				yym11 := z.EncBinary()
 25132  				_ = yym11
 25133  				if false {
 25134  				} else {
 25135  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 25136  				}
 25137  			}
 25138  			if yyr2 || yy2arr2 {
 25139  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 25140  				yym13 := z.EncBinary()
 25141  				_ = yym13
 25142  				if false {
 25143  				} else {
 25144  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 25145  				}
 25146  			} else {
 25147  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 25148  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 25149  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 25150  				yym14 := z.EncBinary()
 25151  				_ = yym14
 25152  				if false {
 25153  				} else {
 25154  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 25155  				}
 25156  			}
 25157  			if yyr2 || yy2arr2 {
 25158  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 25159  				yym16 := z.EncBinary()
 25160  				_ = yym16
 25161  				if false {
 25162  				} else {
 25163  					r.EncodeBool(bool(x.Forwarded))
 25164  				}
 25165  			} else {
 25166  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 25167  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 25168  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 25169  				yym17 := z.EncBinary()
 25170  				_ = yym17
 25171  				if false {
 25172  				} else {
 25173  					r.EncodeBool(bool(x.Forwarded))
 25174  				}
 25175  			}
 25176  			if yyr2 || yy2arr2 {
 25177  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 25178  			} else {
 25179  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 25180  			}
 25181  		}
 25182  	}
 25183  }
 25184  
 25185  func (x *DeploymentDeleteRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 25186  	var h codecSelfer100
 25187  	z, r := codec1978.GenHelperDecoder(d)
 25188  	_, _, _ = h, z, r
 25189  	yym1 := z.DecBinary()
 25190  	_ = yym1
 25191  	if false {
 25192  	} else if z.HasExtensions() && z.DecExt(x) {
 25193  	} else {
 25194  		yyct2 := r.ContainerType()
 25195  		if yyct2 == codecSelferValueTypeMap100 {
 25196  			yyl2 := r.ReadMapStart()
 25197  			if yyl2 == 0 {
 25198  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 25199  			} else {
 25200  				x.codecDecodeSelfFromMap(yyl2, d)
 25201  			}
 25202  		} else if yyct2 == codecSelferValueTypeArray100 {
 25203  			yyl2 := r.ReadArrayStart()
 25204  			if yyl2 == 0 {
 25205  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 25206  			} else {
 25207  				x.codecDecodeSelfFromArray(yyl2, d)
 25208  			}
 25209  		} else {
 25210  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 25211  		}
 25212  	}
 25213  }
 25214  
 25215  func (x *DeploymentDeleteRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 25216  	var h codecSelfer100
 25217  	z, r := codec1978.GenHelperDecoder(d)
 25218  	_, _, _ = h, z, r
 25219  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 25220  	_ = yys3Slc
 25221  	var yyhl3 bool = l >= 0
 25222  	for yyj3 := 0; ; yyj3++ {
 25223  		if yyhl3 {
 25224  			if yyj3 >= l {
 25225  				break
 25226  			}
 25227  		} else {
 25228  			if r.CheckBreak() {
 25229  				break
 25230  			}
 25231  		}
 25232  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 25233  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 25234  		yys3 := string(yys3Slc)
 25235  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 25236  		switch yys3 {
 25237  		case "Deployments":
 25238  			if r.TryDecodeAsNil() {
 25239  				x.Deployments = nil
 25240  			} else {
 25241  				yyv4 := &x.Deployments
 25242  				yym5 := z.DecBinary()
 25243  				_ = yym5
 25244  				if false {
 25245  				} else {
 25246  					z.F.DecSliceStringX(yyv4, false, d)
 25247  				}
 25248  			}
 25249  		case "Region":
 25250  			if r.TryDecodeAsNil() {
 25251  				x.Region = ""
 25252  			} else {
 25253  				yyv6 := &x.Region
 25254  				yym7 := z.DecBinary()
 25255  				_ = yym7
 25256  				if false {
 25257  				} else {
 25258  					*((*string)(yyv6)) = r.DecodeString()
 25259  				}
 25260  			}
 25261  		case "Namespace":
 25262  			if r.TryDecodeAsNil() {
 25263  				x.Namespace = ""
 25264  			} else {
 25265  				yyv8 := &x.Namespace
 25266  				yym9 := z.DecBinary()
 25267  				_ = yym9
 25268  				if false {
 25269  				} else {
 25270  					*((*string)(yyv8)) = r.DecodeString()
 25271  				}
 25272  			}
 25273  		case "AuthToken":
 25274  			if r.TryDecodeAsNil() {
 25275  				x.AuthToken = ""
 25276  			} else {
 25277  				yyv10 := &x.AuthToken
 25278  				yym11 := z.DecBinary()
 25279  				_ = yym11
 25280  				if false {
 25281  				} else {
 25282  					*((*string)(yyv10)) = r.DecodeString()
 25283  				}
 25284  			}
 25285  		case "Forwarded":
 25286  			if r.TryDecodeAsNil() {
 25287  				x.Forwarded = false
 25288  			} else {
 25289  				yyv12 := &x.Forwarded
 25290  				yym13 := z.DecBinary()
 25291  				_ = yym13
 25292  				if false {
 25293  				} else {
 25294  					*((*bool)(yyv12)) = r.DecodeBool()
 25295  				}
 25296  			}
 25297  		default:
 25298  			z.DecStructFieldNotFound(-1, yys3)
 25299  		} // end switch yys3
 25300  	} // end for yyj3
 25301  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 25302  }
 25303  
 25304  func (x *DeploymentDeleteRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 25305  	var h codecSelfer100
 25306  	z, r := codec1978.GenHelperDecoder(d)
 25307  	_, _, _ = h, z, r
 25308  	var yyj14 int
 25309  	var yyb14 bool
 25310  	var yyhl14 bool = l >= 0
 25311  	yyj14++
 25312  	if yyhl14 {
 25313  		yyb14 = yyj14 > l
 25314  	} else {
 25315  		yyb14 = r.CheckBreak()
 25316  	}
 25317  	if yyb14 {
 25318  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 25319  		return
 25320  	}
 25321  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 25322  	if r.TryDecodeAsNil() {
 25323  		x.Deployments = nil
 25324  	} else {
 25325  		yyv15 := &x.Deployments
 25326  		yym16 := z.DecBinary()
 25327  		_ = yym16
 25328  		if false {
 25329  		} else {
 25330  			z.F.DecSliceStringX(yyv15, false, d)
 25331  		}
 25332  	}
 25333  	yyj14++
 25334  	if yyhl14 {
 25335  		yyb14 = yyj14 > l
 25336  	} else {
 25337  		yyb14 = r.CheckBreak()
 25338  	}
 25339  	if yyb14 {
 25340  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 25341  		return
 25342  	}
 25343  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 25344  	if r.TryDecodeAsNil() {
 25345  		x.Region = ""
 25346  	} else {
 25347  		yyv17 := &x.Region
 25348  		yym18 := z.DecBinary()
 25349  		_ = yym18
 25350  		if false {
 25351  		} else {
 25352  			*((*string)(yyv17)) = r.DecodeString()
 25353  		}
 25354  	}
 25355  	yyj14++
 25356  	if yyhl14 {
 25357  		yyb14 = yyj14 > l
 25358  	} else {
 25359  		yyb14 = r.CheckBreak()
 25360  	}
 25361  	if yyb14 {
 25362  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 25363  		return
 25364  	}
 25365  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 25366  	if r.TryDecodeAsNil() {
 25367  		x.Namespace = ""
 25368  	} else {
 25369  		yyv19 := &x.Namespace
 25370  		yym20 := z.DecBinary()
 25371  		_ = yym20
 25372  		if false {
 25373  		} else {
 25374  			*((*string)(yyv19)) = r.DecodeString()
 25375  		}
 25376  	}
 25377  	yyj14++
 25378  	if yyhl14 {
 25379  		yyb14 = yyj14 > l
 25380  	} else {
 25381  		yyb14 = r.CheckBreak()
 25382  	}
 25383  	if yyb14 {
 25384  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 25385  		return
 25386  	}
 25387  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 25388  	if r.TryDecodeAsNil() {
 25389  		x.AuthToken = ""
 25390  	} else {
 25391  		yyv21 := &x.AuthToken
 25392  		yym22 := z.DecBinary()
 25393  		_ = yym22
 25394  		if false {
 25395  		} else {
 25396  			*((*string)(yyv21)) = r.DecodeString()
 25397  		}
 25398  	}
 25399  	yyj14++
 25400  	if yyhl14 {
 25401  		yyb14 = yyj14 > l
 25402  	} else {
 25403  		yyb14 = r.CheckBreak()
 25404  	}
 25405  	if yyb14 {
 25406  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 25407  		return
 25408  	}
 25409  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 25410  	if r.TryDecodeAsNil() {
 25411  		x.Forwarded = false
 25412  	} else {
 25413  		yyv23 := &x.Forwarded
 25414  		yym24 := z.DecBinary()
 25415  		_ = yym24
 25416  		if false {
 25417  		} else {
 25418  			*((*bool)(yyv23)) = r.DecodeBool()
 25419  		}
 25420  	}
 25421  	for {
 25422  		yyj14++
 25423  		if yyhl14 {
 25424  			yyb14 = yyj14 > l
 25425  		} else {
 25426  			yyb14 = r.CheckBreak()
 25427  		}
 25428  		if yyb14 {
 25429  			break
 25430  		}
 25431  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 25432  		z.DecStructFieldNotFound(yyj14-1, "")
 25433  	}
 25434  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 25435  }
 25436  
 25437  func (x *DeploymentStatusUpdateRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 25438  	var h codecSelfer100
 25439  	z, r := codec1978.GenHelperEncoder(e)
 25440  	_, _, _ = h, z, r
 25441  	if x == nil {
 25442  		r.EncodeNil()
 25443  	} else {
 25444  		yym1 := z.EncBinary()
 25445  		_ = yym1
 25446  		if false {
 25447  		} else if z.HasExtensions() && z.EncExt(x) {
 25448  		} else {
 25449  			yysep2 := !z.EncBinary()
 25450  			yy2arr2 := z.EncBasicHandle().StructToArray
 25451  			var yyq2 [3]bool
 25452  			_, _, _ = yysep2, yyq2, yy2arr2
 25453  			const yyr2 bool = false
 25454  			var yynn2 int
 25455  			if yyr2 || yy2arr2 {
 25456  				r.EncodeArrayStart(3)
 25457  			} else {
 25458  				yynn2 = 3
 25459  				for _, b := range yyq2 {
 25460  					if b {
 25461  						yynn2++
 25462  					}
 25463  				}
 25464  				r.EncodeMapStart(yynn2)
 25465  				yynn2 = 0
 25466  			}
 25467  			if yyr2 || yy2arr2 {
 25468  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 25469  				if x.Eval == nil {
 25470  					r.EncodeNil()
 25471  				} else {
 25472  					x.Eval.CodecEncodeSelf(e)
 25473  				}
 25474  			} else {
 25475  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 25476  				r.EncodeString(codecSelferC_UTF8100, string("Eval"))
 25477  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 25478  				if x.Eval == nil {
 25479  					r.EncodeNil()
 25480  				} else {
 25481  					x.Eval.CodecEncodeSelf(e)
 25482  				}
 25483  			}
 25484  			if yyr2 || yy2arr2 {
 25485  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 25486  				if x.DeploymentUpdate == nil {
 25487  					r.EncodeNil()
 25488  				} else {
 25489  					x.DeploymentUpdate.CodecEncodeSelf(e)
 25490  				}
 25491  			} else {
 25492  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 25493  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentUpdate"))
 25494  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 25495  				if x.DeploymentUpdate == nil {
 25496  					r.EncodeNil()
 25497  				} else {
 25498  					x.DeploymentUpdate.CodecEncodeSelf(e)
 25499  				}
 25500  			}
 25501  			if yyr2 || yy2arr2 {
 25502  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 25503  				if x.Job == nil {
 25504  					r.EncodeNil()
 25505  				} else {
 25506  					x.Job.CodecEncodeSelf(e)
 25507  				}
 25508  			} else {
 25509  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 25510  				r.EncodeString(codecSelferC_UTF8100, string("Job"))
 25511  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 25512  				if x.Job == nil {
 25513  					r.EncodeNil()
 25514  				} else {
 25515  					x.Job.CodecEncodeSelf(e)
 25516  				}
 25517  			}
 25518  			if yyr2 || yy2arr2 {
 25519  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 25520  			} else {
 25521  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 25522  			}
 25523  		}
 25524  	}
 25525  }
 25526  
 25527  func (x *DeploymentStatusUpdateRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 25528  	var h codecSelfer100
 25529  	z, r := codec1978.GenHelperDecoder(d)
 25530  	_, _, _ = h, z, r
 25531  	yym1 := z.DecBinary()
 25532  	_ = yym1
 25533  	if false {
 25534  	} else if z.HasExtensions() && z.DecExt(x) {
 25535  	} else {
 25536  		yyct2 := r.ContainerType()
 25537  		if yyct2 == codecSelferValueTypeMap100 {
 25538  			yyl2 := r.ReadMapStart()
 25539  			if yyl2 == 0 {
 25540  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 25541  			} else {
 25542  				x.codecDecodeSelfFromMap(yyl2, d)
 25543  			}
 25544  		} else if yyct2 == codecSelferValueTypeArray100 {
 25545  			yyl2 := r.ReadArrayStart()
 25546  			if yyl2 == 0 {
 25547  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 25548  			} else {
 25549  				x.codecDecodeSelfFromArray(yyl2, d)
 25550  			}
 25551  		} else {
 25552  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 25553  		}
 25554  	}
 25555  }
 25556  
 25557  func (x *DeploymentStatusUpdateRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 25558  	var h codecSelfer100
 25559  	z, r := codec1978.GenHelperDecoder(d)
 25560  	_, _, _ = h, z, r
 25561  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 25562  	_ = yys3Slc
 25563  	var yyhl3 bool = l >= 0
 25564  	for yyj3 := 0; ; yyj3++ {
 25565  		if yyhl3 {
 25566  			if yyj3 >= l {
 25567  				break
 25568  			}
 25569  		} else {
 25570  			if r.CheckBreak() {
 25571  				break
 25572  			}
 25573  		}
 25574  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 25575  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 25576  		yys3 := string(yys3Slc)
 25577  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 25578  		switch yys3 {
 25579  		case "Eval":
 25580  			if r.TryDecodeAsNil() {
 25581  				if x.Eval != nil {
 25582  					x.Eval = nil
 25583  				}
 25584  			} else {
 25585  				if x.Eval == nil {
 25586  					x.Eval = new(Evaluation)
 25587  				}
 25588  				x.Eval.CodecDecodeSelf(d)
 25589  			}
 25590  		case "DeploymentUpdate":
 25591  			if r.TryDecodeAsNil() {
 25592  				if x.DeploymentUpdate != nil {
 25593  					x.DeploymentUpdate = nil
 25594  				}
 25595  			} else {
 25596  				if x.DeploymentUpdate == nil {
 25597  					x.DeploymentUpdate = new(DeploymentStatusUpdate)
 25598  				}
 25599  				x.DeploymentUpdate.CodecDecodeSelf(d)
 25600  			}
 25601  		case "Job":
 25602  			if r.TryDecodeAsNil() {
 25603  				if x.Job != nil {
 25604  					x.Job = nil
 25605  				}
 25606  			} else {
 25607  				if x.Job == nil {
 25608  					x.Job = new(Job)
 25609  				}
 25610  				x.Job.CodecDecodeSelf(d)
 25611  			}
 25612  		default:
 25613  			z.DecStructFieldNotFound(-1, yys3)
 25614  		} // end switch yys3
 25615  	} // end for yyj3
 25616  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 25617  }
 25618  
 25619  func (x *DeploymentStatusUpdateRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 25620  	var h codecSelfer100
 25621  	z, r := codec1978.GenHelperDecoder(d)
 25622  	_, _, _ = h, z, r
 25623  	var yyj7 int
 25624  	var yyb7 bool
 25625  	var yyhl7 bool = l >= 0
 25626  	yyj7++
 25627  	if yyhl7 {
 25628  		yyb7 = yyj7 > l
 25629  	} else {
 25630  		yyb7 = r.CheckBreak()
 25631  	}
 25632  	if yyb7 {
 25633  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 25634  		return
 25635  	}
 25636  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 25637  	if r.TryDecodeAsNil() {
 25638  		if x.Eval != nil {
 25639  			x.Eval = nil
 25640  		}
 25641  	} else {
 25642  		if x.Eval == nil {
 25643  			x.Eval = new(Evaluation)
 25644  		}
 25645  		x.Eval.CodecDecodeSelf(d)
 25646  	}
 25647  	yyj7++
 25648  	if yyhl7 {
 25649  		yyb7 = yyj7 > l
 25650  	} else {
 25651  		yyb7 = r.CheckBreak()
 25652  	}
 25653  	if yyb7 {
 25654  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 25655  		return
 25656  	}
 25657  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 25658  	if r.TryDecodeAsNil() {
 25659  		if x.DeploymentUpdate != nil {
 25660  			x.DeploymentUpdate = nil
 25661  		}
 25662  	} else {
 25663  		if x.DeploymentUpdate == nil {
 25664  			x.DeploymentUpdate = new(DeploymentStatusUpdate)
 25665  		}
 25666  		x.DeploymentUpdate.CodecDecodeSelf(d)
 25667  	}
 25668  	yyj7++
 25669  	if yyhl7 {
 25670  		yyb7 = yyj7 > l
 25671  	} else {
 25672  		yyb7 = r.CheckBreak()
 25673  	}
 25674  	if yyb7 {
 25675  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 25676  		return
 25677  	}
 25678  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 25679  	if r.TryDecodeAsNil() {
 25680  		if x.Job != nil {
 25681  			x.Job = nil
 25682  		}
 25683  	} else {
 25684  		if x.Job == nil {
 25685  			x.Job = new(Job)
 25686  		}
 25687  		x.Job.CodecDecodeSelf(d)
 25688  	}
 25689  	for {
 25690  		yyj7++
 25691  		if yyhl7 {
 25692  			yyb7 = yyj7 > l
 25693  		} else {
 25694  			yyb7 = r.CheckBreak()
 25695  		}
 25696  		if yyb7 {
 25697  			break
 25698  		}
 25699  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 25700  		z.DecStructFieldNotFound(yyj7-1, "")
 25701  	}
 25702  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 25703  }
 25704  
 25705  func (x *DeploymentAllocHealthRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 25706  	var h codecSelfer100
 25707  	z, r := codec1978.GenHelperEncoder(e)
 25708  	_, _, _ = h, z, r
 25709  	if x == nil {
 25710  		r.EncodeNil()
 25711  	} else {
 25712  		yym1 := z.EncBinary()
 25713  		_ = yym1
 25714  		if false {
 25715  		} else if z.HasExtensions() && z.EncExt(x) {
 25716  		} else {
 25717  			yysep2 := !z.EncBinary()
 25718  			yy2arr2 := z.EncBasicHandle().StructToArray
 25719  			var yyq2 [7]bool
 25720  			_, _, _ = yysep2, yyq2, yy2arr2
 25721  			const yyr2 bool = false
 25722  			var yynn2 int
 25723  			if yyr2 || yy2arr2 {
 25724  				r.EncodeArrayStart(7)
 25725  			} else {
 25726  				yynn2 = 7
 25727  				for _, b := range yyq2 {
 25728  					if b {
 25729  						yynn2++
 25730  					}
 25731  				}
 25732  				r.EncodeMapStart(yynn2)
 25733  				yynn2 = 0
 25734  			}
 25735  			if yyr2 || yy2arr2 {
 25736  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 25737  				yym4 := z.EncBinary()
 25738  				_ = yym4
 25739  				if false {
 25740  				} else {
 25741  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 25742  				}
 25743  			} else {
 25744  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 25745  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentID"))
 25746  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 25747  				yym5 := z.EncBinary()
 25748  				_ = yym5
 25749  				if false {
 25750  				} else {
 25751  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 25752  				}
 25753  			}
 25754  			if yyr2 || yy2arr2 {
 25755  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 25756  				if x.HealthyAllocationIDs == nil {
 25757  					r.EncodeNil()
 25758  				} else {
 25759  					yym7 := z.EncBinary()
 25760  					_ = yym7
 25761  					if false {
 25762  					} else {
 25763  						z.F.EncSliceStringV(x.HealthyAllocationIDs, false, e)
 25764  					}
 25765  				}
 25766  			} else {
 25767  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 25768  				r.EncodeString(codecSelferC_UTF8100, string("HealthyAllocationIDs"))
 25769  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 25770  				if x.HealthyAllocationIDs == nil {
 25771  					r.EncodeNil()
 25772  				} else {
 25773  					yym8 := z.EncBinary()
 25774  					_ = yym8
 25775  					if false {
 25776  					} else {
 25777  						z.F.EncSliceStringV(x.HealthyAllocationIDs, false, e)
 25778  					}
 25779  				}
 25780  			}
 25781  			if yyr2 || yy2arr2 {
 25782  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 25783  				if x.UnhealthyAllocationIDs == nil {
 25784  					r.EncodeNil()
 25785  				} else {
 25786  					yym10 := z.EncBinary()
 25787  					_ = yym10
 25788  					if false {
 25789  					} else {
 25790  						z.F.EncSliceStringV(x.UnhealthyAllocationIDs, false, e)
 25791  					}
 25792  				}
 25793  			} else {
 25794  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 25795  				r.EncodeString(codecSelferC_UTF8100, string("UnhealthyAllocationIDs"))
 25796  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 25797  				if x.UnhealthyAllocationIDs == nil {
 25798  					r.EncodeNil()
 25799  				} else {
 25800  					yym11 := z.EncBinary()
 25801  					_ = yym11
 25802  					if false {
 25803  					} else {
 25804  						z.F.EncSliceStringV(x.UnhealthyAllocationIDs, false, e)
 25805  					}
 25806  				}
 25807  			}
 25808  			if yyr2 || yy2arr2 {
 25809  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 25810  				yym13 := z.EncBinary()
 25811  				_ = yym13
 25812  				if false {
 25813  				} else {
 25814  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 25815  				}
 25816  			} else {
 25817  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 25818  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 25819  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 25820  				yym14 := z.EncBinary()
 25821  				_ = yym14
 25822  				if false {
 25823  				} else {
 25824  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 25825  				}
 25826  			}
 25827  			if yyr2 || yy2arr2 {
 25828  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 25829  				yym16 := z.EncBinary()
 25830  				_ = yym16
 25831  				if false {
 25832  				} else {
 25833  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 25834  				}
 25835  			} else {
 25836  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 25837  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 25838  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 25839  				yym17 := z.EncBinary()
 25840  				_ = yym17
 25841  				if false {
 25842  				} else {
 25843  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 25844  				}
 25845  			}
 25846  			if yyr2 || yy2arr2 {
 25847  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 25848  				yym19 := z.EncBinary()
 25849  				_ = yym19
 25850  				if false {
 25851  				} else {
 25852  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 25853  				}
 25854  			} else {
 25855  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 25856  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 25857  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 25858  				yym20 := z.EncBinary()
 25859  				_ = yym20
 25860  				if false {
 25861  				} else {
 25862  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 25863  				}
 25864  			}
 25865  			if yyr2 || yy2arr2 {
 25866  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 25867  				yym22 := z.EncBinary()
 25868  				_ = yym22
 25869  				if false {
 25870  				} else {
 25871  					r.EncodeBool(bool(x.Forwarded))
 25872  				}
 25873  			} else {
 25874  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 25875  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 25876  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 25877  				yym23 := z.EncBinary()
 25878  				_ = yym23
 25879  				if false {
 25880  				} else {
 25881  					r.EncodeBool(bool(x.Forwarded))
 25882  				}
 25883  			}
 25884  			if yyr2 || yy2arr2 {
 25885  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 25886  			} else {
 25887  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 25888  			}
 25889  		}
 25890  	}
 25891  }
 25892  
 25893  func (x *DeploymentAllocHealthRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 25894  	var h codecSelfer100
 25895  	z, r := codec1978.GenHelperDecoder(d)
 25896  	_, _, _ = h, z, r
 25897  	yym1 := z.DecBinary()
 25898  	_ = yym1
 25899  	if false {
 25900  	} else if z.HasExtensions() && z.DecExt(x) {
 25901  	} else {
 25902  		yyct2 := r.ContainerType()
 25903  		if yyct2 == codecSelferValueTypeMap100 {
 25904  			yyl2 := r.ReadMapStart()
 25905  			if yyl2 == 0 {
 25906  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 25907  			} else {
 25908  				x.codecDecodeSelfFromMap(yyl2, d)
 25909  			}
 25910  		} else if yyct2 == codecSelferValueTypeArray100 {
 25911  			yyl2 := r.ReadArrayStart()
 25912  			if yyl2 == 0 {
 25913  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 25914  			} else {
 25915  				x.codecDecodeSelfFromArray(yyl2, d)
 25916  			}
 25917  		} else {
 25918  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 25919  		}
 25920  	}
 25921  }
 25922  
 25923  func (x *DeploymentAllocHealthRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 25924  	var h codecSelfer100
 25925  	z, r := codec1978.GenHelperDecoder(d)
 25926  	_, _, _ = h, z, r
 25927  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 25928  	_ = yys3Slc
 25929  	var yyhl3 bool = l >= 0
 25930  	for yyj3 := 0; ; yyj3++ {
 25931  		if yyhl3 {
 25932  			if yyj3 >= l {
 25933  				break
 25934  			}
 25935  		} else {
 25936  			if r.CheckBreak() {
 25937  				break
 25938  			}
 25939  		}
 25940  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 25941  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 25942  		yys3 := string(yys3Slc)
 25943  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 25944  		switch yys3 {
 25945  		case "DeploymentID":
 25946  			if r.TryDecodeAsNil() {
 25947  				x.DeploymentID = ""
 25948  			} else {
 25949  				yyv4 := &x.DeploymentID
 25950  				yym5 := z.DecBinary()
 25951  				_ = yym5
 25952  				if false {
 25953  				} else {
 25954  					*((*string)(yyv4)) = r.DecodeString()
 25955  				}
 25956  			}
 25957  		case "HealthyAllocationIDs":
 25958  			if r.TryDecodeAsNil() {
 25959  				x.HealthyAllocationIDs = nil
 25960  			} else {
 25961  				yyv6 := &x.HealthyAllocationIDs
 25962  				yym7 := z.DecBinary()
 25963  				_ = yym7
 25964  				if false {
 25965  				} else {
 25966  					z.F.DecSliceStringX(yyv6, false, d)
 25967  				}
 25968  			}
 25969  		case "UnhealthyAllocationIDs":
 25970  			if r.TryDecodeAsNil() {
 25971  				x.UnhealthyAllocationIDs = nil
 25972  			} else {
 25973  				yyv8 := &x.UnhealthyAllocationIDs
 25974  				yym9 := z.DecBinary()
 25975  				_ = yym9
 25976  				if false {
 25977  				} else {
 25978  					z.F.DecSliceStringX(yyv8, false, d)
 25979  				}
 25980  			}
 25981  		case "Region":
 25982  			if r.TryDecodeAsNil() {
 25983  				x.Region = ""
 25984  			} else {
 25985  				yyv10 := &x.Region
 25986  				yym11 := z.DecBinary()
 25987  				_ = yym11
 25988  				if false {
 25989  				} else {
 25990  					*((*string)(yyv10)) = r.DecodeString()
 25991  				}
 25992  			}
 25993  		case "Namespace":
 25994  			if r.TryDecodeAsNil() {
 25995  				x.Namespace = ""
 25996  			} else {
 25997  				yyv12 := &x.Namespace
 25998  				yym13 := z.DecBinary()
 25999  				_ = yym13
 26000  				if false {
 26001  				} else {
 26002  					*((*string)(yyv12)) = r.DecodeString()
 26003  				}
 26004  			}
 26005  		case "AuthToken":
 26006  			if r.TryDecodeAsNil() {
 26007  				x.AuthToken = ""
 26008  			} else {
 26009  				yyv14 := &x.AuthToken
 26010  				yym15 := z.DecBinary()
 26011  				_ = yym15
 26012  				if false {
 26013  				} else {
 26014  					*((*string)(yyv14)) = r.DecodeString()
 26015  				}
 26016  			}
 26017  		case "Forwarded":
 26018  			if r.TryDecodeAsNil() {
 26019  				x.Forwarded = false
 26020  			} else {
 26021  				yyv16 := &x.Forwarded
 26022  				yym17 := z.DecBinary()
 26023  				_ = yym17
 26024  				if false {
 26025  				} else {
 26026  					*((*bool)(yyv16)) = r.DecodeBool()
 26027  				}
 26028  			}
 26029  		default:
 26030  			z.DecStructFieldNotFound(-1, yys3)
 26031  		} // end switch yys3
 26032  	} // end for yyj3
 26033  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 26034  }
 26035  
 26036  func (x *DeploymentAllocHealthRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 26037  	var h codecSelfer100
 26038  	z, r := codec1978.GenHelperDecoder(d)
 26039  	_, _, _ = h, z, r
 26040  	var yyj18 int
 26041  	var yyb18 bool
 26042  	var yyhl18 bool = l >= 0
 26043  	yyj18++
 26044  	if yyhl18 {
 26045  		yyb18 = yyj18 > l
 26046  	} else {
 26047  		yyb18 = r.CheckBreak()
 26048  	}
 26049  	if yyb18 {
 26050  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26051  		return
 26052  	}
 26053  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26054  	if r.TryDecodeAsNil() {
 26055  		x.DeploymentID = ""
 26056  	} else {
 26057  		yyv19 := &x.DeploymentID
 26058  		yym20 := z.DecBinary()
 26059  		_ = yym20
 26060  		if false {
 26061  		} else {
 26062  			*((*string)(yyv19)) = r.DecodeString()
 26063  		}
 26064  	}
 26065  	yyj18++
 26066  	if yyhl18 {
 26067  		yyb18 = yyj18 > l
 26068  	} else {
 26069  		yyb18 = r.CheckBreak()
 26070  	}
 26071  	if yyb18 {
 26072  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26073  		return
 26074  	}
 26075  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26076  	if r.TryDecodeAsNil() {
 26077  		x.HealthyAllocationIDs = nil
 26078  	} else {
 26079  		yyv21 := &x.HealthyAllocationIDs
 26080  		yym22 := z.DecBinary()
 26081  		_ = yym22
 26082  		if false {
 26083  		} else {
 26084  			z.F.DecSliceStringX(yyv21, false, d)
 26085  		}
 26086  	}
 26087  	yyj18++
 26088  	if yyhl18 {
 26089  		yyb18 = yyj18 > l
 26090  	} else {
 26091  		yyb18 = r.CheckBreak()
 26092  	}
 26093  	if yyb18 {
 26094  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26095  		return
 26096  	}
 26097  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26098  	if r.TryDecodeAsNil() {
 26099  		x.UnhealthyAllocationIDs = nil
 26100  	} else {
 26101  		yyv23 := &x.UnhealthyAllocationIDs
 26102  		yym24 := z.DecBinary()
 26103  		_ = yym24
 26104  		if false {
 26105  		} else {
 26106  			z.F.DecSliceStringX(yyv23, false, d)
 26107  		}
 26108  	}
 26109  	yyj18++
 26110  	if yyhl18 {
 26111  		yyb18 = yyj18 > l
 26112  	} else {
 26113  		yyb18 = r.CheckBreak()
 26114  	}
 26115  	if yyb18 {
 26116  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26117  		return
 26118  	}
 26119  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26120  	if r.TryDecodeAsNil() {
 26121  		x.Region = ""
 26122  	} else {
 26123  		yyv25 := &x.Region
 26124  		yym26 := z.DecBinary()
 26125  		_ = yym26
 26126  		if false {
 26127  		} else {
 26128  			*((*string)(yyv25)) = r.DecodeString()
 26129  		}
 26130  	}
 26131  	yyj18++
 26132  	if yyhl18 {
 26133  		yyb18 = yyj18 > l
 26134  	} else {
 26135  		yyb18 = r.CheckBreak()
 26136  	}
 26137  	if yyb18 {
 26138  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26139  		return
 26140  	}
 26141  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26142  	if r.TryDecodeAsNil() {
 26143  		x.Namespace = ""
 26144  	} else {
 26145  		yyv27 := &x.Namespace
 26146  		yym28 := z.DecBinary()
 26147  		_ = yym28
 26148  		if false {
 26149  		} else {
 26150  			*((*string)(yyv27)) = r.DecodeString()
 26151  		}
 26152  	}
 26153  	yyj18++
 26154  	if yyhl18 {
 26155  		yyb18 = yyj18 > l
 26156  	} else {
 26157  		yyb18 = r.CheckBreak()
 26158  	}
 26159  	if yyb18 {
 26160  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26161  		return
 26162  	}
 26163  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26164  	if r.TryDecodeAsNil() {
 26165  		x.AuthToken = ""
 26166  	} else {
 26167  		yyv29 := &x.AuthToken
 26168  		yym30 := z.DecBinary()
 26169  		_ = yym30
 26170  		if false {
 26171  		} else {
 26172  			*((*string)(yyv29)) = r.DecodeString()
 26173  		}
 26174  	}
 26175  	yyj18++
 26176  	if yyhl18 {
 26177  		yyb18 = yyj18 > l
 26178  	} else {
 26179  		yyb18 = r.CheckBreak()
 26180  	}
 26181  	if yyb18 {
 26182  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26183  		return
 26184  	}
 26185  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26186  	if r.TryDecodeAsNil() {
 26187  		x.Forwarded = false
 26188  	} else {
 26189  		yyv31 := &x.Forwarded
 26190  		yym32 := z.DecBinary()
 26191  		_ = yym32
 26192  		if false {
 26193  		} else {
 26194  			*((*bool)(yyv31)) = r.DecodeBool()
 26195  		}
 26196  	}
 26197  	for {
 26198  		yyj18++
 26199  		if yyhl18 {
 26200  			yyb18 = yyj18 > l
 26201  		} else {
 26202  			yyb18 = r.CheckBreak()
 26203  		}
 26204  		if yyb18 {
 26205  			break
 26206  		}
 26207  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26208  		z.DecStructFieldNotFound(yyj18-1, "")
 26209  	}
 26210  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26211  }
 26212  
 26213  func (x *ApplyDeploymentAllocHealthRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 26214  	var h codecSelfer100
 26215  	z, r := codec1978.GenHelperEncoder(e)
 26216  	_, _, _ = h, z, r
 26217  	if x == nil {
 26218  		r.EncodeNil()
 26219  	} else {
 26220  		yym1 := z.EncBinary()
 26221  		_ = yym1
 26222  		if false {
 26223  		} else if z.HasExtensions() && z.EncExt(x) {
 26224  		} else {
 26225  			yysep2 := !z.EncBinary()
 26226  			yy2arr2 := z.EncBasicHandle().StructToArray
 26227  			var yyq2 [10]bool
 26228  			_, _, _ = yysep2, yyq2, yy2arr2
 26229  			const yyr2 bool = false
 26230  			var yynn2 int
 26231  			if yyr2 || yy2arr2 {
 26232  				r.EncodeArrayStart(10)
 26233  			} else {
 26234  				yynn2 = 10
 26235  				for _, b := range yyq2 {
 26236  					if b {
 26237  						yynn2++
 26238  					}
 26239  				}
 26240  				r.EncodeMapStart(yynn2)
 26241  				yynn2 = 0
 26242  			}
 26243  			if yyr2 || yy2arr2 {
 26244  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 26245  				yym4 := z.EncBinary()
 26246  				_ = yym4
 26247  				if false {
 26248  				} else {
 26249  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 26250  				}
 26251  			} else {
 26252  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 26253  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentID"))
 26254  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 26255  				yym5 := z.EncBinary()
 26256  				_ = yym5
 26257  				if false {
 26258  				} else {
 26259  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 26260  				}
 26261  			}
 26262  			if yyr2 || yy2arr2 {
 26263  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 26264  				if x.HealthyAllocationIDs == nil {
 26265  					r.EncodeNil()
 26266  				} else {
 26267  					yym7 := z.EncBinary()
 26268  					_ = yym7
 26269  					if false {
 26270  					} else {
 26271  						z.F.EncSliceStringV(x.HealthyAllocationIDs, false, e)
 26272  					}
 26273  				}
 26274  			} else {
 26275  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 26276  				r.EncodeString(codecSelferC_UTF8100, string("HealthyAllocationIDs"))
 26277  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 26278  				if x.HealthyAllocationIDs == nil {
 26279  					r.EncodeNil()
 26280  				} else {
 26281  					yym8 := z.EncBinary()
 26282  					_ = yym8
 26283  					if false {
 26284  					} else {
 26285  						z.F.EncSliceStringV(x.HealthyAllocationIDs, false, e)
 26286  					}
 26287  				}
 26288  			}
 26289  			if yyr2 || yy2arr2 {
 26290  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 26291  				if x.UnhealthyAllocationIDs == nil {
 26292  					r.EncodeNil()
 26293  				} else {
 26294  					yym10 := z.EncBinary()
 26295  					_ = yym10
 26296  					if false {
 26297  					} else {
 26298  						z.F.EncSliceStringV(x.UnhealthyAllocationIDs, false, e)
 26299  					}
 26300  				}
 26301  			} else {
 26302  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 26303  				r.EncodeString(codecSelferC_UTF8100, string("UnhealthyAllocationIDs"))
 26304  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 26305  				if x.UnhealthyAllocationIDs == nil {
 26306  					r.EncodeNil()
 26307  				} else {
 26308  					yym11 := z.EncBinary()
 26309  					_ = yym11
 26310  					if false {
 26311  					} else {
 26312  						z.F.EncSliceStringV(x.UnhealthyAllocationIDs, false, e)
 26313  					}
 26314  				}
 26315  			}
 26316  			if yyr2 || yy2arr2 {
 26317  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 26318  				yym13 := z.EncBinary()
 26319  				_ = yym13
 26320  				if false {
 26321  				} else {
 26322  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 26323  				}
 26324  			} else {
 26325  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 26326  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 26327  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 26328  				yym14 := z.EncBinary()
 26329  				_ = yym14
 26330  				if false {
 26331  				} else {
 26332  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 26333  				}
 26334  			}
 26335  			if yyr2 || yy2arr2 {
 26336  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 26337  				yym16 := z.EncBinary()
 26338  				_ = yym16
 26339  				if false {
 26340  				} else {
 26341  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 26342  				}
 26343  			} else {
 26344  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 26345  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 26346  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 26347  				yym17 := z.EncBinary()
 26348  				_ = yym17
 26349  				if false {
 26350  				} else {
 26351  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 26352  				}
 26353  			}
 26354  			if yyr2 || yy2arr2 {
 26355  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 26356  				yym19 := z.EncBinary()
 26357  				_ = yym19
 26358  				if false {
 26359  				} else {
 26360  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 26361  				}
 26362  			} else {
 26363  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 26364  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 26365  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 26366  				yym20 := z.EncBinary()
 26367  				_ = yym20
 26368  				if false {
 26369  				} else {
 26370  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 26371  				}
 26372  			}
 26373  			if yyr2 || yy2arr2 {
 26374  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 26375  				yym22 := z.EncBinary()
 26376  				_ = yym22
 26377  				if false {
 26378  				} else {
 26379  					r.EncodeBool(bool(x.Forwarded))
 26380  				}
 26381  			} else {
 26382  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 26383  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 26384  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 26385  				yym23 := z.EncBinary()
 26386  				_ = yym23
 26387  				if false {
 26388  				} else {
 26389  					r.EncodeBool(bool(x.Forwarded))
 26390  				}
 26391  			}
 26392  			if yyr2 || yy2arr2 {
 26393  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 26394  				if x.DeploymentUpdate == nil {
 26395  					r.EncodeNil()
 26396  				} else {
 26397  					x.DeploymentUpdate.CodecEncodeSelf(e)
 26398  				}
 26399  			} else {
 26400  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 26401  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentUpdate"))
 26402  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 26403  				if x.DeploymentUpdate == nil {
 26404  					r.EncodeNil()
 26405  				} else {
 26406  					x.DeploymentUpdate.CodecEncodeSelf(e)
 26407  				}
 26408  			}
 26409  			if yyr2 || yy2arr2 {
 26410  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 26411  				if x.Job == nil {
 26412  					r.EncodeNil()
 26413  				} else {
 26414  					x.Job.CodecEncodeSelf(e)
 26415  				}
 26416  			} else {
 26417  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 26418  				r.EncodeString(codecSelferC_UTF8100, string("Job"))
 26419  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 26420  				if x.Job == nil {
 26421  					r.EncodeNil()
 26422  				} else {
 26423  					x.Job.CodecEncodeSelf(e)
 26424  				}
 26425  			}
 26426  			if yyr2 || yy2arr2 {
 26427  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 26428  				if x.Eval == nil {
 26429  					r.EncodeNil()
 26430  				} else {
 26431  					x.Eval.CodecEncodeSelf(e)
 26432  				}
 26433  			} else {
 26434  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 26435  				r.EncodeString(codecSelferC_UTF8100, string("Eval"))
 26436  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 26437  				if x.Eval == nil {
 26438  					r.EncodeNil()
 26439  				} else {
 26440  					x.Eval.CodecEncodeSelf(e)
 26441  				}
 26442  			}
 26443  			if yyr2 || yy2arr2 {
 26444  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 26445  			} else {
 26446  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 26447  			}
 26448  		}
 26449  	}
 26450  }
 26451  
 26452  func (x *ApplyDeploymentAllocHealthRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 26453  	var h codecSelfer100
 26454  	z, r := codec1978.GenHelperDecoder(d)
 26455  	_, _, _ = h, z, r
 26456  	yym1 := z.DecBinary()
 26457  	_ = yym1
 26458  	if false {
 26459  	} else if z.HasExtensions() && z.DecExt(x) {
 26460  	} else {
 26461  		yyct2 := r.ContainerType()
 26462  		if yyct2 == codecSelferValueTypeMap100 {
 26463  			yyl2 := r.ReadMapStart()
 26464  			if yyl2 == 0 {
 26465  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 26466  			} else {
 26467  				x.codecDecodeSelfFromMap(yyl2, d)
 26468  			}
 26469  		} else if yyct2 == codecSelferValueTypeArray100 {
 26470  			yyl2 := r.ReadArrayStart()
 26471  			if yyl2 == 0 {
 26472  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26473  			} else {
 26474  				x.codecDecodeSelfFromArray(yyl2, d)
 26475  			}
 26476  		} else {
 26477  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 26478  		}
 26479  	}
 26480  }
 26481  
 26482  func (x *ApplyDeploymentAllocHealthRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 26483  	var h codecSelfer100
 26484  	z, r := codec1978.GenHelperDecoder(d)
 26485  	_, _, _ = h, z, r
 26486  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 26487  	_ = yys3Slc
 26488  	var yyhl3 bool = l >= 0
 26489  	for yyj3 := 0; ; yyj3++ {
 26490  		if yyhl3 {
 26491  			if yyj3 >= l {
 26492  				break
 26493  			}
 26494  		} else {
 26495  			if r.CheckBreak() {
 26496  				break
 26497  			}
 26498  		}
 26499  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 26500  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 26501  		yys3 := string(yys3Slc)
 26502  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 26503  		switch yys3 {
 26504  		case "DeploymentID":
 26505  			if r.TryDecodeAsNil() {
 26506  				x.DeploymentID = ""
 26507  			} else {
 26508  				yyv4 := &x.DeploymentID
 26509  				yym5 := z.DecBinary()
 26510  				_ = yym5
 26511  				if false {
 26512  				} else {
 26513  					*((*string)(yyv4)) = r.DecodeString()
 26514  				}
 26515  			}
 26516  		case "HealthyAllocationIDs":
 26517  			if r.TryDecodeAsNil() {
 26518  				x.HealthyAllocationIDs = nil
 26519  			} else {
 26520  				yyv6 := &x.HealthyAllocationIDs
 26521  				yym7 := z.DecBinary()
 26522  				_ = yym7
 26523  				if false {
 26524  				} else {
 26525  					z.F.DecSliceStringX(yyv6, false, d)
 26526  				}
 26527  			}
 26528  		case "UnhealthyAllocationIDs":
 26529  			if r.TryDecodeAsNil() {
 26530  				x.UnhealthyAllocationIDs = nil
 26531  			} else {
 26532  				yyv8 := &x.UnhealthyAllocationIDs
 26533  				yym9 := z.DecBinary()
 26534  				_ = yym9
 26535  				if false {
 26536  				} else {
 26537  					z.F.DecSliceStringX(yyv8, false, d)
 26538  				}
 26539  			}
 26540  		case "Region":
 26541  			if r.TryDecodeAsNil() {
 26542  				x.Region = ""
 26543  			} else {
 26544  				yyv10 := &x.Region
 26545  				yym11 := z.DecBinary()
 26546  				_ = yym11
 26547  				if false {
 26548  				} else {
 26549  					*((*string)(yyv10)) = r.DecodeString()
 26550  				}
 26551  			}
 26552  		case "Namespace":
 26553  			if r.TryDecodeAsNil() {
 26554  				x.Namespace = ""
 26555  			} else {
 26556  				yyv12 := &x.Namespace
 26557  				yym13 := z.DecBinary()
 26558  				_ = yym13
 26559  				if false {
 26560  				} else {
 26561  					*((*string)(yyv12)) = r.DecodeString()
 26562  				}
 26563  			}
 26564  		case "AuthToken":
 26565  			if r.TryDecodeAsNil() {
 26566  				x.AuthToken = ""
 26567  			} else {
 26568  				yyv14 := &x.AuthToken
 26569  				yym15 := z.DecBinary()
 26570  				_ = yym15
 26571  				if false {
 26572  				} else {
 26573  					*((*string)(yyv14)) = r.DecodeString()
 26574  				}
 26575  			}
 26576  		case "Forwarded":
 26577  			if r.TryDecodeAsNil() {
 26578  				x.Forwarded = false
 26579  			} else {
 26580  				yyv16 := &x.Forwarded
 26581  				yym17 := z.DecBinary()
 26582  				_ = yym17
 26583  				if false {
 26584  				} else {
 26585  					*((*bool)(yyv16)) = r.DecodeBool()
 26586  				}
 26587  			}
 26588  		case "DeploymentUpdate":
 26589  			if r.TryDecodeAsNil() {
 26590  				if x.DeploymentUpdate != nil {
 26591  					x.DeploymentUpdate = nil
 26592  				}
 26593  			} else {
 26594  				if x.DeploymentUpdate == nil {
 26595  					x.DeploymentUpdate = new(DeploymentStatusUpdate)
 26596  				}
 26597  				x.DeploymentUpdate.CodecDecodeSelf(d)
 26598  			}
 26599  		case "Job":
 26600  			if r.TryDecodeAsNil() {
 26601  				if x.Job != nil {
 26602  					x.Job = nil
 26603  				}
 26604  			} else {
 26605  				if x.Job == nil {
 26606  					x.Job = new(Job)
 26607  				}
 26608  				x.Job.CodecDecodeSelf(d)
 26609  			}
 26610  		case "Eval":
 26611  			if r.TryDecodeAsNil() {
 26612  				if x.Eval != nil {
 26613  					x.Eval = nil
 26614  				}
 26615  			} else {
 26616  				if x.Eval == nil {
 26617  					x.Eval = new(Evaluation)
 26618  				}
 26619  				x.Eval.CodecDecodeSelf(d)
 26620  			}
 26621  		default:
 26622  			z.DecStructFieldNotFound(-1, yys3)
 26623  		} // end switch yys3
 26624  	} // end for yyj3
 26625  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 26626  }
 26627  
 26628  func (x *ApplyDeploymentAllocHealthRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 26629  	var h codecSelfer100
 26630  	z, r := codec1978.GenHelperDecoder(d)
 26631  	_, _, _ = h, z, r
 26632  	var yyj21 int
 26633  	var yyb21 bool
 26634  	var yyhl21 bool = l >= 0
 26635  	yyj21++
 26636  	if yyhl21 {
 26637  		yyb21 = yyj21 > l
 26638  	} else {
 26639  		yyb21 = r.CheckBreak()
 26640  	}
 26641  	if yyb21 {
 26642  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26643  		return
 26644  	}
 26645  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26646  	if r.TryDecodeAsNil() {
 26647  		x.DeploymentID = ""
 26648  	} else {
 26649  		yyv22 := &x.DeploymentID
 26650  		yym23 := z.DecBinary()
 26651  		_ = yym23
 26652  		if false {
 26653  		} else {
 26654  			*((*string)(yyv22)) = r.DecodeString()
 26655  		}
 26656  	}
 26657  	yyj21++
 26658  	if yyhl21 {
 26659  		yyb21 = yyj21 > l
 26660  	} else {
 26661  		yyb21 = r.CheckBreak()
 26662  	}
 26663  	if yyb21 {
 26664  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26665  		return
 26666  	}
 26667  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26668  	if r.TryDecodeAsNil() {
 26669  		x.HealthyAllocationIDs = nil
 26670  	} else {
 26671  		yyv24 := &x.HealthyAllocationIDs
 26672  		yym25 := z.DecBinary()
 26673  		_ = yym25
 26674  		if false {
 26675  		} else {
 26676  			z.F.DecSliceStringX(yyv24, false, d)
 26677  		}
 26678  	}
 26679  	yyj21++
 26680  	if yyhl21 {
 26681  		yyb21 = yyj21 > l
 26682  	} else {
 26683  		yyb21 = r.CheckBreak()
 26684  	}
 26685  	if yyb21 {
 26686  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26687  		return
 26688  	}
 26689  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26690  	if r.TryDecodeAsNil() {
 26691  		x.UnhealthyAllocationIDs = nil
 26692  	} else {
 26693  		yyv26 := &x.UnhealthyAllocationIDs
 26694  		yym27 := z.DecBinary()
 26695  		_ = yym27
 26696  		if false {
 26697  		} else {
 26698  			z.F.DecSliceStringX(yyv26, false, d)
 26699  		}
 26700  	}
 26701  	yyj21++
 26702  	if yyhl21 {
 26703  		yyb21 = yyj21 > l
 26704  	} else {
 26705  		yyb21 = r.CheckBreak()
 26706  	}
 26707  	if yyb21 {
 26708  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26709  		return
 26710  	}
 26711  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26712  	if r.TryDecodeAsNil() {
 26713  		x.Region = ""
 26714  	} else {
 26715  		yyv28 := &x.Region
 26716  		yym29 := z.DecBinary()
 26717  		_ = yym29
 26718  		if false {
 26719  		} else {
 26720  			*((*string)(yyv28)) = r.DecodeString()
 26721  		}
 26722  	}
 26723  	yyj21++
 26724  	if yyhl21 {
 26725  		yyb21 = yyj21 > l
 26726  	} else {
 26727  		yyb21 = r.CheckBreak()
 26728  	}
 26729  	if yyb21 {
 26730  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26731  		return
 26732  	}
 26733  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26734  	if r.TryDecodeAsNil() {
 26735  		x.Namespace = ""
 26736  	} else {
 26737  		yyv30 := &x.Namespace
 26738  		yym31 := z.DecBinary()
 26739  		_ = yym31
 26740  		if false {
 26741  		} else {
 26742  			*((*string)(yyv30)) = r.DecodeString()
 26743  		}
 26744  	}
 26745  	yyj21++
 26746  	if yyhl21 {
 26747  		yyb21 = yyj21 > l
 26748  	} else {
 26749  		yyb21 = r.CheckBreak()
 26750  	}
 26751  	if yyb21 {
 26752  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26753  		return
 26754  	}
 26755  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26756  	if r.TryDecodeAsNil() {
 26757  		x.AuthToken = ""
 26758  	} else {
 26759  		yyv32 := &x.AuthToken
 26760  		yym33 := z.DecBinary()
 26761  		_ = yym33
 26762  		if false {
 26763  		} else {
 26764  			*((*string)(yyv32)) = r.DecodeString()
 26765  		}
 26766  	}
 26767  	yyj21++
 26768  	if yyhl21 {
 26769  		yyb21 = yyj21 > l
 26770  	} else {
 26771  		yyb21 = r.CheckBreak()
 26772  	}
 26773  	if yyb21 {
 26774  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26775  		return
 26776  	}
 26777  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26778  	if r.TryDecodeAsNil() {
 26779  		x.Forwarded = false
 26780  	} else {
 26781  		yyv34 := &x.Forwarded
 26782  		yym35 := z.DecBinary()
 26783  		_ = yym35
 26784  		if false {
 26785  		} else {
 26786  			*((*bool)(yyv34)) = r.DecodeBool()
 26787  		}
 26788  	}
 26789  	yyj21++
 26790  	if yyhl21 {
 26791  		yyb21 = yyj21 > l
 26792  	} else {
 26793  		yyb21 = r.CheckBreak()
 26794  	}
 26795  	if yyb21 {
 26796  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26797  		return
 26798  	}
 26799  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26800  	if r.TryDecodeAsNil() {
 26801  		if x.DeploymentUpdate != nil {
 26802  			x.DeploymentUpdate = nil
 26803  		}
 26804  	} else {
 26805  		if x.DeploymentUpdate == nil {
 26806  			x.DeploymentUpdate = new(DeploymentStatusUpdate)
 26807  		}
 26808  		x.DeploymentUpdate.CodecDecodeSelf(d)
 26809  	}
 26810  	yyj21++
 26811  	if yyhl21 {
 26812  		yyb21 = yyj21 > l
 26813  	} else {
 26814  		yyb21 = r.CheckBreak()
 26815  	}
 26816  	if yyb21 {
 26817  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26818  		return
 26819  	}
 26820  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26821  	if r.TryDecodeAsNil() {
 26822  		if x.Job != nil {
 26823  			x.Job = nil
 26824  		}
 26825  	} else {
 26826  		if x.Job == nil {
 26827  			x.Job = new(Job)
 26828  		}
 26829  		x.Job.CodecDecodeSelf(d)
 26830  	}
 26831  	yyj21++
 26832  	if yyhl21 {
 26833  		yyb21 = yyj21 > l
 26834  	} else {
 26835  		yyb21 = r.CheckBreak()
 26836  	}
 26837  	if yyb21 {
 26838  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26839  		return
 26840  	}
 26841  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26842  	if r.TryDecodeAsNil() {
 26843  		if x.Eval != nil {
 26844  			x.Eval = nil
 26845  		}
 26846  	} else {
 26847  		if x.Eval == nil {
 26848  			x.Eval = new(Evaluation)
 26849  		}
 26850  		x.Eval.CodecDecodeSelf(d)
 26851  	}
 26852  	for {
 26853  		yyj21++
 26854  		if yyhl21 {
 26855  			yyb21 = yyj21 > l
 26856  		} else {
 26857  			yyb21 = r.CheckBreak()
 26858  		}
 26859  		if yyb21 {
 26860  			break
 26861  		}
 26862  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 26863  		z.DecStructFieldNotFound(yyj21-1, "")
 26864  	}
 26865  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 26866  }
 26867  
 26868  func (x *DeploymentPromoteRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 26869  	var h codecSelfer100
 26870  	z, r := codec1978.GenHelperEncoder(e)
 26871  	_, _, _ = h, z, r
 26872  	if x == nil {
 26873  		r.EncodeNil()
 26874  	} else {
 26875  		yym1 := z.EncBinary()
 26876  		_ = yym1
 26877  		if false {
 26878  		} else if z.HasExtensions() && z.EncExt(x) {
 26879  		} else {
 26880  			yysep2 := !z.EncBinary()
 26881  			yy2arr2 := z.EncBasicHandle().StructToArray
 26882  			var yyq2 [7]bool
 26883  			_, _, _ = yysep2, yyq2, yy2arr2
 26884  			const yyr2 bool = false
 26885  			var yynn2 int
 26886  			if yyr2 || yy2arr2 {
 26887  				r.EncodeArrayStart(7)
 26888  			} else {
 26889  				yynn2 = 7
 26890  				for _, b := range yyq2 {
 26891  					if b {
 26892  						yynn2++
 26893  					}
 26894  				}
 26895  				r.EncodeMapStart(yynn2)
 26896  				yynn2 = 0
 26897  			}
 26898  			if yyr2 || yy2arr2 {
 26899  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 26900  				yym4 := z.EncBinary()
 26901  				_ = yym4
 26902  				if false {
 26903  				} else {
 26904  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 26905  				}
 26906  			} else {
 26907  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 26908  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentID"))
 26909  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 26910  				yym5 := z.EncBinary()
 26911  				_ = yym5
 26912  				if false {
 26913  				} else {
 26914  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 26915  				}
 26916  			}
 26917  			if yyr2 || yy2arr2 {
 26918  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 26919  				yym7 := z.EncBinary()
 26920  				_ = yym7
 26921  				if false {
 26922  				} else {
 26923  					r.EncodeBool(bool(x.All))
 26924  				}
 26925  			} else {
 26926  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 26927  				r.EncodeString(codecSelferC_UTF8100, string("All"))
 26928  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 26929  				yym8 := z.EncBinary()
 26930  				_ = yym8
 26931  				if false {
 26932  				} else {
 26933  					r.EncodeBool(bool(x.All))
 26934  				}
 26935  			}
 26936  			if yyr2 || yy2arr2 {
 26937  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 26938  				if x.Groups == nil {
 26939  					r.EncodeNil()
 26940  				} else {
 26941  					yym10 := z.EncBinary()
 26942  					_ = yym10
 26943  					if false {
 26944  					} else {
 26945  						z.F.EncSliceStringV(x.Groups, false, e)
 26946  					}
 26947  				}
 26948  			} else {
 26949  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 26950  				r.EncodeString(codecSelferC_UTF8100, string("Groups"))
 26951  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 26952  				if x.Groups == nil {
 26953  					r.EncodeNil()
 26954  				} else {
 26955  					yym11 := z.EncBinary()
 26956  					_ = yym11
 26957  					if false {
 26958  					} else {
 26959  						z.F.EncSliceStringV(x.Groups, false, e)
 26960  					}
 26961  				}
 26962  			}
 26963  			if yyr2 || yy2arr2 {
 26964  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 26965  				yym13 := z.EncBinary()
 26966  				_ = yym13
 26967  				if false {
 26968  				} else {
 26969  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 26970  				}
 26971  			} else {
 26972  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 26973  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 26974  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 26975  				yym14 := z.EncBinary()
 26976  				_ = yym14
 26977  				if false {
 26978  				} else {
 26979  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 26980  				}
 26981  			}
 26982  			if yyr2 || yy2arr2 {
 26983  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 26984  				yym16 := z.EncBinary()
 26985  				_ = yym16
 26986  				if false {
 26987  				} else {
 26988  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 26989  				}
 26990  			} else {
 26991  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 26992  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 26993  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 26994  				yym17 := z.EncBinary()
 26995  				_ = yym17
 26996  				if false {
 26997  				} else {
 26998  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 26999  				}
 27000  			}
 27001  			if yyr2 || yy2arr2 {
 27002  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 27003  				yym19 := z.EncBinary()
 27004  				_ = yym19
 27005  				if false {
 27006  				} else {
 27007  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 27008  				}
 27009  			} else {
 27010  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 27011  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 27012  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 27013  				yym20 := z.EncBinary()
 27014  				_ = yym20
 27015  				if false {
 27016  				} else {
 27017  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 27018  				}
 27019  			}
 27020  			if yyr2 || yy2arr2 {
 27021  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 27022  				yym22 := z.EncBinary()
 27023  				_ = yym22
 27024  				if false {
 27025  				} else {
 27026  					r.EncodeBool(bool(x.Forwarded))
 27027  				}
 27028  			} else {
 27029  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 27030  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 27031  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 27032  				yym23 := z.EncBinary()
 27033  				_ = yym23
 27034  				if false {
 27035  				} else {
 27036  					r.EncodeBool(bool(x.Forwarded))
 27037  				}
 27038  			}
 27039  			if yyr2 || yy2arr2 {
 27040  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 27041  			} else {
 27042  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 27043  			}
 27044  		}
 27045  	}
 27046  }
 27047  
 27048  func (x *DeploymentPromoteRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 27049  	var h codecSelfer100
 27050  	z, r := codec1978.GenHelperDecoder(d)
 27051  	_, _, _ = h, z, r
 27052  	yym1 := z.DecBinary()
 27053  	_ = yym1
 27054  	if false {
 27055  	} else if z.HasExtensions() && z.DecExt(x) {
 27056  	} else {
 27057  		yyct2 := r.ContainerType()
 27058  		if yyct2 == codecSelferValueTypeMap100 {
 27059  			yyl2 := r.ReadMapStart()
 27060  			if yyl2 == 0 {
 27061  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 27062  			} else {
 27063  				x.codecDecodeSelfFromMap(yyl2, d)
 27064  			}
 27065  		} else if yyct2 == codecSelferValueTypeArray100 {
 27066  			yyl2 := r.ReadArrayStart()
 27067  			if yyl2 == 0 {
 27068  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27069  			} else {
 27070  				x.codecDecodeSelfFromArray(yyl2, d)
 27071  			}
 27072  		} else {
 27073  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 27074  		}
 27075  	}
 27076  }
 27077  
 27078  func (x *DeploymentPromoteRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 27079  	var h codecSelfer100
 27080  	z, r := codec1978.GenHelperDecoder(d)
 27081  	_, _, _ = h, z, r
 27082  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 27083  	_ = yys3Slc
 27084  	var yyhl3 bool = l >= 0
 27085  	for yyj3 := 0; ; yyj3++ {
 27086  		if yyhl3 {
 27087  			if yyj3 >= l {
 27088  				break
 27089  			}
 27090  		} else {
 27091  			if r.CheckBreak() {
 27092  				break
 27093  			}
 27094  		}
 27095  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 27096  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 27097  		yys3 := string(yys3Slc)
 27098  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 27099  		switch yys3 {
 27100  		case "DeploymentID":
 27101  			if r.TryDecodeAsNil() {
 27102  				x.DeploymentID = ""
 27103  			} else {
 27104  				yyv4 := &x.DeploymentID
 27105  				yym5 := z.DecBinary()
 27106  				_ = yym5
 27107  				if false {
 27108  				} else {
 27109  					*((*string)(yyv4)) = r.DecodeString()
 27110  				}
 27111  			}
 27112  		case "All":
 27113  			if r.TryDecodeAsNil() {
 27114  				x.All = false
 27115  			} else {
 27116  				yyv6 := &x.All
 27117  				yym7 := z.DecBinary()
 27118  				_ = yym7
 27119  				if false {
 27120  				} else {
 27121  					*((*bool)(yyv6)) = r.DecodeBool()
 27122  				}
 27123  			}
 27124  		case "Groups":
 27125  			if r.TryDecodeAsNil() {
 27126  				x.Groups = nil
 27127  			} else {
 27128  				yyv8 := &x.Groups
 27129  				yym9 := z.DecBinary()
 27130  				_ = yym9
 27131  				if false {
 27132  				} else {
 27133  					z.F.DecSliceStringX(yyv8, false, d)
 27134  				}
 27135  			}
 27136  		case "Region":
 27137  			if r.TryDecodeAsNil() {
 27138  				x.Region = ""
 27139  			} else {
 27140  				yyv10 := &x.Region
 27141  				yym11 := z.DecBinary()
 27142  				_ = yym11
 27143  				if false {
 27144  				} else {
 27145  					*((*string)(yyv10)) = r.DecodeString()
 27146  				}
 27147  			}
 27148  		case "Namespace":
 27149  			if r.TryDecodeAsNil() {
 27150  				x.Namespace = ""
 27151  			} else {
 27152  				yyv12 := &x.Namespace
 27153  				yym13 := z.DecBinary()
 27154  				_ = yym13
 27155  				if false {
 27156  				} else {
 27157  					*((*string)(yyv12)) = r.DecodeString()
 27158  				}
 27159  			}
 27160  		case "AuthToken":
 27161  			if r.TryDecodeAsNil() {
 27162  				x.AuthToken = ""
 27163  			} else {
 27164  				yyv14 := &x.AuthToken
 27165  				yym15 := z.DecBinary()
 27166  				_ = yym15
 27167  				if false {
 27168  				} else {
 27169  					*((*string)(yyv14)) = r.DecodeString()
 27170  				}
 27171  			}
 27172  		case "Forwarded":
 27173  			if r.TryDecodeAsNil() {
 27174  				x.Forwarded = false
 27175  			} else {
 27176  				yyv16 := &x.Forwarded
 27177  				yym17 := z.DecBinary()
 27178  				_ = yym17
 27179  				if false {
 27180  				} else {
 27181  					*((*bool)(yyv16)) = r.DecodeBool()
 27182  				}
 27183  			}
 27184  		default:
 27185  			z.DecStructFieldNotFound(-1, yys3)
 27186  		} // end switch yys3
 27187  	} // end for yyj3
 27188  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 27189  }
 27190  
 27191  func (x *DeploymentPromoteRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 27192  	var h codecSelfer100
 27193  	z, r := codec1978.GenHelperDecoder(d)
 27194  	_, _, _ = h, z, r
 27195  	var yyj18 int
 27196  	var yyb18 bool
 27197  	var yyhl18 bool = l >= 0
 27198  	yyj18++
 27199  	if yyhl18 {
 27200  		yyb18 = yyj18 > l
 27201  	} else {
 27202  		yyb18 = r.CheckBreak()
 27203  	}
 27204  	if yyb18 {
 27205  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27206  		return
 27207  	}
 27208  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27209  	if r.TryDecodeAsNil() {
 27210  		x.DeploymentID = ""
 27211  	} else {
 27212  		yyv19 := &x.DeploymentID
 27213  		yym20 := z.DecBinary()
 27214  		_ = yym20
 27215  		if false {
 27216  		} else {
 27217  			*((*string)(yyv19)) = r.DecodeString()
 27218  		}
 27219  	}
 27220  	yyj18++
 27221  	if yyhl18 {
 27222  		yyb18 = yyj18 > l
 27223  	} else {
 27224  		yyb18 = r.CheckBreak()
 27225  	}
 27226  	if yyb18 {
 27227  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27228  		return
 27229  	}
 27230  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27231  	if r.TryDecodeAsNil() {
 27232  		x.All = false
 27233  	} else {
 27234  		yyv21 := &x.All
 27235  		yym22 := z.DecBinary()
 27236  		_ = yym22
 27237  		if false {
 27238  		} else {
 27239  			*((*bool)(yyv21)) = r.DecodeBool()
 27240  		}
 27241  	}
 27242  	yyj18++
 27243  	if yyhl18 {
 27244  		yyb18 = yyj18 > l
 27245  	} else {
 27246  		yyb18 = r.CheckBreak()
 27247  	}
 27248  	if yyb18 {
 27249  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27250  		return
 27251  	}
 27252  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27253  	if r.TryDecodeAsNil() {
 27254  		x.Groups = nil
 27255  	} else {
 27256  		yyv23 := &x.Groups
 27257  		yym24 := z.DecBinary()
 27258  		_ = yym24
 27259  		if false {
 27260  		} else {
 27261  			z.F.DecSliceStringX(yyv23, false, d)
 27262  		}
 27263  	}
 27264  	yyj18++
 27265  	if yyhl18 {
 27266  		yyb18 = yyj18 > l
 27267  	} else {
 27268  		yyb18 = r.CheckBreak()
 27269  	}
 27270  	if yyb18 {
 27271  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27272  		return
 27273  	}
 27274  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27275  	if r.TryDecodeAsNil() {
 27276  		x.Region = ""
 27277  	} else {
 27278  		yyv25 := &x.Region
 27279  		yym26 := z.DecBinary()
 27280  		_ = yym26
 27281  		if false {
 27282  		} else {
 27283  			*((*string)(yyv25)) = r.DecodeString()
 27284  		}
 27285  	}
 27286  	yyj18++
 27287  	if yyhl18 {
 27288  		yyb18 = yyj18 > l
 27289  	} else {
 27290  		yyb18 = r.CheckBreak()
 27291  	}
 27292  	if yyb18 {
 27293  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27294  		return
 27295  	}
 27296  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27297  	if r.TryDecodeAsNil() {
 27298  		x.Namespace = ""
 27299  	} else {
 27300  		yyv27 := &x.Namespace
 27301  		yym28 := z.DecBinary()
 27302  		_ = yym28
 27303  		if false {
 27304  		} else {
 27305  			*((*string)(yyv27)) = r.DecodeString()
 27306  		}
 27307  	}
 27308  	yyj18++
 27309  	if yyhl18 {
 27310  		yyb18 = yyj18 > l
 27311  	} else {
 27312  		yyb18 = r.CheckBreak()
 27313  	}
 27314  	if yyb18 {
 27315  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27316  		return
 27317  	}
 27318  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27319  	if r.TryDecodeAsNil() {
 27320  		x.AuthToken = ""
 27321  	} else {
 27322  		yyv29 := &x.AuthToken
 27323  		yym30 := z.DecBinary()
 27324  		_ = yym30
 27325  		if false {
 27326  		} else {
 27327  			*((*string)(yyv29)) = r.DecodeString()
 27328  		}
 27329  	}
 27330  	yyj18++
 27331  	if yyhl18 {
 27332  		yyb18 = yyj18 > l
 27333  	} else {
 27334  		yyb18 = r.CheckBreak()
 27335  	}
 27336  	if yyb18 {
 27337  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27338  		return
 27339  	}
 27340  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27341  	if r.TryDecodeAsNil() {
 27342  		x.Forwarded = false
 27343  	} else {
 27344  		yyv31 := &x.Forwarded
 27345  		yym32 := z.DecBinary()
 27346  		_ = yym32
 27347  		if false {
 27348  		} else {
 27349  			*((*bool)(yyv31)) = r.DecodeBool()
 27350  		}
 27351  	}
 27352  	for {
 27353  		yyj18++
 27354  		if yyhl18 {
 27355  			yyb18 = yyj18 > l
 27356  		} else {
 27357  			yyb18 = r.CheckBreak()
 27358  		}
 27359  		if yyb18 {
 27360  			break
 27361  		}
 27362  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27363  		z.DecStructFieldNotFound(yyj18-1, "")
 27364  	}
 27365  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27366  }
 27367  
 27368  func (x *ApplyDeploymentPromoteRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 27369  	var h codecSelfer100
 27370  	z, r := codec1978.GenHelperEncoder(e)
 27371  	_, _, _ = h, z, r
 27372  	if x == nil {
 27373  		r.EncodeNil()
 27374  	} else {
 27375  		yym1 := z.EncBinary()
 27376  		_ = yym1
 27377  		if false {
 27378  		} else if z.HasExtensions() && z.EncExt(x) {
 27379  		} else {
 27380  			yysep2 := !z.EncBinary()
 27381  			yy2arr2 := z.EncBasicHandle().StructToArray
 27382  			var yyq2 [8]bool
 27383  			_, _, _ = yysep2, yyq2, yy2arr2
 27384  			const yyr2 bool = false
 27385  			var yynn2 int
 27386  			if yyr2 || yy2arr2 {
 27387  				r.EncodeArrayStart(8)
 27388  			} else {
 27389  				yynn2 = 8
 27390  				for _, b := range yyq2 {
 27391  					if b {
 27392  						yynn2++
 27393  					}
 27394  				}
 27395  				r.EncodeMapStart(yynn2)
 27396  				yynn2 = 0
 27397  			}
 27398  			if yyr2 || yy2arr2 {
 27399  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 27400  				yym4 := z.EncBinary()
 27401  				_ = yym4
 27402  				if false {
 27403  				} else {
 27404  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 27405  				}
 27406  			} else {
 27407  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 27408  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentID"))
 27409  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 27410  				yym5 := z.EncBinary()
 27411  				_ = yym5
 27412  				if false {
 27413  				} else {
 27414  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 27415  				}
 27416  			}
 27417  			if yyr2 || yy2arr2 {
 27418  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 27419  				yym7 := z.EncBinary()
 27420  				_ = yym7
 27421  				if false {
 27422  				} else {
 27423  					r.EncodeBool(bool(x.All))
 27424  				}
 27425  			} else {
 27426  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 27427  				r.EncodeString(codecSelferC_UTF8100, string("All"))
 27428  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 27429  				yym8 := z.EncBinary()
 27430  				_ = yym8
 27431  				if false {
 27432  				} else {
 27433  					r.EncodeBool(bool(x.All))
 27434  				}
 27435  			}
 27436  			if yyr2 || yy2arr2 {
 27437  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 27438  				if x.Groups == nil {
 27439  					r.EncodeNil()
 27440  				} else {
 27441  					yym10 := z.EncBinary()
 27442  					_ = yym10
 27443  					if false {
 27444  					} else {
 27445  						z.F.EncSliceStringV(x.Groups, false, e)
 27446  					}
 27447  				}
 27448  			} else {
 27449  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 27450  				r.EncodeString(codecSelferC_UTF8100, string("Groups"))
 27451  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 27452  				if x.Groups == nil {
 27453  					r.EncodeNil()
 27454  				} else {
 27455  					yym11 := z.EncBinary()
 27456  					_ = yym11
 27457  					if false {
 27458  					} else {
 27459  						z.F.EncSliceStringV(x.Groups, false, e)
 27460  					}
 27461  				}
 27462  			}
 27463  			if yyr2 || yy2arr2 {
 27464  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 27465  				yym13 := z.EncBinary()
 27466  				_ = yym13
 27467  				if false {
 27468  				} else {
 27469  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 27470  				}
 27471  			} else {
 27472  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 27473  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 27474  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 27475  				yym14 := z.EncBinary()
 27476  				_ = yym14
 27477  				if false {
 27478  				} else {
 27479  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 27480  				}
 27481  			}
 27482  			if yyr2 || yy2arr2 {
 27483  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 27484  				yym16 := z.EncBinary()
 27485  				_ = yym16
 27486  				if false {
 27487  				} else {
 27488  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 27489  				}
 27490  			} else {
 27491  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 27492  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 27493  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 27494  				yym17 := z.EncBinary()
 27495  				_ = yym17
 27496  				if false {
 27497  				} else {
 27498  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 27499  				}
 27500  			}
 27501  			if yyr2 || yy2arr2 {
 27502  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 27503  				yym19 := z.EncBinary()
 27504  				_ = yym19
 27505  				if false {
 27506  				} else {
 27507  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 27508  				}
 27509  			} else {
 27510  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 27511  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 27512  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 27513  				yym20 := z.EncBinary()
 27514  				_ = yym20
 27515  				if false {
 27516  				} else {
 27517  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 27518  				}
 27519  			}
 27520  			if yyr2 || yy2arr2 {
 27521  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 27522  				yym22 := z.EncBinary()
 27523  				_ = yym22
 27524  				if false {
 27525  				} else {
 27526  					r.EncodeBool(bool(x.Forwarded))
 27527  				}
 27528  			} else {
 27529  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 27530  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 27531  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 27532  				yym23 := z.EncBinary()
 27533  				_ = yym23
 27534  				if false {
 27535  				} else {
 27536  					r.EncodeBool(bool(x.Forwarded))
 27537  				}
 27538  			}
 27539  			if yyr2 || yy2arr2 {
 27540  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 27541  				if x.Eval == nil {
 27542  					r.EncodeNil()
 27543  				} else {
 27544  					x.Eval.CodecEncodeSelf(e)
 27545  				}
 27546  			} else {
 27547  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 27548  				r.EncodeString(codecSelferC_UTF8100, string("Eval"))
 27549  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 27550  				if x.Eval == nil {
 27551  					r.EncodeNil()
 27552  				} else {
 27553  					x.Eval.CodecEncodeSelf(e)
 27554  				}
 27555  			}
 27556  			if yyr2 || yy2arr2 {
 27557  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 27558  			} else {
 27559  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 27560  			}
 27561  		}
 27562  	}
 27563  }
 27564  
 27565  func (x *ApplyDeploymentPromoteRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 27566  	var h codecSelfer100
 27567  	z, r := codec1978.GenHelperDecoder(d)
 27568  	_, _, _ = h, z, r
 27569  	yym1 := z.DecBinary()
 27570  	_ = yym1
 27571  	if false {
 27572  	} else if z.HasExtensions() && z.DecExt(x) {
 27573  	} else {
 27574  		yyct2 := r.ContainerType()
 27575  		if yyct2 == codecSelferValueTypeMap100 {
 27576  			yyl2 := r.ReadMapStart()
 27577  			if yyl2 == 0 {
 27578  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 27579  			} else {
 27580  				x.codecDecodeSelfFromMap(yyl2, d)
 27581  			}
 27582  		} else if yyct2 == codecSelferValueTypeArray100 {
 27583  			yyl2 := r.ReadArrayStart()
 27584  			if yyl2 == 0 {
 27585  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27586  			} else {
 27587  				x.codecDecodeSelfFromArray(yyl2, d)
 27588  			}
 27589  		} else {
 27590  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 27591  		}
 27592  	}
 27593  }
 27594  
 27595  func (x *ApplyDeploymentPromoteRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 27596  	var h codecSelfer100
 27597  	z, r := codec1978.GenHelperDecoder(d)
 27598  	_, _, _ = h, z, r
 27599  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 27600  	_ = yys3Slc
 27601  	var yyhl3 bool = l >= 0
 27602  	for yyj3 := 0; ; yyj3++ {
 27603  		if yyhl3 {
 27604  			if yyj3 >= l {
 27605  				break
 27606  			}
 27607  		} else {
 27608  			if r.CheckBreak() {
 27609  				break
 27610  			}
 27611  		}
 27612  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 27613  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 27614  		yys3 := string(yys3Slc)
 27615  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 27616  		switch yys3 {
 27617  		case "DeploymentID":
 27618  			if r.TryDecodeAsNil() {
 27619  				x.DeploymentID = ""
 27620  			} else {
 27621  				yyv4 := &x.DeploymentID
 27622  				yym5 := z.DecBinary()
 27623  				_ = yym5
 27624  				if false {
 27625  				} else {
 27626  					*((*string)(yyv4)) = r.DecodeString()
 27627  				}
 27628  			}
 27629  		case "All":
 27630  			if r.TryDecodeAsNil() {
 27631  				x.All = false
 27632  			} else {
 27633  				yyv6 := &x.All
 27634  				yym7 := z.DecBinary()
 27635  				_ = yym7
 27636  				if false {
 27637  				} else {
 27638  					*((*bool)(yyv6)) = r.DecodeBool()
 27639  				}
 27640  			}
 27641  		case "Groups":
 27642  			if r.TryDecodeAsNil() {
 27643  				x.Groups = nil
 27644  			} else {
 27645  				yyv8 := &x.Groups
 27646  				yym9 := z.DecBinary()
 27647  				_ = yym9
 27648  				if false {
 27649  				} else {
 27650  					z.F.DecSliceStringX(yyv8, false, d)
 27651  				}
 27652  			}
 27653  		case "Region":
 27654  			if r.TryDecodeAsNil() {
 27655  				x.Region = ""
 27656  			} else {
 27657  				yyv10 := &x.Region
 27658  				yym11 := z.DecBinary()
 27659  				_ = yym11
 27660  				if false {
 27661  				} else {
 27662  					*((*string)(yyv10)) = r.DecodeString()
 27663  				}
 27664  			}
 27665  		case "Namespace":
 27666  			if r.TryDecodeAsNil() {
 27667  				x.Namespace = ""
 27668  			} else {
 27669  				yyv12 := &x.Namespace
 27670  				yym13 := z.DecBinary()
 27671  				_ = yym13
 27672  				if false {
 27673  				} else {
 27674  					*((*string)(yyv12)) = r.DecodeString()
 27675  				}
 27676  			}
 27677  		case "AuthToken":
 27678  			if r.TryDecodeAsNil() {
 27679  				x.AuthToken = ""
 27680  			} else {
 27681  				yyv14 := &x.AuthToken
 27682  				yym15 := z.DecBinary()
 27683  				_ = yym15
 27684  				if false {
 27685  				} else {
 27686  					*((*string)(yyv14)) = r.DecodeString()
 27687  				}
 27688  			}
 27689  		case "Forwarded":
 27690  			if r.TryDecodeAsNil() {
 27691  				x.Forwarded = false
 27692  			} else {
 27693  				yyv16 := &x.Forwarded
 27694  				yym17 := z.DecBinary()
 27695  				_ = yym17
 27696  				if false {
 27697  				} else {
 27698  					*((*bool)(yyv16)) = r.DecodeBool()
 27699  				}
 27700  			}
 27701  		case "Eval":
 27702  			if r.TryDecodeAsNil() {
 27703  				if x.Eval != nil {
 27704  					x.Eval = nil
 27705  				}
 27706  			} else {
 27707  				if x.Eval == nil {
 27708  					x.Eval = new(Evaluation)
 27709  				}
 27710  				x.Eval.CodecDecodeSelf(d)
 27711  			}
 27712  		default:
 27713  			z.DecStructFieldNotFound(-1, yys3)
 27714  		} // end switch yys3
 27715  	} // end for yyj3
 27716  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 27717  }
 27718  
 27719  func (x *ApplyDeploymentPromoteRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 27720  	var h codecSelfer100
 27721  	z, r := codec1978.GenHelperDecoder(d)
 27722  	_, _, _ = h, z, r
 27723  	var yyj19 int
 27724  	var yyb19 bool
 27725  	var yyhl19 bool = l >= 0
 27726  	yyj19++
 27727  	if yyhl19 {
 27728  		yyb19 = yyj19 > l
 27729  	} else {
 27730  		yyb19 = r.CheckBreak()
 27731  	}
 27732  	if yyb19 {
 27733  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27734  		return
 27735  	}
 27736  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27737  	if r.TryDecodeAsNil() {
 27738  		x.DeploymentID = ""
 27739  	} else {
 27740  		yyv20 := &x.DeploymentID
 27741  		yym21 := z.DecBinary()
 27742  		_ = yym21
 27743  		if false {
 27744  		} else {
 27745  			*((*string)(yyv20)) = r.DecodeString()
 27746  		}
 27747  	}
 27748  	yyj19++
 27749  	if yyhl19 {
 27750  		yyb19 = yyj19 > l
 27751  	} else {
 27752  		yyb19 = r.CheckBreak()
 27753  	}
 27754  	if yyb19 {
 27755  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27756  		return
 27757  	}
 27758  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27759  	if r.TryDecodeAsNil() {
 27760  		x.All = false
 27761  	} else {
 27762  		yyv22 := &x.All
 27763  		yym23 := z.DecBinary()
 27764  		_ = yym23
 27765  		if false {
 27766  		} else {
 27767  			*((*bool)(yyv22)) = r.DecodeBool()
 27768  		}
 27769  	}
 27770  	yyj19++
 27771  	if yyhl19 {
 27772  		yyb19 = yyj19 > l
 27773  	} else {
 27774  		yyb19 = r.CheckBreak()
 27775  	}
 27776  	if yyb19 {
 27777  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27778  		return
 27779  	}
 27780  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27781  	if r.TryDecodeAsNil() {
 27782  		x.Groups = nil
 27783  	} else {
 27784  		yyv24 := &x.Groups
 27785  		yym25 := z.DecBinary()
 27786  		_ = yym25
 27787  		if false {
 27788  		} else {
 27789  			z.F.DecSliceStringX(yyv24, false, d)
 27790  		}
 27791  	}
 27792  	yyj19++
 27793  	if yyhl19 {
 27794  		yyb19 = yyj19 > l
 27795  	} else {
 27796  		yyb19 = r.CheckBreak()
 27797  	}
 27798  	if yyb19 {
 27799  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27800  		return
 27801  	}
 27802  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27803  	if r.TryDecodeAsNil() {
 27804  		x.Region = ""
 27805  	} else {
 27806  		yyv26 := &x.Region
 27807  		yym27 := z.DecBinary()
 27808  		_ = yym27
 27809  		if false {
 27810  		} else {
 27811  			*((*string)(yyv26)) = r.DecodeString()
 27812  		}
 27813  	}
 27814  	yyj19++
 27815  	if yyhl19 {
 27816  		yyb19 = yyj19 > l
 27817  	} else {
 27818  		yyb19 = r.CheckBreak()
 27819  	}
 27820  	if yyb19 {
 27821  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27822  		return
 27823  	}
 27824  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27825  	if r.TryDecodeAsNil() {
 27826  		x.Namespace = ""
 27827  	} else {
 27828  		yyv28 := &x.Namespace
 27829  		yym29 := z.DecBinary()
 27830  		_ = yym29
 27831  		if false {
 27832  		} else {
 27833  			*((*string)(yyv28)) = r.DecodeString()
 27834  		}
 27835  	}
 27836  	yyj19++
 27837  	if yyhl19 {
 27838  		yyb19 = yyj19 > l
 27839  	} else {
 27840  		yyb19 = r.CheckBreak()
 27841  	}
 27842  	if yyb19 {
 27843  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27844  		return
 27845  	}
 27846  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27847  	if r.TryDecodeAsNil() {
 27848  		x.AuthToken = ""
 27849  	} else {
 27850  		yyv30 := &x.AuthToken
 27851  		yym31 := z.DecBinary()
 27852  		_ = yym31
 27853  		if false {
 27854  		} else {
 27855  			*((*string)(yyv30)) = r.DecodeString()
 27856  		}
 27857  	}
 27858  	yyj19++
 27859  	if yyhl19 {
 27860  		yyb19 = yyj19 > l
 27861  	} else {
 27862  		yyb19 = r.CheckBreak()
 27863  	}
 27864  	if yyb19 {
 27865  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27866  		return
 27867  	}
 27868  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27869  	if r.TryDecodeAsNil() {
 27870  		x.Forwarded = false
 27871  	} else {
 27872  		yyv32 := &x.Forwarded
 27873  		yym33 := z.DecBinary()
 27874  		_ = yym33
 27875  		if false {
 27876  		} else {
 27877  			*((*bool)(yyv32)) = r.DecodeBool()
 27878  		}
 27879  	}
 27880  	yyj19++
 27881  	if yyhl19 {
 27882  		yyb19 = yyj19 > l
 27883  	} else {
 27884  		yyb19 = r.CheckBreak()
 27885  	}
 27886  	if yyb19 {
 27887  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27888  		return
 27889  	}
 27890  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27891  	if r.TryDecodeAsNil() {
 27892  		if x.Eval != nil {
 27893  			x.Eval = nil
 27894  		}
 27895  	} else {
 27896  		if x.Eval == nil {
 27897  			x.Eval = new(Evaluation)
 27898  		}
 27899  		x.Eval.CodecDecodeSelf(d)
 27900  	}
 27901  	for {
 27902  		yyj19++
 27903  		if yyhl19 {
 27904  			yyb19 = yyj19 > l
 27905  		} else {
 27906  			yyb19 = r.CheckBreak()
 27907  		}
 27908  		if yyb19 {
 27909  			break
 27910  		}
 27911  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 27912  		z.DecStructFieldNotFound(yyj19-1, "")
 27913  	}
 27914  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 27915  }
 27916  
 27917  func (x *DeploymentPauseRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 27918  	var h codecSelfer100
 27919  	z, r := codec1978.GenHelperEncoder(e)
 27920  	_, _, _ = h, z, r
 27921  	if x == nil {
 27922  		r.EncodeNil()
 27923  	} else {
 27924  		yym1 := z.EncBinary()
 27925  		_ = yym1
 27926  		if false {
 27927  		} else if z.HasExtensions() && z.EncExt(x) {
 27928  		} else {
 27929  			yysep2 := !z.EncBinary()
 27930  			yy2arr2 := z.EncBasicHandle().StructToArray
 27931  			var yyq2 [6]bool
 27932  			_, _, _ = yysep2, yyq2, yy2arr2
 27933  			const yyr2 bool = false
 27934  			var yynn2 int
 27935  			if yyr2 || yy2arr2 {
 27936  				r.EncodeArrayStart(6)
 27937  			} else {
 27938  				yynn2 = 6
 27939  				for _, b := range yyq2 {
 27940  					if b {
 27941  						yynn2++
 27942  					}
 27943  				}
 27944  				r.EncodeMapStart(yynn2)
 27945  				yynn2 = 0
 27946  			}
 27947  			if yyr2 || yy2arr2 {
 27948  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 27949  				yym4 := z.EncBinary()
 27950  				_ = yym4
 27951  				if false {
 27952  				} else {
 27953  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 27954  				}
 27955  			} else {
 27956  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 27957  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentID"))
 27958  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 27959  				yym5 := z.EncBinary()
 27960  				_ = yym5
 27961  				if false {
 27962  				} else {
 27963  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 27964  				}
 27965  			}
 27966  			if yyr2 || yy2arr2 {
 27967  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 27968  				yym7 := z.EncBinary()
 27969  				_ = yym7
 27970  				if false {
 27971  				} else {
 27972  					r.EncodeBool(bool(x.Pause))
 27973  				}
 27974  			} else {
 27975  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 27976  				r.EncodeString(codecSelferC_UTF8100, string("Pause"))
 27977  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 27978  				yym8 := z.EncBinary()
 27979  				_ = yym8
 27980  				if false {
 27981  				} else {
 27982  					r.EncodeBool(bool(x.Pause))
 27983  				}
 27984  			}
 27985  			if yyr2 || yy2arr2 {
 27986  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 27987  				yym10 := z.EncBinary()
 27988  				_ = yym10
 27989  				if false {
 27990  				} else {
 27991  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 27992  				}
 27993  			} else {
 27994  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 27995  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 27996  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 27997  				yym11 := z.EncBinary()
 27998  				_ = yym11
 27999  				if false {
 28000  				} else {
 28001  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 28002  				}
 28003  			}
 28004  			if yyr2 || yy2arr2 {
 28005  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 28006  				yym13 := z.EncBinary()
 28007  				_ = yym13
 28008  				if false {
 28009  				} else {
 28010  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 28011  				}
 28012  			} else {
 28013  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 28014  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 28015  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 28016  				yym14 := z.EncBinary()
 28017  				_ = yym14
 28018  				if false {
 28019  				} else {
 28020  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 28021  				}
 28022  			}
 28023  			if yyr2 || yy2arr2 {
 28024  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 28025  				yym16 := z.EncBinary()
 28026  				_ = yym16
 28027  				if false {
 28028  				} else {
 28029  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 28030  				}
 28031  			} else {
 28032  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 28033  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 28034  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 28035  				yym17 := z.EncBinary()
 28036  				_ = yym17
 28037  				if false {
 28038  				} else {
 28039  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 28040  				}
 28041  			}
 28042  			if yyr2 || yy2arr2 {
 28043  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 28044  				yym19 := z.EncBinary()
 28045  				_ = yym19
 28046  				if false {
 28047  				} else {
 28048  					r.EncodeBool(bool(x.Forwarded))
 28049  				}
 28050  			} else {
 28051  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 28052  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 28053  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 28054  				yym20 := z.EncBinary()
 28055  				_ = yym20
 28056  				if false {
 28057  				} else {
 28058  					r.EncodeBool(bool(x.Forwarded))
 28059  				}
 28060  			}
 28061  			if yyr2 || yy2arr2 {
 28062  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 28063  			} else {
 28064  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 28065  			}
 28066  		}
 28067  	}
 28068  }
 28069  
 28070  func (x *DeploymentPauseRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 28071  	var h codecSelfer100
 28072  	z, r := codec1978.GenHelperDecoder(d)
 28073  	_, _, _ = h, z, r
 28074  	yym1 := z.DecBinary()
 28075  	_ = yym1
 28076  	if false {
 28077  	} else if z.HasExtensions() && z.DecExt(x) {
 28078  	} else {
 28079  		yyct2 := r.ContainerType()
 28080  		if yyct2 == codecSelferValueTypeMap100 {
 28081  			yyl2 := r.ReadMapStart()
 28082  			if yyl2 == 0 {
 28083  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 28084  			} else {
 28085  				x.codecDecodeSelfFromMap(yyl2, d)
 28086  			}
 28087  		} else if yyct2 == codecSelferValueTypeArray100 {
 28088  			yyl2 := r.ReadArrayStart()
 28089  			if yyl2 == 0 {
 28090  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28091  			} else {
 28092  				x.codecDecodeSelfFromArray(yyl2, d)
 28093  			}
 28094  		} else {
 28095  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 28096  		}
 28097  	}
 28098  }
 28099  
 28100  func (x *DeploymentPauseRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 28101  	var h codecSelfer100
 28102  	z, r := codec1978.GenHelperDecoder(d)
 28103  	_, _, _ = h, z, r
 28104  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 28105  	_ = yys3Slc
 28106  	var yyhl3 bool = l >= 0
 28107  	for yyj3 := 0; ; yyj3++ {
 28108  		if yyhl3 {
 28109  			if yyj3 >= l {
 28110  				break
 28111  			}
 28112  		} else {
 28113  			if r.CheckBreak() {
 28114  				break
 28115  			}
 28116  		}
 28117  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 28118  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 28119  		yys3 := string(yys3Slc)
 28120  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 28121  		switch yys3 {
 28122  		case "DeploymentID":
 28123  			if r.TryDecodeAsNil() {
 28124  				x.DeploymentID = ""
 28125  			} else {
 28126  				yyv4 := &x.DeploymentID
 28127  				yym5 := z.DecBinary()
 28128  				_ = yym5
 28129  				if false {
 28130  				} else {
 28131  					*((*string)(yyv4)) = r.DecodeString()
 28132  				}
 28133  			}
 28134  		case "Pause":
 28135  			if r.TryDecodeAsNil() {
 28136  				x.Pause = false
 28137  			} else {
 28138  				yyv6 := &x.Pause
 28139  				yym7 := z.DecBinary()
 28140  				_ = yym7
 28141  				if false {
 28142  				} else {
 28143  					*((*bool)(yyv6)) = r.DecodeBool()
 28144  				}
 28145  			}
 28146  		case "Region":
 28147  			if r.TryDecodeAsNil() {
 28148  				x.Region = ""
 28149  			} else {
 28150  				yyv8 := &x.Region
 28151  				yym9 := z.DecBinary()
 28152  				_ = yym9
 28153  				if false {
 28154  				} else {
 28155  					*((*string)(yyv8)) = r.DecodeString()
 28156  				}
 28157  			}
 28158  		case "Namespace":
 28159  			if r.TryDecodeAsNil() {
 28160  				x.Namespace = ""
 28161  			} else {
 28162  				yyv10 := &x.Namespace
 28163  				yym11 := z.DecBinary()
 28164  				_ = yym11
 28165  				if false {
 28166  				} else {
 28167  					*((*string)(yyv10)) = r.DecodeString()
 28168  				}
 28169  			}
 28170  		case "AuthToken":
 28171  			if r.TryDecodeAsNil() {
 28172  				x.AuthToken = ""
 28173  			} else {
 28174  				yyv12 := &x.AuthToken
 28175  				yym13 := z.DecBinary()
 28176  				_ = yym13
 28177  				if false {
 28178  				} else {
 28179  					*((*string)(yyv12)) = r.DecodeString()
 28180  				}
 28181  			}
 28182  		case "Forwarded":
 28183  			if r.TryDecodeAsNil() {
 28184  				x.Forwarded = false
 28185  			} else {
 28186  				yyv14 := &x.Forwarded
 28187  				yym15 := z.DecBinary()
 28188  				_ = yym15
 28189  				if false {
 28190  				} else {
 28191  					*((*bool)(yyv14)) = r.DecodeBool()
 28192  				}
 28193  			}
 28194  		default:
 28195  			z.DecStructFieldNotFound(-1, yys3)
 28196  		} // end switch yys3
 28197  	} // end for yyj3
 28198  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 28199  }
 28200  
 28201  func (x *DeploymentPauseRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 28202  	var h codecSelfer100
 28203  	z, r := codec1978.GenHelperDecoder(d)
 28204  	_, _, _ = h, z, r
 28205  	var yyj16 int
 28206  	var yyb16 bool
 28207  	var yyhl16 bool = l >= 0
 28208  	yyj16++
 28209  	if yyhl16 {
 28210  		yyb16 = yyj16 > l
 28211  	} else {
 28212  		yyb16 = r.CheckBreak()
 28213  	}
 28214  	if yyb16 {
 28215  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28216  		return
 28217  	}
 28218  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28219  	if r.TryDecodeAsNil() {
 28220  		x.DeploymentID = ""
 28221  	} else {
 28222  		yyv17 := &x.DeploymentID
 28223  		yym18 := z.DecBinary()
 28224  		_ = yym18
 28225  		if false {
 28226  		} else {
 28227  			*((*string)(yyv17)) = r.DecodeString()
 28228  		}
 28229  	}
 28230  	yyj16++
 28231  	if yyhl16 {
 28232  		yyb16 = yyj16 > l
 28233  	} else {
 28234  		yyb16 = r.CheckBreak()
 28235  	}
 28236  	if yyb16 {
 28237  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28238  		return
 28239  	}
 28240  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28241  	if r.TryDecodeAsNil() {
 28242  		x.Pause = false
 28243  	} else {
 28244  		yyv19 := &x.Pause
 28245  		yym20 := z.DecBinary()
 28246  		_ = yym20
 28247  		if false {
 28248  		} else {
 28249  			*((*bool)(yyv19)) = r.DecodeBool()
 28250  		}
 28251  	}
 28252  	yyj16++
 28253  	if yyhl16 {
 28254  		yyb16 = yyj16 > l
 28255  	} else {
 28256  		yyb16 = r.CheckBreak()
 28257  	}
 28258  	if yyb16 {
 28259  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28260  		return
 28261  	}
 28262  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28263  	if r.TryDecodeAsNil() {
 28264  		x.Region = ""
 28265  	} else {
 28266  		yyv21 := &x.Region
 28267  		yym22 := z.DecBinary()
 28268  		_ = yym22
 28269  		if false {
 28270  		} else {
 28271  			*((*string)(yyv21)) = r.DecodeString()
 28272  		}
 28273  	}
 28274  	yyj16++
 28275  	if yyhl16 {
 28276  		yyb16 = yyj16 > l
 28277  	} else {
 28278  		yyb16 = r.CheckBreak()
 28279  	}
 28280  	if yyb16 {
 28281  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28282  		return
 28283  	}
 28284  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28285  	if r.TryDecodeAsNil() {
 28286  		x.Namespace = ""
 28287  	} else {
 28288  		yyv23 := &x.Namespace
 28289  		yym24 := z.DecBinary()
 28290  		_ = yym24
 28291  		if false {
 28292  		} else {
 28293  			*((*string)(yyv23)) = r.DecodeString()
 28294  		}
 28295  	}
 28296  	yyj16++
 28297  	if yyhl16 {
 28298  		yyb16 = yyj16 > l
 28299  	} else {
 28300  		yyb16 = r.CheckBreak()
 28301  	}
 28302  	if yyb16 {
 28303  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28304  		return
 28305  	}
 28306  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28307  	if r.TryDecodeAsNil() {
 28308  		x.AuthToken = ""
 28309  	} else {
 28310  		yyv25 := &x.AuthToken
 28311  		yym26 := z.DecBinary()
 28312  		_ = yym26
 28313  		if false {
 28314  		} else {
 28315  			*((*string)(yyv25)) = r.DecodeString()
 28316  		}
 28317  	}
 28318  	yyj16++
 28319  	if yyhl16 {
 28320  		yyb16 = yyj16 > l
 28321  	} else {
 28322  		yyb16 = r.CheckBreak()
 28323  	}
 28324  	if yyb16 {
 28325  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28326  		return
 28327  	}
 28328  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28329  	if r.TryDecodeAsNil() {
 28330  		x.Forwarded = false
 28331  	} else {
 28332  		yyv27 := &x.Forwarded
 28333  		yym28 := z.DecBinary()
 28334  		_ = yym28
 28335  		if false {
 28336  		} else {
 28337  			*((*bool)(yyv27)) = r.DecodeBool()
 28338  		}
 28339  	}
 28340  	for {
 28341  		yyj16++
 28342  		if yyhl16 {
 28343  			yyb16 = yyj16 > l
 28344  		} else {
 28345  			yyb16 = r.CheckBreak()
 28346  		}
 28347  		if yyb16 {
 28348  			break
 28349  		}
 28350  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28351  		z.DecStructFieldNotFound(yyj16-1, "")
 28352  	}
 28353  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28354  }
 28355  
 28356  func (x *DeploymentSpecificRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 28357  	var h codecSelfer100
 28358  	z, r := codec1978.GenHelperEncoder(e)
 28359  	_, _, _ = h, z, r
 28360  	if x == nil {
 28361  		r.EncodeNil()
 28362  	} else {
 28363  		yym1 := z.EncBinary()
 28364  		_ = yym1
 28365  		if false {
 28366  		} else if z.HasExtensions() && z.EncExt(x) {
 28367  		} else {
 28368  			yysep2 := !z.EncBinary()
 28369  			yy2arr2 := z.EncBasicHandle().StructToArray
 28370  			var yyq2 [9]bool
 28371  			_, _, _ = yysep2, yyq2, yy2arr2
 28372  			const yyr2 bool = false
 28373  			var yynn2 int
 28374  			if yyr2 || yy2arr2 {
 28375  				r.EncodeArrayStart(9)
 28376  			} else {
 28377  				yynn2 = 9
 28378  				for _, b := range yyq2 {
 28379  					if b {
 28380  						yynn2++
 28381  					}
 28382  				}
 28383  				r.EncodeMapStart(yynn2)
 28384  				yynn2 = 0
 28385  			}
 28386  			if yyr2 || yy2arr2 {
 28387  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 28388  				yym4 := z.EncBinary()
 28389  				_ = yym4
 28390  				if false {
 28391  				} else {
 28392  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 28393  				}
 28394  			} else {
 28395  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 28396  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentID"))
 28397  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 28398  				yym5 := z.EncBinary()
 28399  				_ = yym5
 28400  				if false {
 28401  				} else {
 28402  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 28403  				}
 28404  			}
 28405  			if yyr2 || yy2arr2 {
 28406  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 28407  				yym7 := z.EncBinary()
 28408  				_ = yym7
 28409  				if false {
 28410  				} else {
 28411  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 28412  				}
 28413  			} else {
 28414  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 28415  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 28416  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 28417  				yym8 := z.EncBinary()
 28418  				_ = yym8
 28419  				if false {
 28420  				} else {
 28421  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 28422  				}
 28423  			}
 28424  			if yyr2 || yy2arr2 {
 28425  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 28426  				yym10 := z.EncBinary()
 28427  				_ = yym10
 28428  				if false {
 28429  				} else {
 28430  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 28431  				}
 28432  			} else {
 28433  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 28434  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 28435  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 28436  				yym11 := z.EncBinary()
 28437  				_ = yym11
 28438  				if false {
 28439  				} else {
 28440  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 28441  				}
 28442  			}
 28443  			if yyr2 || yy2arr2 {
 28444  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 28445  				yym13 := z.EncBinary()
 28446  				_ = yym13
 28447  				if false {
 28448  				} else {
 28449  					r.EncodeUint(uint64(x.MinQueryIndex))
 28450  				}
 28451  			} else {
 28452  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 28453  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 28454  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 28455  				yym14 := z.EncBinary()
 28456  				_ = yym14
 28457  				if false {
 28458  				} else {
 28459  					r.EncodeUint(uint64(x.MinQueryIndex))
 28460  				}
 28461  			}
 28462  			if yyr2 || yy2arr2 {
 28463  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 28464  				yym16 := z.EncBinary()
 28465  				_ = yym16
 28466  				if false {
 28467  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 28468  				} else {
 28469  					r.EncodeInt(int64(x.MaxQueryTime))
 28470  				}
 28471  			} else {
 28472  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 28473  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 28474  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 28475  				yym17 := z.EncBinary()
 28476  				_ = yym17
 28477  				if false {
 28478  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 28479  				} else {
 28480  					r.EncodeInt(int64(x.MaxQueryTime))
 28481  				}
 28482  			}
 28483  			if yyr2 || yy2arr2 {
 28484  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 28485  				yym19 := z.EncBinary()
 28486  				_ = yym19
 28487  				if false {
 28488  				} else {
 28489  					r.EncodeBool(bool(x.AllowStale))
 28490  				}
 28491  			} else {
 28492  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 28493  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 28494  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 28495  				yym20 := z.EncBinary()
 28496  				_ = yym20
 28497  				if false {
 28498  				} else {
 28499  					r.EncodeBool(bool(x.AllowStale))
 28500  				}
 28501  			}
 28502  			if yyr2 || yy2arr2 {
 28503  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 28504  				yym22 := z.EncBinary()
 28505  				_ = yym22
 28506  				if false {
 28507  				} else {
 28508  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 28509  				}
 28510  			} else {
 28511  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 28512  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 28513  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 28514  				yym23 := z.EncBinary()
 28515  				_ = yym23
 28516  				if false {
 28517  				} else {
 28518  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 28519  				}
 28520  			}
 28521  			if yyr2 || yy2arr2 {
 28522  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 28523  				yym25 := z.EncBinary()
 28524  				_ = yym25
 28525  				if false {
 28526  				} else {
 28527  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 28528  				}
 28529  			} else {
 28530  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 28531  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 28532  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 28533  				yym26 := z.EncBinary()
 28534  				_ = yym26
 28535  				if false {
 28536  				} else {
 28537  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 28538  				}
 28539  			}
 28540  			if yyr2 || yy2arr2 {
 28541  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 28542  				yym28 := z.EncBinary()
 28543  				_ = yym28
 28544  				if false {
 28545  				} else {
 28546  					r.EncodeBool(bool(x.Forwarded))
 28547  				}
 28548  			} else {
 28549  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 28550  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 28551  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 28552  				yym29 := z.EncBinary()
 28553  				_ = yym29
 28554  				if false {
 28555  				} else {
 28556  					r.EncodeBool(bool(x.Forwarded))
 28557  				}
 28558  			}
 28559  			if yyr2 || yy2arr2 {
 28560  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 28561  			} else {
 28562  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 28563  			}
 28564  		}
 28565  	}
 28566  }
 28567  
 28568  func (x *DeploymentSpecificRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 28569  	var h codecSelfer100
 28570  	z, r := codec1978.GenHelperDecoder(d)
 28571  	_, _, _ = h, z, r
 28572  	yym1 := z.DecBinary()
 28573  	_ = yym1
 28574  	if false {
 28575  	} else if z.HasExtensions() && z.DecExt(x) {
 28576  	} else {
 28577  		yyct2 := r.ContainerType()
 28578  		if yyct2 == codecSelferValueTypeMap100 {
 28579  			yyl2 := r.ReadMapStart()
 28580  			if yyl2 == 0 {
 28581  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 28582  			} else {
 28583  				x.codecDecodeSelfFromMap(yyl2, d)
 28584  			}
 28585  		} else if yyct2 == codecSelferValueTypeArray100 {
 28586  			yyl2 := r.ReadArrayStart()
 28587  			if yyl2 == 0 {
 28588  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28589  			} else {
 28590  				x.codecDecodeSelfFromArray(yyl2, d)
 28591  			}
 28592  		} else {
 28593  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 28594  		}
 28595  	}
 28596  }
 28597  
 28598  func (x *DeploymentSpecificRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 28599  	var h codecSelfer100
 28600  	z, r := codec1978.GenHelperDecoder(d)
 28601  	_, _, _ = h, z, r
 28602  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 28603  	_ = yys3Slc
 28604  	var yyhl3 bool = l >= 0
 28605  	for yyj3 := 0; ; yyj3++ {
 28606  		if yyhl3 {
 28607  			if yyj3 >= l {
 28608  				break
 28609  			}
 28610  		} else {
 28611  			if r.CheckBreak() {
 28612  				break
 28613  			}
 28614  		}
 28615  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 28616  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 28617  		yys3 := string(yys3Slc)
 28618  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 28619  		switch yys3 {
 28620  		case "DeploymentID":
 28621  			if r.TryDecodeAsNil() {
 28622  				x.DeploymentID = ""
 28623  			} else {
 28624  				yyv4 := &x.DeploymentID
 28625  				yym5 := z.DecBinary()
 28626  				_ = yym5
 28627  				if false {
 28628  				} else {
 28629  					*((*string)(yyv4)) = r.DecodeString()
 28630  				}
 28631  			}
 28632  		case "Region":
 28633  			if r.TryDecodeAsNil() {
 28634  				x.Region = ""
 28635  			} else {
 28636  				yyv6 := &x.Region
 28637  				yym7 := z.DecBinary()
 28638  				_ = yym7
 28639  				if false {
 28640  				} else {
 28641  					*((*string)(yyv6)) = r.DecodeString()
 28642  				}
 28643  			}
 28644  		case "Namespace":
 28645  			if r.TryDecodeAsNil() {
 28646  				x.Namespace = ""
 28647  			} else {
 28648  				yyv8 := &x.Namespace
 28649  				yym9 := z.DecBinary()
 28650  				_ = yym9
 28651  				if false {
 28652  				} else {
 28653  					*((*string)(yyv8)) = r.DecodeString()
 28654  				}
 28655  			}
 28656  		case "MinQueryIndex":
 28657  			if r.TryDecodeAsNil() {
 28658  				x.MinQueryIndex = 0
 28659  			} else {
 28660  				yyv10 := &x.MinQueryIndex
 28661  				yym11 := z.DecBinary()
 28662  				_ = yym11
 28663  				if false {
 28664  				} else {
 28665  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 28666  				}
 28667  			}
 28668  		case "MaxQueryTime":
 28669  			if r.TryDecodeAsNil() {
 28670  				x.MaxQueryTime = 0
 28671  			} else {
 28672  				yyv12 := &x.MaxQueryTime
 28673  				yym13 := z.DecBinary()
 28674  				_ = yym13
 28675  				if false {
 28676  				} else if z.HasExtensions() && z.DecExt(yyv12) {
 28677  				} else {
 28678  					*((*int64)(yyv12)) = int64(r.DecodeInt(64))
 28679  				}
 28680  			}
 28681  		case "AllowStale":
 28682  			if r.TryDecodeAsNil() {
 28683  				x.AllowStale = false
 28684  			} else {
 28685  				yyv14 := &x.AllowStale
 28686  				yym15 := z.DecBinary()
 28687  				_ = yym15
 28688  				if false {
 28689  				} else {
 28690  					*((*bool)(yyv14)) = r.DecodeBool()
 28691  				}
 28692  			}
 28693  		case "Prefix":
 28694  			if r.TryDecodeAsNil() {
 28695  				x.Prefix = ""
 28696  			} else {
 28697  				yyv16 := &x.Prefix
 28698  				yym17 := z.DecBinary()
 28699  				_ = yym17
 28700  				if false {
 28701  				} else {
 28702  					*((*string)(yyv16)) = r.DecodeString()
 28703  				}
 28704  			}
 28705  		case "AuthToken":
 28706  			if r.TryDecodeAsNil() {
 28707  				x.AuthToken = ""
 28708  			} else {
 28709  				yyv18 := &x.AuthToken
 28710  				yym19 := z.DecBinary()
 28711  				_ = yym19
 28712  				if false {
 28713  				} else {
 28714  					*((*string)(yyv18)) = r.DecodeString()
 28715  				}
 28716  			}
 28717  		case "Forwarded":
 28718  			if r.TryDecodeAsNil() {
 28719  				x.Forwarded = false
 28720  			} else {
 28721  				yyv20 := &x.Forwarded
 28722  				yym21 := z.DecBinary()
 28723  				_ = yym21
 28724  				if false {
 28725  				} else {
 28726  					*((*bool)(yyv20)) = r.DecodeBool()
 28727  				}
 28728  			}
 28729  		default:
 28730  			z.DecStructFieldNotFound(-1, yys3)
 28731  		} // end switch yys3
 28732  	} // end for yyj3
 28733  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 28734  }
 28735  
 28736  func (x *DeploymentSpecificRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 28737  	var h codecSelfer100
 28738  	z, r := codec1978.GenHelperDecoder(d)
 28739  	_, _, _ = h, z, r
 28740  	var yyj22 int
 28741  	var yyb22 bool
 28742  	var yyhl22 bool = l >= 0
 28743  	yyj22++
 28744  	if yyhl22 {
 28745  		yyb22 = yyj22 > l
 28746  	} else {
 28747  		yyb22 = r.CheckBreak()
 28748  	}
 28749  	if yyb22 {
 28750  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28751  		return
 28752  	}
 28753  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28754  	if r.TryDecodeAsNil() {
 28755  		x.DeploymentID = ""
 28756  	} else {
 28757  		yyv23 := &x.DeploymentID
 28758  		yym24 := z.DecBinary()
 28759  		_ = yym24
 28760  		if false {
 28761  		} else {
 28762  			*((*string)(yyv23)) = r.DecodeString()
 28763  		}
 28764  	}
 28765  	yyj22++
 28766  	if yyhl22 {
 28767  		yyb22 = yyj22 > l
 28768  	} else {
 28769  		yyb22 = r.CheckBreak()
 28770  	}
 28771  	if yyb22 {
 28772  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28773  		return
 28774  	}
 28775  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28776  	if r.TryDecodeAsNil() {
 28777  		x.Region = ""
 28778  	} else {
 28779  		yyv25 := &x.Region
 28780  		yym26 := z.DecBinary()
 28781  		_ = yym26
 28782  		if false {
 28783  		} else {
 28784  			*((*string)(yyv25)) = r.DecodeString()
 28785  		}
 28786  	}
 28787  	yyj22++
 28788  	if yyhl22 {
 28789  		yyb22 = yyj22 > l
 28790  	} else {
 28791  		yyb22 = r.CheckBreak()
 28792  	}
 28793  	if yyb22 {
 28794  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28795  		return
 28796  	}
 28797  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28798  	if r.TryDecodeAsNil() {
 28799  		x.Namespace = ""
 28800  	} else {
 28801  		yyv27 := &x.Namespace
 28802  		yym28 := z.DecBinary()
 28803  		_ = yym28
 28804  		if false {
 28805  		} else {
 28806  			*((*string)(yyv27)) = r.DecodeString()
 28807  		}
 28808  	}
 28809  	yyj22++
 28810  	if yyhl22 {
 28811  		yyb22 = yyj22 > l
 28812  	} else {
 28813  		yyb22 = r.CheckBreak()
 28814  	}
 28815  	if yyb22 {
 28816  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28817  		return
 28818  	}
 28819  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28820  	if r.TryDecodeAsNil() {
 28821  		x.MinQueryIndex = 0
 28822  	} else {
 28823  		yyv29 := &x.MinQueryIndex
 28824  		yym30 := z.DecBinary()
 28825  		_ = yym30
 28826  		if false {
 28827  		} else {
 28828  			*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
 28829  		}
 28830  	}
 28831  	yyj22++
 28832  	if yyhl22 {
 28833  		yyb22 = yyj22 > l
 28834  	} else {
 28835  		yyb22 = r.CheckBreak()
 28836  	}
 28837  	if yyb22 {
 28838  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28839  		return
 28840  	}
 28841  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28842  	if r.TryDecodeAsNil() {
 28843  		x.MaxQueryTime = 0
 28844  	} else {
 28845  		yyv31 := &x.MaxQueryTime
 28846  		yym32 := z.DecBinary()
 28847  		_ = yym32
 28848  		if false {
 28849  		} else if z.HasExtensions() && z.DecExt(yyv31) {
 28850  		} else {
 28851  			*((*int64)(yyv31)) = int64(r.DecodeInt(64))
 28852  		}
 28853  	}
 28854  	yyj22++
 28855  	if yyhl22 {
 28856  		yyb22 = yyj22 > l
 28857  	} else {
 28858  		yyb22 = r.CheckBreak()
 28859  	}
 28860  	if yyb22 {
 28861  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28862  		return
 28863  	}
 28864  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28865  	if r.TryDecodeAsNil() {
 28866  		x.AllowStale = false
 28867  	} else {
 28868  		yyv33 := &x.AllowStale
 28869  		yym34 := z.DecBinary()
 28870  		_ = yym34
 28871  		if false {
 28872  		} else {
 28873  			*((*bool)(yyv33)) = r.DecodeBool()
 28874  		}
 28875  	}
 28876  	yyj22++
 28877  	if yyhl22 {
 28878  		yyb22 = yyj22 > l
 28879  	} else {
 28880  		yyb22 = r.CheckBreak()
 28881  	}
 28882  	if yyb22 {
 28883  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28884  		return
 28885  	}
 28886  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28887  	if r.TryDecodeAsNil() {
 28888  		x.Prefix = ""
 28889  	} else {
 28890  		yyv35 := &x.Prefix
 28891  		yym36 := z.DecBinary()
 28892  		_ = yym36
 28893  		if false {
 28894  		} else {
 28895  			*((*string)(yyv35)) = r.DecodeString()
 28896  		}
 28897  	}
 28898  	yyj22++
 28899  	if yyhl22 {
 28900  		yyb22 = yyj22 > l
 28901  	} else {
 28902  		yyb22 = r.CheckBreak()
 28903  	}
 28904  	if yyb22 {
 28905  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28906  		return
 28907  	}
 28908  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28909  	if r.TryDecodeAsNil() {
 28910  		x.AuthToken = ""
 28911  	} else {
 28912  		yyv37 := &x.AuthToken
 28913  		yym38 := z.DecBinary()
 28914  		_ = yym38
 28915  		if false {
 28916  		} else {
 28917  			*((*string)(yyv37)) = r.DecodeString()
 28918  		}
 28919  	}
 28920  	yyj22++
 28921  	if yyhl22 {
 28922  		yyb22 = yyj22 > l
 28923  	} else {
 28924  		yyb22 = r.CheckBreak()
 28925  	}
 28926  	if yyb22 {
 28927  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28928  		return
 28929  	}
 28930  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28931  	if r.TryDecodeAsNil() {
 28932  		x.Forwarded = false
 28933  	} else {
 28934  		yyv39 := &x.Forwarded
 28935  		yym40 := z.DecBinary()
 28936  		_ = yym40
 28937  		if false {
 28938  		} else {
 28939  			*((*bool)(yyv39)) = r.DecodeBool()
 28940  		}
 28941  	}
 28942  	for {
 28943  		yyj22++
 28944  		if yyhl22 {
 28945  			yyb22 = yyj22 > l
 28946  		} else {
 28947  			yyb22 = r.CheckBreak()
 28948  		}
 28949  		if yyb22 {
 28950  			break
 28951  		}
 28952  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 28953  		z.DecStructFieldNotFound(yyj22-1, "")
 28954  	}
 28955  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 28956  }
 28957  
 28958  func (x *DeploymentFailRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 28959  	var h codecSelfer100
 28960  	z, r := codec1978.GenHelperEncoder(e)
 28961  	_, _, _ = h, z, r
 28962  	if x == nil {
 28963  		r.EncodeNil()
 28964  	} else {
 28965  		yym1 := z.EncBinary()
 28966  		_ = yym1
 28967  		if false {
 28968  		} else if z.HasExtensions() && z.EncExt(x) {
 28969  		} else {
 28970  			yysep2 := !z.EncBinary()
 28971  			yy2arr2 := z.EncBasicHandle().StructToArray
 28972  			var yyq2 [5]bool
 28973  			_, _, _ = yysep2, yyq2, yy2arr2
 28974  			const yyr2 bool = false
 28975  			var yynn2 int
 28976  			if yyr2 || yy2arr2 {
 28977  				r.EncodeArrayStart(5)
 28978  			} else {
 28979  				yynn2 = 5
 28980  				for _, b := range yyq2 {
 28981  					if b {
 28982  						yynn2++
 28983  					}
 28984  				}
 28985  				r.EncodeMapStart(yynn2)
 28986  				yynn2 = 0
 28987  			}
 28988  			if yyr2 || yy2arr2 {
 28989  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 28990  				yym4 := z.EncBinary()
 28991  				_ = yym4
 28992  				if false {
 28993  				} else {
 28994  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 28995  				}
 28996  			} else {
 28997  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 28998  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentID"))
 28999  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 29000  				yym5 := z.EncBinary()
 29001  				_ = yym5
 29002  				if false {
 29003  				} else {
 29004  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 29005  				}
 29006  			}
 29007  			if yyr2 || yy2arr2 {
 29008  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 29009  				yym7 := z.EncBinary()
 29010  				_ = yym7
 29011  				if false {
 29012  				} else {
 29013  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 29014  				}
 29015  			} else {
 29016  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 29017  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 29018  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 29019  				yym8 := z.EncBinary()
 29020  				_ = yym8
 29021  				if false {
 29022  				} else {
 29023  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 29024  				}
 29025  			}
 29026  			if yyr2 || yy2arr2 {
 29027  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 29028  				yym10 := z.EncBinary()
 29029  				_ = yym10
 29030  				if false {
 29031  				} else {
 29032  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 29033  				}
 29034  			} else {
 29035  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 29036  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 29037  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 29038  				yym11 := z.EncBinary()
 29039  				_ = yym11
 29040  				if false {
 29041  				} else {
 29042  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 29043  				}
 29044  			}
 29045  			if yyr2 || yy2arr2 {
 29046  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 29047  				yym13 := z.EncBinary()
 29048  				_ = yym13
 29049  				if false {
 29050  				} else {
 29051  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 29052  				}
 29053  			} else {
 29054  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 29055  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 29056  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 29057  				yym14 := z.EncBinary()
 29058  				_ = yym14
 29059  				if false {
 29060  				} else {
 29061  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 29062  				}
 29063  			}
 29064  			if yyr2 || yy2arr2 {
 29065  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 29066  				yym16 := z.EncBinary()
 29067  				_ = yym16
 29068  				if false {
 29069  				} else {
 29070  					r.EncodeBool(bool(x.Forwarded))
 29071  				}
 29072  			} else {
 29073  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 29074  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 29075  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 29076  				yym17 := z.EncBinary()
 29077  				_ = yym17
 29078  				if false {
 29079  				} else {
 29080  					r.EncodeBool(bool(x.Forwarded))
 29081  				}
 29082  			}
 29083  			if yyr2 || yy2arr2 {
 29084  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 29085  			} else {
 29086  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 29087  			}
 29088  		}
 29089  	}
 29090  }
 29091  
 29092  func (x *DeploymentFailRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 29093  	var h codecSelfer100
 29094  	z, r := codec1978.GenHelperDecoder(d)
 29095  	_, _, _ = h, z, r
 29096  	yym1 := z.DecBinary()
 29097  	_ = yym1
 29098  	if false {
 29099  	} else if z.HasExtensions() && z.DecExt(x) {
 29100  	} else {
 29101  		yyct2 := r.ContainerType()
 29102  		if yyct2 == codecSelferValueTypeMap100 {
 29103  			yyl2 := r.ReadMapStart()
 29104  			if yyl2 == 0 {
 29105  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 29106  			} else {
 29107  				x.codecDecodeSelfFromMap(yyl2, d)
 29108  			}
 29109  		} else if yyct2 == codecSelferValueTypeArray100 {
 29110  			yyl2 := r.ReadArrayStart()
 29111  			if yyl2 == 0 {
 29112  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29113  			} else {
 29114  				x.codecDecodeSelfFromArray(yyl2, d)
 29115  			}
 29116  		} else {
 29117  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 29118  		}
 29119  	}
 29120  }
 29121  
 29122  func (x *DeploymentFailRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 29123  	var h codecSelfer100
 29124  	z, r := codec1978.GenHelperDecoder(d)
 29125  	_, _, _ = h, z, r
 29126  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 29127  	_ = yys3Slc
 29128  	var yyhl3 bool = l >= 0
 29129  	for yyj3 := 0; ; yyj3++ {
 29130  		if yyhl3 {
 29131  			if yyj3 >= l {
 29132  				break
 29133  			}
 29134  		} else {
 29135  			if r.CheckBreak() {
 29136  				break
 29137  			}
 29138  		}
 29139  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 29140  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 29141  		yys3 := string(yys3Slc)
 29142  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 29143  		switch yys3 {
 29144  		case "DeploymentID":
 29145  			if r.TryDecodeAsNil() {
 29146  				x.DeploymentID = ""
 29147  			} else {
 29148  				yyv4 := &x.DeploymentID
 29149  				yym5 := z.DecBinary()
 29150  				_ = yym5
 29151  				if false {
 29152  				} else {
 29153  					*((*string)(yyv4)) = r.DecodeString()
 29154  				}
 29155  			}
 29156  		case "Region":
 29157  			if r.TryDecodeAsNil() {
 29158  				x.Region = ""
 29159  			} else {
 29160  				yyv6 := &x.Region
 29161  				yym7 := z.DecBinary()
 29162  				_ = yym7
 29163  				if false {
 29164  				} else {
 29165  					*((*string)(yyv6)) = r.DecodeString()
 29166  				}
 29167  			}
 29168  		case "Namespace":
 29169  			if r.TryDecodeAsNil() {
 29170  				x.Namespace = ""
 29171  			} else {
 29172  				yyv8 := &x.Namespace
 29173  				yym9 := z.DecBinary()
 29174  				_ = yym9
 29175  				if false {
 29176  				} else {
 29177  					*((*string)(yyv8)) = r.DecodeString()
 29178  				}
 29179  			}
 29180  		case "AuthToken":
 29181  			if r.TryDecodeAsNil() {
 29182  				x.AuthToken = ""
 29183  			} else {
 29184  				yyv10 := &x.AuthToken
 29185  				yym11 := z.DecBinary()
 29186  				_ = yym11
 29187  				if false {
 29188  				} else {
 29189  					*((*string)(yyv10)) = r.DecodeString()
 29190  				}
 29191  			}
 29192  		case "Forwarded":
 29193  			if r.TryDecodeAsNil() {
 29194  				x.Forwarded = false
 29195  			} else {
 29196  				yyv12 := &x.Forwarded
 29197  				yym13 := z.DecBinary()
 29198  				_ = yym13
 29199  				if false {
 29200  				} else {
 29201  					*((*bool)(yyv12)) = r.DecodeBool()
 29202  				}
 29203  			}
 29204  		default:
 29205  			z.DecStructFieldNotFound(-1, yys3)
 29206  		} // end switch yys3
 29207  	} // end for yyj3
 29208  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 29209  }
 29210  
 29211  func (x *DeploymentFailRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 29212  	var h codecSelfer100
 29213  	z, r := codec1978.GenHelperDecoder(d)
 29214  	_, _, _ = h, z, r
 29215  	var yyj14 int
 29216  	var yyb14 bool
 29217  	var yyhl14 bool = l >= 0
 29218  	yyj14++
 29219  	if yyhl14 {
 29220  		yyb14 = yyj14 > l
 29221  	} else {
 29222  		yyb14 = r.CheckBreak()
 29223  	}
 29224  	if yyb14 {
 29225  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29226  		return
 29227  	}
 29228  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 29229  	if r.TryDecodeAsNil() {
 29230  		x.DeploymentID = ""
 29231  	} else {
 29232  		yyv15 := &x.DeploymentID
 29233  		yym16 := z.DecBinary()
 29234  		_ = yym16
 29235  		if false {
 29236  		} else {
 29237  			*((*string)(yyv15)) = r.DecodeString()
 29238  		}
 29239  	}
 29240  	yyj14++
 29241  	if yyhl14 {
 29242  		yyb14 = yyj14 > l
 29243  	} else {
 29244  		yyb14 = r.CheckBreak()
 29245  	}
 29246  	if yyb14 {
 29247  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29248  		return
 29249  	}
 29250  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 29251  	if r.TryDecodeAsNil() {
 29252  		x.Region = ""
 29253  	} else {
 29254  		yyv17 := &x.Region
 29255  		yym18 := z.DecBinary()
 29256  		_ = yym18
 29257  		if false {
 29258  		} else {
 29259  			*((*string)(yyv17)) = r.DecodeString()
 29260  		}
 29261  	}
 29262  	yyj14++
 29263  	if yyhl14 {
 29264  		yyb14 = yyj14 > l
 29265  	} else {
 29266  		yyb14 = r.CheckBreak()
 29267  	}
 29268  	if yyb14 {
 29269  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29270  		return
 29271  	}
 29272  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 29273  	if r.TryDecodeAsNil() {
 29274  		x.Namespace = ""
 29275  	} else {
 29276  		yyv19 := &x.Namespace
 29277  		yym20 := z.DecBinary()
 29278  		_ = yym20
 29279  		if false {
 29280  		} else {
 29281  			*((*string)(yyv19)) = r.DecodeString()
 29282  		}
 29283  	}
 29284  	yyj14++
 29285  	if yyhl14 {
 29286  		yyb14 = yyj14 > l
 29287  	} else {
 29288  		yyb14 = r.CheckBreak()
 29289  	}
 29290  	if yyb14 {
 29291  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29292  		return
 29293  	}
 29294  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 29295  	if r.TryDecodeAsNil() {
 29296  		x.AuthToken = ""
 29297  	} else {
 29298  		yyv21 := &x.AuthToken
 29299  		yym22 := z.DecBinary()
 29300  		_ = yym22
 29301  		if false {
 29302  		} else {
 29303  			*((*string)(yyv21)) = r.DecodeString()
 29304  		}
 29305  	}
 29306  	yyj14++
 29307  	if yyhl14 {
 29308  		yyb14 = yyj14 > l
 29309  	} else {
 29310  		yyb14 = r.CheckBreak()
 29311  	}
 29312  	if yyb14 {
 29313  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29314  		return
 29315  	}
 29316  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 29317  	if r.TryDecodeAsNil() {
 29318  		x.Forwarded = false
 29319  	} else {
 29320  		yyv23 := &x.Forwarded
 29321  		yym24 := z.DecBinary()
 29322  		_ = yym24
 29323  		if false {
 29324  		} else {
 29325  			*((*bool)(yyv23)) = r.DecodeBool()
 29326  		}
 29327  	}
 29328  	for {
 29329  		yyj14++
 29330  		if yyhl14 {
 29331  			yyb14 = yyj14 > l
 29332  		} else {
 29333  			yyb14 = r.CheckBreak()
 29334  		}
 29335  		if yyb14 {
 29336  			break
 29337  		}
 29338  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 29339  		z.DecStructFieldNotFound(yyj14-1, "")
 29340  	}
 29341  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29342  }
 29343  
 29344  func (x *SingleDeploymentResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 29345  	var h codecSelfer100
 29346  	z, r := codec1978.GenHelperEncoder(e)
 29347  	_, _, _ = h, z, r
 29348  	if x == nil {
 29349  		r.EncodeNil()
 29350  	} else {
 29351  		yym1 := z.EncBinary()
 29352  		_ = yym1
 29353  		if false {
 29354  		} else if z.HasExtensions() && z.EncExt(x) {
 29355  		} else {
 29356  			yysep2 := !z.EncBinary()
 29357  			yy2arr2 := z.EncBasicHandle().StructToArray
 29358  			var yyq2 [4]bool
 29359  			_, _, _ = yysep2, yyq2, yy2arr2
 29360  			const yyr2 bool = false
 29361  			var yynn2 int
 29362  			if yyr2 || yy2arr2 {
 29363  				r.EncodeArrayStart(4)
 29364  			} else {
 29365  				yynn2 = 4
 29366  				for _, b := range yyq2 {
 29367  					if b {
 29368  						yynn2++
 29369  					}
 29370  				}
 29371  				r.EncodeMapStart(yynn2)
 29372  				yynn2 = 0
 29373  			}
 29374  			if yyr2 || yy2arr2 {
 29375  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 29376  				if x.Deployment == nil {
 29377  					r.EncodeNil()
 29378  				} else {
 29379  					x.Deployment.CodecEncodeSelf(e)
 29380  				}
 29381  			} else {
 29382  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 29383  				r.EncodeString(codecSelferC_UTF8100, string("Deployment"))
 29384  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 29385  				if x.Deployment == nil {
 29386  					r.EncodeNil()
 29387  				} else {
 29388  					x.Deployment.CodecEncodeSelf(e)
 29389  				}
 29390  			}
 29391  			if yyr2 || yy2arr2 {
 29392  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 29393  				yym7 := z.EncBinary()
 29394  				_ = yym7
 29395  				if false {
 29396  				} else {
 29397  					r.EncodeUint(uint64(x.Index))
 29398  				}
 29399  			} else {
 29400  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 29401  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 29402  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 29403  				yym8 := z.EncBinary()
 29404  				_ = yym8
 29405  				if false {
 29406  				} else {
 29407  					r.EncodeUint(uint64(x.Index))
 29408  				}
 29409  			}
 29410  			if yyr2 || yy2arr2 {
 29411  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 29412  				yym10 := z.EncBinary()
 29413  				_ = yym10
 29414  				if false {
 29415  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 29416  				} else {
 29417  					r.EncodeInt(int64(x.LastContact))
 29418  				}
 29419  			} else {
 29420  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 29421  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 29422  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 29423  				yym11 := z.EncBinary()
 29424  				_ = yym11
 29425  				if false {
 29426  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 29427  				} else {
 29428  					r.EncodeInt(int64(x.LastContact))
 29429  				}
 29430  			}
 29431  			if yyr2 || yy2arr2 {
 29432  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 29433  				yym13 := z.EncBinary()
 29434  				_ = yym13
 29435  				if false {
 29436  				} else {
 29437  					r.EncodeBool(bool(x.KnownLeader))
 29438  				}
 29439  			} else {
 29440  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 29441  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 29442  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 29443  				yym14 := z.EncBinary()
 29444  				_ = yym14
 29445  				if false {
 29446  				} else {
 29447  					r.EncodeBool(bool(x.KnownLeader))
 29448  				}
 29449  			}
 29450  			if yyr2 || yy2arr2 {
 29451  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 29452  			} else {
 29453  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 29454  			}
 29455  		}
 29456  	}
 29457  }
 29458  
 29459  func (x *SingleDeploymentResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 29460  	var h codecSelfer100
 29461  	z, r := codec1978.GenHelperDecoder(d)
 29462  	_, _, _ = h, z, r
 29463  	yym1 := z.DecBinary()
 29464  	_ = yym1
 29465  	if false {
 29466  	} else if z.HasExtensions() && z.DecExt(x) {
 29467  	} else {
 29468  		yyct2 := r.ContainerType()
 29469  		if yyct2 == codecSelferValueTypeMap100 {
 29470  			yyl2 := r.ReadMapStart()
 29471  			if yyl2 == 0 {
 29472  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 29473  			} else {
 29474  				x.codecDecodeSelfFromMap(yyl2, d)
 29475  			}
 29476  		} else if yyct2 == codecSelferValueTypeArray100 {
 29477  			yyl2 := r.ReadArrayStart()
 29478  			if yyl2 == 0 {
 29479  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29480  			} else {
 29481  				x.codecDecodeSelfFromArray(yyl2, d)
 29482  			}
 29483  		} else {
 29484  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 29485  		}
 29486  	}
 29487  }
 29488  
 29489  func (x *SingleDeploymentResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 29490  	var h codecSelfer100
 29491  	z, r := codec1978.GenHelperDecoder(d)
 29492  	_, _, _ = h, z, r
 29493  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 29494  	_ = yys3Slc
 29495  	var yyhl3 bool = l >= 0
 29496  	for yyj3 := 0; ; yyj3++ {
 29497  		if yyhl3 {
 29498  			if yyj3 >= l {
 29499  				break
 29500  			}
 29501  		} else {
 29502  			if r.CheckBreak() {
 29503  				break
 29504  			}
 29505  		}
 29506  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 29507  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 29508  		yys3 := string(yys3Slc)
 29509  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 29510  		switch yys3 {
 29511  		case "Deployment":
 29512  			if r.TryDecodeAsNil() {
 29513  				if x.Deployment != nil {
 29514  					x.Deployment = nil
 29515  				}
 29516  			} else {
 29517  				if x.Deployment == nil {
 29518  					x.Deployment = new(Deployment)
 29519  				}
 29520  				x.Deployment.CodecDecodeSelf(d)
 29521  			}
 29522  		case "Index":
 29523  			if r.TryDecodeAsNil() {
 29524  				x.Index = 0
 29525  			} else {
 29526  				yyv5 := &x.Index
 29527  				yym6 := z.DecBinary()
 29528  				_ = yym6
 29529  				if false {
 29530  				} else {
 29531  					*((*uint64)(yyv5)) = uint64(r.DecodeUint(64))
 29532  				}
 29533  			}
 29534  		case "LastContact":
 29535  			if r.TryDecodeAsNil() {
 29536  				x.LastContact = 0
 29537  			} else {
 29538  				yyv7 := &x.LastContact
 29539  				yym8 := z.DecBinary()
 29540  				_ = yym8
 29541  				if false {
 29542  				} else if z.HasExtensions() && z.DecExt(yyv7) {
 29543  				} else {
 29544  					*((*int64)(yyv7)) = int64(r.DecodeInt(64))
 29545  				}
 29546  			}
 29547  		case "KnownLeader":
 29548  			if r.TryDecodeAsNil() {
 29549  				x.KnownLeader = false
 29550  			} else {
 29551  				yyv9 := &x.KnownLeader
 29552  				yym10 := z.DecBinary()
 29553  				_ = yym10
 29554  				if false {
 29555  				} else {
 29556  					*((*bool)(yyv9)) = r.DecodeBool()
 29557  				}
 29558  			}
 29559  		default:
 29560  			z.DecStructFieldNotFound(-1, yys3)
 29561  		} // end switch yys3
 29562  	} // end for yyj3
 29563  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 29564  }
 29565  
 29566  func (x *SingleDeploymentResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 29567  	var h codecSelfer100
 29568  	z, r := codec1978.GenHelperDecoder(d)
 29569  	_, _, _ = h, z, r
 29570  	var yyj11 int
 29571  	var yyb11 bool
 29572  	var yyhl11 bool = l >= 0
 29573  	yyj11++
 29574  	if yyhl11 {
 29575  		yyb11 = yyj11 > l
 29576  	} else {
 29577  		yyb11 = r.CheckBreak()
 29578  	}
 29579  	if yyb11 {
 29580  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29581  		return
 29582  	}
 29583  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 29584  	if r.TryDecodeAsNil() {
 29585  		if x.Deployment != nil {
 29586  			x.Deployment = nil
 29587  		}
 29588  	} else {
 29589  		if x.Deployment == nil {
 29590  			x.Deployment = new(Deployment)
 29591  		}
 29592  		x.Deployment.CodecDecodeSelf(d)
 29593  	}
 29594  	yyj11++
 29595  	if yyhl11 {
 29596  		yyb11 = yyj11 > l
 29597  	} else {
 29598  		yyb11 = r.CheckBreak()
 29599  	}
 29600  	if yyb11 {
 29601  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29602  		return
 29603  	}
 29604  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 29605  	if r.TryDecodeAsNil() {
 29606  		x.Index = 0
 29607  	} else {
 29608  		yyv13 := &x.Index
 29609  		yym14 := z.DecBinary()
 29610  		_ = yym14
 29611  		if false {
 29612  		} else {
 29613  			*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 29614  		}
 29615  	}
 29616  	yyj11++
 29617  	if yyhl11 {
 29618  		yyb11 = yyj11 > l
 29619  	} else {
 29620  		yyb11 = r.CheckBreak()
 29621  	}
 29622  	if yyb11 {
 29623  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29624  		return
 29625  	}
 29626  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 29627  	if r.TryDecodeAsNil() {
 29628  		x.LastContact = 0
 29629  	} else {
 29630  		yyv15 := &x.LastContact
 29631  		yym16 := z.DecBinary()
 29632  		_ = yym16
 29633  		if false {
 29634  		} else if z.HasExtensions() && z.DecExt(yyv15) {
 29635  		} else {
 29636  			*((*int64)(yyv15)) = int64(r.DecodeInt(64))
 29637  		}
 29638  	}
 29639  	yyj11++
 29640  	if yyhl11 {
 29641  		yyb11 = yyj11 > l
 29642  	} else {
 29643  		yyb11 = r.CheckBreak()
 29644  	}
 29645  	if yyb11 {
 29646  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29647  		return
 29648  	}
 29649  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 29650  	if r.TryDecodeAsNil() {
 29651  		x.KnownLeader = false
 29652  	} else {
 29653  		yyv17 := &x.KnownLeader
 29654  		yym18 := z.DecBinary()
 29655  		_ = yym18
 29656  		if false {
 29657  		} else {
 29658  			*((*bool)(yyv17)) = r.DecodeBool()
 29659  		}
 29660  	}
 29661  	for {
 29662  		yyj11++
 29663  		if yyhl11 {
 29664  			yyb11 = yyj11 > l
 29665  		} else {
 29666  			yyb11 = r.CheckBreak()
 29667  		}
 29668  		if yyb11 {
 29669  			break
 29670  		}
 29671  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 29672  		z.DecStructFieldNotFound(yyj11-1, "")
 29673  	}
 29674  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29675  }
 29676  
 29677  func (x *GenericResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 29678  	var h codecSelfer100
 29679  	z, r := codec1978.GenHelperEncoder(e)
 29680  	_, _, _ = h, z, r
 29681  	if x == nil {
 29682  		r.EncodeNil()
 29683  	} else {
 29684  		yym1 := z.EncBinary()
 29685  		_ = yym1
 29686  		if false {
 29687  		} else if z.HasExtensions() && z.EncExt(x) {
 29688  		} else {
 29689  			yysep2 := !z.EncBinary()
 29690  			yy2arr2 := z.EncBasicHandle().StructToArray
 29691  			var yyq2 [1]bool
 29692  			_, _, _ = yysep2, yyq2, yy2arr2
 29693  			const yyr2 bool = false
 29694  			var yynn2 int
 29695  			if yyr2 || yy2arr2 {
 29696  				r.EncodeArrayStart(1)
 29697  			} else {
 29698  				yynn2 = 1
 29699  				for _, b := range yyq2 {
 29700  					if b {
 29701  						yynn2++
 29702  					}
 29703  				}
 29704  				r.EncodeMapStart(yynn2)
 29705  				yynn2 = 0
 29706  			}
 29707  			if yyr2 || yy2arr2 {
 29708  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 29709  				yym4 := z.EncBinary()
 29710  				_ = yym4
 29711  				if false {
 29712  				} else {
 29713  					r.EncodeUint(uint64(x.Index))
 29714  				}
 29715  			} else {
 29716  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 29717  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 29718  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 29719  				yym5 := z.EncBinary()
 29720  				_ = yym5
 29721  				if false {
 29722  				} else {
 29723  					r.EncodeUint(uint64(x.Index))
 29724  				}
 29725  			}
 29726  			if yyr2 || yy2arr2 {
 29727  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 29728  			} else {
 29729  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 29730  			}
 29731  		}
 29732  	}
 29733  }
 29734  
 29735  func (x *GenericResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 29736  	var h codecSelfer100
 29737  	z, r := codec1978.GenHelperDecoder(d)
 29738  	_, _, _ = h, z, r
 29739  	yym1 := z.DecBinary()
 29740  	_ = yym1
 29741  	if false {
 29742  	} else if z.HasExtensions() && z.DecExt(x) {
 29743  	} else {
 29744  		yyct2 := r.ContainerType()
 29745  		if yyct2 == codecSelferValueTypeMap100 {
 29746  			yyl2 := r.ReadMapStart()
 29747  			if yyl2 == 0 {
 29748  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 29749  			} else {
 29750  				x.codecDecodeSelfFromMap(yyl2, d)
 29751  			}
 29752  		} else if yyct2 == codecSelferValueTypeArray100 {
 29753  			yyl2 := r.ReadArrayStart()
 29754  			if yyl2 == 0 {
 29755  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29756  			} else {
 29757  				x.codecDecodeSelfFromArray(yyl2, d)
 29758  			}
 29759  		} else {
 29760  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 29761  		}
 29762  	}
 29763  }
 29764  
 29765  func (x *GenericResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 29766  	var h codecSelfer100
 29767  	z, r := codec1978.GenHelperDecoder(d)
 29768  	_, _, _ = h, z, r
 29769  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 29770  	_ = yys3Slc
 29771  	var yyhl3 bool = l >= 0
 29772  	for yyj3 := 0; ; yyj3++ {
 29773  		if yyhl3 {
 29774  			if yyj3 >= l {
 29775  				break
 29776  			}
 29777  		} else {
 29778  			if r.CheckBreak() {
 29779  				break
 29780  			}
 29781  		}
 29782  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 29783  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 29784  		yys3 := string(yys3Slc)
 29785  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 29786  		switch yys3 {
 29787  		case "Index":
 29788  			if r.TryDecodeAsNil() {
 29789  				x.Index = 0
 29790  			} else {
 29791  				yyv4 := &x.Index
 29792  				yym5 := z.DecBinary()
 29793  				_ = yym5
 29794  				if false {
 29795  				} else {
 29796  					*((*uint64)(yyv4)) = uint64(r.DecodeUint(64))
 29797  				}
 29798  			}
 29799  		default:
 29800  			z.DecStructFieldNotFound(-1, yys3)
 29801  		} // end switch yys3
 29802  	} // end for yyj3
 29803  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 29804  }
 29805  
 29806  func (x *GenericResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 29807  	var h codecSelfer100
 29808  	z, r := codec1978.GenHelperDecoder(d)
 29809  	_, _, _ = h, z, r
 29810  	var yyj6 int
 29811  	var yyb6 bool
 29812  	var yyhl6 bool = l >= 0
 29813  	yyj6++
 29814  	if yyhl6 {
 29815  		yyb6 = yyj6 > l
 29816  	} else {
 29817  		yyb6 = r.CheckBreak()
 29818  	}
 29819  	if yyb6 {
 29820  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29821  		return
 29822  	}
 29823  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 29824  	if r.TryDecodeAsNil() {
 29825  		x.Index = 0
 29826  	} else {
 29827  		yyv7 := &x.Index
 29828  		yym8 := z.DecBinary()
 29829  		_ = yym8
 29830  		if false {
 29831  		} else {
 29832  			*((*uint64)(yyv7)) = uint64(r.DecodeUint(64))
 29833  		}
 29834  	}
 29835  	for {
 29836  		yyj6++
 29837  		if yyhl6 {
 29838  			yyb6 = yyj6 > l
 29839  		} else {
 29840  			yyb6 = r.CheckBreak()
 29841  		}
 29842  		if yyb6 {
 29843  			break
 29844  		}
 29845  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 29846  		z.DecStructFieldNotFound(yyj6-1, "")
 29847  	}
 29848  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 29849  }
 29850  
 29851  func (x *VersionResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 29852  	var h codecSelfer100
 29853  	z, r := codec1978.GenHelperEncoder(e)
 29854  	_, _, _ = h, z, r
 29855  	if x == nil {
 29856  		r.EncodeNil()
 29857  	} else {
 29858  		yym1 := z.EncBinary()
 29859  		_ = yym1
 29860  		if false {
 29861  		} else if z.HasExtensions() && z.EncExt(x) {
 29862  		} else {
 29863  			yysep2 := !z.EncBinary()
 29864  			yy2arr2 := z.EncBasicHandle().StructToArray
 29865  			var yyq2 [5]bool
 29866  			_, _, _ = yysep2, yyq2, yy2arr2
 29867  			const yyr2 bool = false
 29868  			var yynn2 int
 29869  			if yyr2 || yy2arr2 {
 29870  				r.EncodeArrayStart(5)
 29871  			} else {
 29872  				yynn2 = 5
 29873  				for _, b := range yyq2 {
 29874  					if b {
 29875  						yynn2++
 29876  					}
 29877  				}
 29878  				r.EncodeMapStart(yynn2)
 29879  				yynn2 = 0
 29880  			}
 29881  			if yyr2 || yy2arr2 {
 29882  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 29883  				yym4 := z.EncBinary()
 29884  				_ = yym4
 29885  				if false {
 29886  				} else {
 29887  					r.EncodeString(codecSelferC_UTF8100, string(x.Build))
 29888  				}
 29889  			} else {
 29890  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 29891  				r.EncodeString(codecSelferC_UTF8100, string("Build"))
 29892  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 29893  				yym5 := z.EncBinary()
 29894  				_ = yym5
 29895  				if false {
 29896  				} else {
 29897  					r.EncodeString(codecSelferC_UTF8100, string(x.Build))
 29898  				}
 29899  			}
 29900  			if yyr2 || yy2arr2 {
 29901  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 29902  				if x.Versions == nil {
 29903  					r.EncodeNil()
 29904  				} else {
 29905  					yym7 := z.EncBinary()
 29906  					_ = yym7
 29907  					if false {
 29908  					} else {
 29909  						z.F.EncMapStringIntV(x.Versions, false, e)
 29910  					}
 29911  				}
 29912  			} else {
 29913  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 29914  				r.EncodeString(codecSelferC_UTF8100, string("Versions"))
 29915  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 29916  				if x.Versions == nil {
 29917  					r.EncodeNil()
 29918  				} else {
 29919  					yym8 := z.EncBinary()
 29920  					_ = yym8
 29921  					if false {
 29922  					} else {
 29923  						z.F.EncMapStringIntV(x.Versions, false, e)
 29924  					}
 29925  				}
 29926  			}
 29927  			if yyr2 || yy2arr2 {
 29928  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 29929  				yym10 := z.EncBinary()
 29930  				_ = yym10
 29931  				if false {
 29932  				} else {
 29933  					r.EncodeUint(uint64(x.Index))
 29934  				}
 29935  			} else {
 29936  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 29937  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 29938  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 29939  				yym11 := z.EncBinary()
 29940  				_ = yym11
 29941  				if false {
 29942  				} else {
 29943  					r.EncodeUint(uint64(x.Index))
 29944  				}
 29945  			}
 29946  			if yyr2 || yy2arr2 {
 29947  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 29948  				yym13 := z.EncBinary()
 29949  				_ = yym13
 29950  				if false {
 29951  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 29952  				} else {
 29953  					r.EncodeInt(int64(x.LastContact))
 29954  				}
 29955  			} else {
 29956  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 29957  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 29958  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 29959  				yym14 := z.EncBinary()
 29960  				_ = yym14
 29961  				if false {
 29962  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 29963  				} else {
 29964  					r.EncodeInt(int64(x.LastContact))
 29965  				}
 29966  			}
 29967  			if yyr2 || yy2arr2 {
 29968  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 29969  				yym16 := z.EncBinary()
 29970  				_ = yym16
 29971  				if false {
 29972  				} else {
 29973  					r.EncodeBool(bool(x.KnownLeader))
 29974  				}
 29975  			} else {
 29976  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 29977  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 29978  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 29979  				yym17 := z.EncBinary()
 29980  				_ = yym17
 29981  				if false {
 29982  				} else {
 29983  					r.EncodeBool(bool(x.KnownLeader))
 29984  				}
 29985  			}
 29986  			if yyr2 || yy2arr2 {
 29987  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 29988  			} else {
 29989  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 29990  			}
 29991  		}
 29992  	}
 29993  }
 29994  
 29995  func (x *VersionResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 29996  	var h codecSelfer100
 29997  	z, r := codec1978.GenHelperDecoder(d)
 29998  	_, _, _ = h, z, r
 29999  	yym1 := z.DecBinary()
 30000  	_ = yym1
 30001  	if false {
 30002  	} else if z.HasExtensions() && z.DecExt(x) {
 30003  	} else {
 30004  		yyct2 := r.ContainerType()
 30005  		if yyct2 == codecSelferValueTypeMap100 {
 30006  			yyl2 := r.ReadMapStart()
 30007  			if yyl2 == 0 {
 30008  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 30009  			} else {
 30010  				x.codecDecodeSelfFromMap(yyl2, d)
 30011  			}
 30012  		} else if yyct2 == codecSelferValueTypeArray100 {
 30013  			yyl2 := r.ReadArrayStart()
 30014  			if yyl2 == 0 {
 30015  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30016  			} else {
 30017  				x.codecDecodeSelfFromArray(yyl2, d)
 30018  			}
 30019  		} else {
 30020  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 30021  		}
 30022  	}
 30023  }
 30024  
 30025  func (x *VersionResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 30026  	var h codecSelfer100
 30027  	z, r := codec1978.GenHelperDecoder(d)
 30028  	_, _, _ = h, z, r
 30029  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 30030  	_ = yys3Slc
 30031  	var yyhl3 bool = l >= 0
 30032  	for yyj3 := 0; ; yyj3++ {
 30033  		if yyhl3 {
 30034  			if yyj3 >= l {
 30035  				break
 30036  			}
 30037  		} else {
 30038  			if r.CheckBreak() {
 30039  				break
 30040  			}
 30041  		}
 30042  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 30043  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 30044  		yys3 := string(yys3Slc)
 30045  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 30046  		switch yys3 {
 30047  		case "Build":
 30048  			if r.TryDecodeAsNil() {
 30049  				x.Build = ""
 30050  			} else {
 30051  				yyv4 := &x.Build
 30052  				yym5 := z.DecBinary()
 30053  				_ = yym5
 30054  				if false {
 30055  				} else {
 30056  					*((*string)(yyv4)) = r.DecodeString()
 30057  				}
 30058  			}
 30059  		case "Versions":
 30060  			if r.TryDecodeAsNil() {
 30061  				x.Versions = nil
 30062  			} else {
 30063  				yyv6 := &x.Versions
 30064  				yym7 := z.DecBinary()
 30065  				_ = yym7
 30066  				if false {
 30067  				} else {
 30068  					z.F.DecMapStringIntX(yyv6, false, d)
 30069  				}
 30070  			}
 30071  		case "Index":
 30072  			if r.TryDecodeAsNil() {
 30073  				x.Index = 0
 30074  			} else {
 30075  				yyv8 := &x.Index
 30076  				yym9 := z.DecBinary()
 30077  				_ = yym9
 30078  				if false {
 30079  				} else {
 30080  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 30081  				}
 30082  			}
 30083  		case "LastContact":
 30084  			if r.TryDecodeAsNil() {
 30085  				x.LastContact = 0
 30086  			} else {
 30087  				yyv10 := &x.LastContact
 30088  				yym11 := z.DecBinary()
 30089  				_ = yym11
 30090  				if false {
 30091  				} else if z.HasExtensions() && z.DecExt(yyv10) {
 30092  				} else {
 30093  					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
 30094  				}
 30095  			}
 30096  		case "KnownLeader":
 30097  			if r.TryDecodeAsNil() {
 30098  				x.KnownLeader = false
 30099  			} else {
 30100  				yyv12 := &x.KnownLeader
 30101  				yym13 := z.DecBinary()
 30102  				_ = yym13
 30103  				if false {
 30104  				} else {
 30105  					*((*bool)(yyv12)) = r.DecodeBool()
 30106  				}
 30107  			}
 30108  		default:
 30109  			z.DecStructFieldNotFound(-1, yys3)
 30110  		} // end switch yys3
 30111  	} // end for yyj3
 30112  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 30113  }
 30114  
 30115  func (x *VersionResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 30116  	var h codecSelfer100
 30117  	z, r := codec1978.GenHelperDecoder(d)
 30118  	_, _, _ = h, z, r
 30119  	var yyj14 int
 30120  	var yyb14 bool
 30121  	var yyhl14 bool = l >= 0
 30122  	yyj14++
 30123  	if yyhl14 {
 30124  		yyb14 = yyj14 > l
 30125  	} else {
 30126  		yyb14 = r.CheckBreak()
 30127  	}
 30128  	if yyb14 {
 30129  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30130  		return
 30131  	}
 30132  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 30133  	if r.TryDecodeAsNil() {
 30134  		x.Build = ""
 30135  	} else {
 30136  		yyv15 := &x.Build
 30137  		yym16 := z.DecBinary()
 30138  		_ = yym16
 30139  		if false {
 30140  		} else {
 30141  			*((*string)(yyv15)) = r.DecodeString()
 30142  		}
 30143  	}
 30144  	yyj14++
 30145  	if yyhl14 {
 30146  		yyb14 = yyj14 > l
 30147  	} else {
 30148  		yyb14 = r.CheckBreak()
 30149  	}
 30150  	if yyb14 {
 30151  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30152  		return
 30153  	}
 30154  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 30155  	if r.TryDecodeAsNil() {
 30156  		x.Versions = nil
 30157  	} else {
 30158  		yyv17 := &x.Versions
 30159  		yym18 := z.DecBinary()
 30160  		_ = yym18
 30161  		if false {
 30162  		} else {
 30163  			z.F.DecMapStringIntX(yyv17, false, d)
 30164  		}
 30165  	}
 30166  	yyj14++
 30167  	if yyhl14 {
 30168  		yyb14 = yyj14 > l
 30169  	} else {
 30170  		yyb14 = r.CheckBreak()
 30171  	}
 30172  	if yyb14 {
 30173  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30174  		return
 30175  	}
 30176  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 30177  	if r.TryDecodeAsNil() {
 30178  		x.Index = 0
 30179  	} else {
 30180  		yyv19 := &x.Index
 30181  		yym20 := z.DecBinary()
 30182  		_ = yym20
 30183  		if false {
 30184  		} else {
 30185  			*((*uint64)(yyv19)) = uint64(r.DecodeUint(64))
 30186  		}
 30187  	}
 30188  	yyj14++
 30189  	if yyhl14 {
 30190  		yyb14 = yyj14 > l
 30191  	} else {
 30192  		yyb14 = r.CheckBreak()
 30193  	}
 30194  	if yyb14 {
 30195  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30196  		return
 30197  	}
 30198  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 30199  	if r.TryDecodeAsNil() {
 30200  		x.LastContact = 0
 30201  	} else {
 30202  		yyv21 := &x.LastContact
 30203  		yym22 := z.DecBinary()
 30204  		_ = yym22
 30205  		if false {
 30206  		} else if z.HasExtensions() && z.DecExt(yyv21) {
 30207  		} else {
 30208  			*((*int64)(yyv21)) = int64(r.DecodeInt(64))
 30209  		}
 30210  	}
 30211  	yyj14++
 30212  	if yyhl14 {
 30213  		yyb14 = yyj14 > l
 30214  	} else {
 30215  		yyb14 = r.CheckBreak()
 30216  	}
 30217  	if yyb14 {
 30218  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30219  		return
 30220  	}
 30221  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 30222  	if r.TryDecodeAsNil() {
 30223  		x.KnownLeader = false
 30224  	} else {
 30225  		yyv23 := &x.KnownLeader
 30226  		yym24 := z.DecBinary()
 30227  		_ = yym24
 30228  		if false {
 30229  		} else {
 30230  			*((*bool)(yyv23)) = r.DecodeBool()
 30231  		}
 30232  	}
 30233  	for {
 30234  		yyj14++
 30235  		if yyhl14 {
 30236  			yyb14 = yyj14 > l
 30237  		} else {
 30238  			yyb14 = r.CheckBreak()
 30239  		}
 30240  		if yyb14 {
 30241  			break
 30242  		}
 30243  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 30244  		z.DecStructFieldNotFound(yyj14-1, "")
 30245  	}
 30246  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30247  }
 30248  
 30249  func (x *JobRegisterResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 30250  	var h codecSelfer100
 30251  	z, r := codec1978.GenHelperEncoder(e)
 30252  	_, _, _ = h, z, r
 30253  	if x == nil {
 30254  		r.EncodeNil()
 30255  	} else {
 30256  		yym1 := z.EncBinary()
 30257  		_ = yym1
 30258  		if false {
 30259  		} else if z.HasExtensions() && z.EncExt(x) {
 30260  		} else {
 30261  			yysep2 := !z.EncBinary()
 30262  			yy2arr2 := z.EncBasicHandle().StructToArray
 30263  			var yyq2 [7]bool
 30264  			_, _, _ = yysep2, yyq2, yy2arr2
 30265  			const yyr2 bool = false
 30266  			var yynn2 int
 30267  			if yyr2 || yy2arr2 {
 30268  				r.EncodeArrayStart(7)
 30269  			} else {
 30270  				yynn2 = 7
 30271  				for _, b := range yyq2 {
 30272  					if b {
 30273  						yynn2++
 30274  					}
 30275  				}
 30276  				r.EncodeMapStart(yynn2)
 30277  				yynn2 = 0
 30278  			}
 30279  			if yyr2 || yy2arr2 {
 30280  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 30281  				yym4 := z.EncBinary()
 30282  				_ = yym4
 30283  				if false {
 30284  				} else {
 30285  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 30286  				}
 30287  			} else {
 30288  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 30289  				r.EncodeString(codecSelferC_UTF8100, string("EvalID"))
 30290  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 30291  				yym5 := z.EncBinary()
 30292  				_ = yym5
 30293  				if false {
 30294  				} else {
 30295  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 30296  				}
 30297  			}
 30298  			if yyr2 || yy2arr2 {
 30299  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 30300  				yym7 := z.EncBinary()
 30301  				_ = yym7
 30302  				if false {
 30303  				} else {
 30304  					r.EncodeUint(uint64(x.EvalCreateIndex))
 30305  				}
 30306  			} else {
 30307  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 30308  				r.EncodeString(codecSelferC_UTF8100, string("EvalCreateIndex"))
 30309  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 30310  				yym8 := z.EncBinary()
 30311  				_ = yym8
 30312  				if false {
 30313  				} else {
 30314  					r.EncodeUint(uint64(x.EvalCreateIndex))
 30315  				}
 30316  			}
 30317  			if yyr2 || yy2arr2 {
 30318  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 30319  				yym10 := z.EncBinary()
 30320  				_ = yym10
 30321  				if false {
 30322  				} else {
 30323  					r.EncodeUint(uint64(x.JobModifyIndex))
 30324  				}
 30325  			} else {
 30326  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 30327  				r.EncodeString(codecSelferC_UTF8100, string("JobModifyIndex"))
 30328  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 30329  				yym11 := z.EncBinary()
 30330  				_ = yym11
 30331  				if false {
 30332  				} else {
 30333  					r.EncodeUint(uint64(x.JobModifyIndex))
 30334  				}
 30335  			}
 30336  			if yyr2 || yy2arr2 {
 30337  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 30338  				yym13 := z.EncBinary()
 30339  				_ = yym13
 30340  				if false {
 30341  				} else {
 30342  					r.EncodeString(codecSelferC_UTF8100, string(x.Warnings))
 30343  				}
 30344  			} else {
 30345  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 30346  				r.EncodeString(codecSelferC_UTF8100, string("Warnings"))
 30347  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 30348  				yym14 := z.EncBinary()
 30349  				_ = yym14
 30350  				if false {
 30351  				} else {
 30352  					r.EncodeString(codecSelferC_UTF8100, string(x.Warnings))
 30353  				}
 30354  			}
 30355  			if yyr2 || yy2arr2 {
 30356  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 30357  				yym16 := z.EncBinary()
 30358  				_ = yym16
 30359  				if false {
 30360  				} else {
 30361  					r.EncodeUint(uint64(x.Index))
 30362  				}
 30363  			} else {
 30364  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 30365  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 30366  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 30367  				yym17 := z.EncBinary()
 30368  				_ = yym17
 30369  				if false {
 30370  				} else {
 30371  					r.EncodeUint(uint64(x.Index))
 30372  				}
 30373  			}
 30374  			if yyr2 || yy2arr2 {
 30375  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 30376  				yym19 := z.EncBinary()
 30377  				_ = yym19
 30378  				if false {
 30379  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 30380  				} else {
 30381  					r.EncodeInt(int64(x.LastContact))
 30382  				}
 30383  			} else {
 30384  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 30385  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 30386  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 30387  				yym20 := z.EncBinary()
 30388  				_ = yym20
 30389  				if false {
 30390  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 30391  				} else {
 30392  					r.EncodeInt(int64(x.LastContact))
 30393  				}
 30394  			}
 30395  			if yyr2 || yy2arr2 {
 30396  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 30397  				yym22 := z.EncBinary()
 30398  				_ = yym22
 30399  				if false {
 30400  				} else {
 30401  					r.EncodeBool(bool(x.KnownLeader))
 30402  				}
 30403  			} else {
 30404  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 30405  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 30406  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 30407  				yym23 := z.EncBinary()
 30408  				_ = yym23
 30409  				if false {
 30410  				} else {
 30411  					r.EncodeBool(bool(x.KnownLeader))
 30412  				}
 30413  			}
 30414  			if yyr2 || yy2arr2 {
 30415  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 30416  			} else {
 30417  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 30418  			}
 30419  		}
 30420  	}
 30421  }
 30422  
 30423  func (x *JobRegisterResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 30424  	var h codecSelfer100
 30425  	z, r := codec1978.GenHelperDecoder(d)
 30426  	_, _, _ = h, z, r
 30427  	yym1 := z.DecBinary()
 30428  	_ = yym1
 30429  	if false {
 30430  	} else if z.HasExtensions() && z.DecExt(x) {
 30431  	} else {
 30432  		yyct2 := r.ContainerType()
 30433  		if yyct2 == codecSelferValueTypeMap100 {
 30434  			yyl2 := r.ReadMapStart()
 30435  			if yyl2 == 0 {
 30436  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 30437  			} else {
 30438  				x.codecDecodeSelfFromMap(yyl2, d)
 30439  			}
 30440  		} else if yyct2 == codecSelferValueTypeArray100 {
 30441  			yyl2 := r.ReadArrayStart()
 30442  			if yyl2 == 0 {
 30443  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30444  			} else {
 30445  				x.codecDecodeSelfFromArray(yyl2, d)
 30446  			}
 30447  		} else {
 30448  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 30449  		}
 30450  	}
 30451  }
 30452  
 30453  func (x *JobRegisterResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 30454  	var h codecSelfer100
 30455  	z, r := codec1978.GenHelperDecoder(d)
 30456  	_, _, _ = h, z, r
 30457  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 30458  	_ = yys3Slc
 30459  	var yyhl3 bool = l >= 0
 30460  	for yyj3 := 0; ; yyj3++ {
 30461  		if yyhl3 {
 30462  			if yyj3 >= l {
 30463  				break
 30464  			}
 30465  		} else {
 30466  			if r.CheckBreak() {
 30467  				break
 30468  			}
 30469  		}
 30470  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 30471  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 30472  		yys3 := string(yys3Slc)
 30473  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 30474  		switch yys3 {
 30475  		case "EvalID":
 30476  			if r.TryDecodeAsNil() {
 30477  				x.EvalID = ""
 30478  			} else {
 30479  				yyv4 := &x.EvalID
 30480  				yym5 := z.DecBinary()
 30481  				_ = yym5
 30482  				if false {
 30483  				} else {
 30484  					*((*string)(yyv4)) = r.DecodeString()
 30485  				}
 30486  			}
 30487  		case "EvalCreateIndex":
 30488  			if r.TryDecodeAsNil() {
 30489  				x.EvalCreateIndex = 0
 30490  			} else {
 30491  				yyv6 := &x.EvalCreateIndex
 30492  				yym7 := z.DecBinary()
 30493  				_ = yym7
 30494  				if false {
 30495  				} else {
 30496  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 30497  				}
 30498  			}
 30499  		case "JobModifyIndex":
 30500  			if r.TryDecodeAsNil() {
 30501  				x.JobModifyIndex = 0
 30502  			} else {
 30503  				yyv8 := &x.JobModifyIndex
 30504  				yym9 := z.DecBinary()
 30505  				_ = yym9
 30506  				if false {
 30507  				} else {
 30508  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 30509  				}
 30510  			}
 30511  		case "Warnings":
 30512  			if r.TryDecodeAsNil() {
 30513  				x.Warnings = ""
 30514  			} else {
 30515  				yyv10 := &x.Warnings
 30516  				yym11 := z.DecBinary()
 30517  				_ = yym11
 30518  				if false {
 30519  				} else {
 30520  					*((*string)(yyv10)) = r.DecodeString()
 30521  				}
 30522  			}
 30523  		case "Index":
 30524  			if r.TryDecodeAsNil() {
 30525  				x.Index = 0
 30526  			} else {
 30527  				yyv12 := &x.Index
 30528  				yym13 := z.DecBinary()
 30529  				_ = yym13
 30530  				if false {
 30531  				} else {
 30532  					*((*uint64)(yyv12)) = uint64(r.DecodeUint(64))
 30533  				}
 30534  			}
 30535  		case "LastContact":
 30536  			if r.TryDecodeAsNil() {
 30537  				x.LastContact = 0
 30538  			} else {
 30539  				yyv14 := &x.LastContact
 30540  				yym15 := z.DecBinary()
 30541  				_ = yym15
 30542  				if false {
 30543  				} else if z.HasExtensions() && z.DecExt(yyv14) {
 30544  				} else {
 30545  					*((*int64)(yyv14)) = int64(r.DecodeInt(64))
 30546  				}
 30547  			}
 30548  		case "KnownLeader":
 30549  			if r.TryDecodeAsNil() {
 30550  				x.KnownLeader = false
 30551  			} else {
 30552  				yyv16 := &x.KnownLeader
 30553  				yym17 := z.DecBinary()
 30554  				_ = yym17
 30555  				if false {
 30556  				} else {
 30557  					*((*bool)(yyv16)) = r.DecodeBool()
 30558  				}
 30559  			}
 30560  		default:
 30561  			z.DecStructFieldNotFound(-1, yys3)
 30562  		} // end switch yys3
 30563  	} // end for yyj3
 30564  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 30565  }
 30566  
 30567  func (x *JobRegisterResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 30568  	var h codecSelfer100
 30569  	z, r := codec1978.GenHelperDecoder(d)
 30570  	_, _, _ = h, z, r
 30571  	var yyj18 int
 30572  	var yyb18 bool
 30573  	var yyhl18 bool = l >= 0
 30574  	yyj18++
 30575  	if yyhl18 {
 30576  		yyb18 = yyj18 > l
 30577  	} else {
 30578  		yyb18 = r.CheckBreak()
 30579  	}
 30580  	if yyb18 {
 30581  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30582  		return
 30583  	}
 30584  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 30585  	if r.TryDecodeAsNil() {
 30586  		x.EvalID = ""
 30587  	} else {
 30588  		yyv19 := &x.EvalID
 30589  		yym20 := z.DecBinary()
 30590  		_ = yym20
 30591  		if false {
 30592  		} else {
 30593  			*((*string)(yyv19)) = r.DecodeString()
 30594  		}
 30595  	}
 30596  	yyj18++
 30597  	if yyhl18 {
 30598  		yyb18 = yyj18 > l
 30599  	} else {
 30600  		yyb18 = r.CheckBreak()
 30601  	}
 30602  	if yyb18 {
 30603  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30604  		return
 30605  	}
 30606  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 30607  	if r.TryDecodeAsNil() {
 30608  		x.EvalCreateIndex = 0
 30609  	} else {
 30610  		yyv21 := &x.EvalCreateIndex
 30611  		yym22 := z.DecBinary()
 30612  		_ = yym22
 30613  		if false {
 30614  		} else {
 30615  			*((*uint64)(yyv21)) = uint64(r.DecodeUint(64))
 30616  		}
 30617  	}
 30618  	yyj18++
 30619  	if yyhl18 {
 30620  		yyb18 = yyj18 > l
 30621  	} else {
 30622  		yyb18 = r.CheckBreak()
 30623  	}
 30624  	if yyb18 {
 30625  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30626  		return
 30627  	}
 30628  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 30629  	if r.TryDecodeAsNil() {
 30630  		x.JobModifyIndex = 0
 30631  	} else {
 30632  		yyv23 := &x.JobModifyIndex
 30633  		yym24 := z.DecBinary()
 30634  		_ = yym24
 30635  		if false {
 30636  		} else {
 30637  			*((*uint64)(yyv23)) = uint64(r.DecodeUint(64))
 30638  		}
 30639  	}
 30640  	yyj18++
 30641  	if yyhl18 {
 30642  		yyb18 = yyj18 > l
 30643  	} else {
 30644  		yyb18 = r.CheckBreak()
 30645  	}
 30646  	if yyb18 {
 30647  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30648  		return
 30649  	}
 30650  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 30651  	if r.TryDecodeAsNil() {
 30652  		x.Warnings = ""
 30653  	} else {
 30654  		yyv25 := &x.Warnings
 30655  		yym26 := z.DecBinary()
 30656  		_ = yym26
 30657  		if false {
 30658  		} else {
 30659  			*((*string)(yyv25)) = r.DecodeString()
 30660  		}
 30661  	}
 30662  	yyj18++
 30663  	if yyhl18 {
 30664  		yyb18 = yyj18 > l
 30665  	} else {
 30666  		yyb18 = r.CheckBreak()
 30667  	}
 30668  	if yyb18 {
 30669  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30670  		return
 30671  	}
 30672  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 30673  	if r.TryDecodeAsNil() {
 30674  		x.Index = 0
 30675  	} else {
 30676  		yyv27 := &x.Index
 30677  		yym28 := z.DecBinary()
 30678  		_ = yym28
 30679  		if false {
 30680  		} else {
 30681  			*((*uint64)(yyv27)) = uint64(r.DecodeUint(64))
 30682  		}
 30683  	}
 30684  	yyj18++
 30685  	if yyhl18 {
 30686  		yyb18 = yyj18 > l
 30687  	} else {
 30688  		yyb18 = r.CheckBreak()
 30689  	}
 30690  	if yyb18 {
 30691  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30692  		return
 30693  	}
 30694  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 30695  	if r.TryDecodeAsNil() {
 30696  		x.LastContact = 0
 30697  	} else {
 30698  		yyv29 := &x.LastContact
 30699  		yym30 := z.DecBinary()
 30700  		_ = yym30
 30701  		if false {
 30702  		} else if z.HasExtensions() && z.DecExt(yyv29) {
 30703  		} else {
 30704  			*((*int64)(yyv29)) = int64(r.DecodeInt(64))
 30705  		}
 30706  	}
 30707  	yyj18++
 30708  	if yyhl18 {
 30709  		yyb18 = yyj18 > l
 30710  	} else {
 30711  		yyb18 = r.CheckBreak()
 30712  	}
 30713  	if yyb18 {
 30714  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30715  		return
 30716  	}
 30717  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 30718  	if r.TryDecodeAsNil() {
 30719  		x.KnownLeader = false
 30720  	} else {
 30721  		yyv31 := &x.KnownLeader
 30722  		yym32 := z.DecBinary()
 30723  		_ = yym32
 30724  		if false {
 30725  		} else {
 30726  			*((*bool)(yyv31)) = r.DecodeBool()
 30727  		}
 30728  	}
 30729  	for {
 30730  		yyj18++
 30731  		if yyhl18 {
 30732  			yyb18 = yyj18 > l
 30733  		} else {
 30734  			yyb18 = r.CheckBreak()
 30735  		}
 30736  		if yyb18 {
 30737  			break
 30738  		}
 30739  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 30740  		z.DecStructFieldNotFound(yyj18-1, "")
 30741  	}
 30742  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30743  }
 30744  
 30745  func (x *JobDeregisterResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 30746  	var h codecSelfer100
 30747  	z, r := codec1978.GenHelperEncoder(e)
 30748  	_, _, _ = h, z, r
 30749  	if x == nil {
 30750  		r.EncodeNil()
 30751  	} else {
 30752  		yym1 := z.EncBinary()
 30753  		_ = yym1
 30754  		if false {
 30755  		} else if z.HasExtensions() && z.EncExt(x) {
 30756  		} else {
 30757  			yysep2 := !z.EncBinary()
 30758  			yy2arr2 := z.EncBasicHandle().StructToArray
 30759  			var yyq2 [6]bool
 30760  			_, _, _ = yysep2, yyq2, yy2arr2
 30761  			const yyr2 bool = false
 30762  			var yynn2 int
 30763  			if yyr2 || yy2arr2 {
 30764  				r.EncodeArrayStart(6)
 30765  			} else {
 30766  				yynn2 = 6
 30767  				for _, b := range yyq2 {
 30768  					if b {
 30769  						yynn2++
 30770  					}
 30771  				}
 30772  				r.EncodeMapStart(yynn2)
 30773  				yynn2 = 0
 30774  			}
 30775  			if yyr2 || yy2arr2 {
 30776  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 30777  				yym4 := z.EncBinary()
 30778  				_ = yym4
 30779  				if false {
 30780  				} else {
 30781  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 30782  				}
 30783  			} else {
 30784  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 30785  				r.EncodeString(codecSelferC_UTF8100, string("EvalID"))
 30786  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 30787  				yym5 := z.EncBinary()
 30788  				_ = yym5
 30789  				if false {
 30790  				} else {
 30791  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 30792  				}
 30793  			}
 30794  			if yyr2 || yy2arr2 {
 30795  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 30796  				yym7 := z.EncBinary()
 30797  				_ = yym7
 30798  				if false {
 30799  				} else {
 30800  					r.EncodeUint(uint64(x.EvalCreateIndex))
 30801  				}
 30802  			} else {
 30803  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 30804  				r.EncodeString(codecSelferC_UTF8100, string("EvalCreateIndex"))
 30805  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 30806  				yym8 := z.EncBinary()
 30807  				_ = yym8
 30808  				if false {
 30809  				} else {
 30810  					r.EncodeUint(uint64(x.EvalCreateIndex))
 30811  				}
 30812  			}
 30813  			if yyr2 || yy2arr2 {
 30814  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 30815  				yym10 := z.EncBinary()
 30816  				_ = yym10
 30817  				if false {
 30818  				} else {
 30819  					r.EncodeUint(uint64(x.JobModifyIndex))
 30820  				}
 30821  			} else {
 30822  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 30823  				r.EncodeString(codecSelferC_UTF8100, string("JobModifyIndex"))
 30824  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 30825  				yym11 := z.EncBinary()
 30826  				_ = yym11
 30827  				if false {
 30828  				} else {
 30829  					r.EncodeUint(uint64(x.JobModifyIndex))
 30830  				}
 30831  			}
 30832  			if yyr2 || yy2arr2 {
 30833  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 30834  				yym13 := z.EncBinary()
 30835  				_ = yym13
 30836  				if false {
 30837  				} else {
 30838  					r.EncodeUint(uint64(x.Index))
 30839  				}
 30840  			} else {
 30841  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 30842  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 30843  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 30844  				yym14 := z.EncBinary()
 30845  				_ = yym14
 30846  				if false {
 30847  				} else {
 30848  					r.EncodeUint(uint64(x.Index))
 30849  				}
 30850  			}
 30851  			if yyr2 || yy2arr2 {
 30852  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 30853  				yym16 := z.EncBinary()
 30854  				_ = yym16
 30855  				if false {
 30856  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 30857  				} else {
 30858  					r.EncodeInt(int64(x.LastContact))
 30859  				}
 30860  			} else {
 30861  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 30862  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 30863  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 30864  				yym17 := z.EncBinary()
 30865  				_ = yym17
 30866  				if false {
 30867  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 30868  				} else {
 30869  					r.EncodeInt(int64(x.LastContact))
 30870  				}
 30871  			}
 30872  			if yyr2 || yy2arr2 {
 30873  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 30874  				yym19 := z.EncBinary()
 30875  				_ = yym19
 30876  				if false {
 30877  				} else {
 30878  					r.EncodeBool(bool(x.KnownLeader))
 30879  				}
 30880  			} else {
 30881  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 30882  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 30883  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 30884  				yym20 := z.EncBinary()
 30885  				_ = yym20
 30886  				if false {
 30887  				} else {
 30888  					r.EncodeBool(bool(x.KnownLeader))
 30889  				}
 30890  			}
 30891  			if yyr2 || yy2arr2 {
 30892  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 30893  			} else {
 30894  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 30895  			}
 30896  		}
 30897  	}
 30898  }
 30899  
 30900  func (x *JobDeregisterResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 30901  	var h codecSelfer100
 30902  	z, r := codec1978.GenHelperDecoder(d)
 30903  	_, _, _ = h, z, r
 30904  	yym1 := z.DecBinary()
 30905  	_ = yym1
 30906  	if false {
 30907  	} else if z.HasExtensions() && z.DecExt(x) {
 30908  	} else {
 30909  		yyct2 := r.ContainerType()
 30910  		if yyct2 == codecSelferValueTypeMap100 {
 30911  			yyl2 := r.ReadMapStart()
 30912  			if yyl2 == 0 {
 30913  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 30914  			} else {
 30915  				x.codecDecodeSelfFromMap(yyl2, d)
 30916  			}
 30917  		} else if yyct2 == codecSelferValueTypeArray100 {
 30918  			yyl2 := r.ReadArrayStart()
 30919  			if yyl2 == 0 {
 30920  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 30921  			} else {
 30922  				x.codecDecodeSelfFromArray(yyl2, d)
 30923  			}
 30924  		} else {
 30925  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 30926  		}
 30927  	}
 30928  }
 30929  
 30930  func (x *JobDeregisterResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 30931  	var h codecSelfer100
 30932  	z, r := codec1978.GenHelperDecoder(d)
 30933  	_, _, _ = h, z, r
 30934  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 30935  	_ = yys3Slc
 30936  	var yyhl3 bool = l >= 0
 30937  	for yyj3 := 0; ; yyj3++ {
 30938  		if yyhl3 {
 30939  			if yyj3 >= l {
 30940  				break
 30941  			}
 30942  		} else {
 30943  			if r.CheckBreak() {
 30944  				break
 30945  			}
 30946  		}
 30947  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 30948  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 30949  		yys3 := string(yys3Slc)
 30950  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 30951  		switch yys3 {
 30952  		case "EvalID":
 30953  			if r.TryDecodeAsNil() {
 30954  				x.EvalID = ""
 30955  			} else {
 30956  				yyv4 := &x.EvalID
 30957  				yym5 := z.DecBinary()
 30958  				_ = yym5
 30959  				if false {
 30960  				} else {
 30961  					*((*string)(yyv4)) = r.DecodeString()
 30962  				}
 30963  			}
 30964  		case "EvalCreateIndex":
 30965  			if r.TryDecodeAsNil() {
 30966  				x.EvalCreateIndex = 0
 30967  			} else {
 30968  				yyv6 := &x.EvalCreateIndex
 30969  				yym7 := z.DecBinary()
 30970  				_ = yym7
 30971  				if false {
 30972  				} else {
 30973  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 30974  				}
 30975  			}
 30976  		case "JobModifyIndex":
 30977  			if r.TryDecodeAsNil() {
 30978  				x.JobModifyIndex = 0
 30979  			} else {
 30980  				yyv8 := &x.JobModifyIndex
 30981  				yym9 := z.DecBinary()
 30982  				_ = yym9
 30983  				if false {
 30984  				} else {
 30985  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 30986  				}
 30987  			}
 30988  		case "Index":
 30989  			if r.TryDecodeAsNil() {
 30990  				x.Index = 0
 30991  			} else {
 30992  				yyv10 := &x.Index
 30993  				yym11 := z.DecBinary()
 30994  				_ = yym11
 30995  				if false {
 30996  				} else {
 30997  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 30998  				}
 30999  			}
 31000  		case "LastContact":
 31001  			if r.TryDecodeAsNil() {
 31002  				x.LastContact = 0
 31003  			} else {
 31004  				yyv12 := &x.LastContact
 31005  				yym13 := z.DecBinary()
 31006  				_ = yym13
 31007  				if false {
 31008  				} else if z.HasExtensions() && z.DecExt(yyv12) {
 31009  				} else {
 31010  					*((*int64)(yyv12)) = int64(r.DecodeInt(64))
 31011  				}
 31012  			}
 31013  		case "KnownLeader":
 31014  			if r.TryDecodeAsNil() {
 31015  				x.KnownLeader = false
 31016  			} else {
 31017  				yyv14 := &x.KnownLeader
 31018  				yym15 := z.DecBinary()
 31019  				_ = yym15
 31020  				if false {
 31021  				} else {
 31022  					*((*bool)(yyv14)) = r.DecodeBool()
 31023  				}
 31024  			}
 31025  		default:
 31026  			z.DecStructFieldNotFound(-1, yys3)
 31027  		} // end switch yys3
 31028  	} // end for yyj3
 31029  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 31030  }
 31031  
 31032  func (x *JobDeregisterResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 31033  	var h codecSelfer100
 31034  	z, r := codec1978.GenHelperDecoder(d)
 31035  	_, _, _ = h, z, r
 31036  	var yyj16 int
 31037  	var yyb16 bool
 31038  	var yyhl16 bool = l >= 0
 31039  	yyj16++
 31040  	if yyhl16 {
 31041  		yyb16 = yyj16 > l
 31042  	} else {
 31043  		yyb16 = r.CheckBreak()
 31044  	}
 31045  	if yyb16 {
 31046  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31047  		return
 31048  	}
 31049  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31050  	if r.TryDecodeAsNil() {
 31051  		x.EvalID = ""
 31052  	} else {
 31053  		yyv17 := &x.EvalID
 31054  		yym18 := z.DecBinary()
 31055  		_ = yym18
 31056  		if false {
 31057  		} else {
 31058  			*((*string)(yyv17)) = r.DecodeString()
 31059  		}
 31060  	}
 31061  	yyj16++
 31062  	if yyhl16 {
 31063  		yyb16 = yyj16 > l
 31064  	} else {
 31065  		yyb16 = r.CheckBreak()
 31066  	}
 31067  	if yyb16 {
 31068  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31069  		return
 31070  	}
 31071  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31072  	if r.TryDecodeAsNil() {
 31073  		x.EvalCreateIndex = 0
 31074  	} else {
 31075  		yyv19 := &x.EvalCreateIndex
 31076  		yym20 := z.DecBinary()
 31077  		_ = yym20
 31078  		if false {
 31079  		} else {
 31080  			*((*uint64)(yyv19)) = uint64(r.DecodeUint(64))
 31081  		}
 31082  	}
 31083  	yyj16++
 31084  	if yyhl16 {
 31085  		yyb16 = yyj16 > l
 31086  	} else {
 31087  		yyb16 = r.CheckBreak()
 31088  	}
 31089  	if yyb16 {
 31090  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31091  		return
 31092  	}
 31093  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31094  	if r.TryDecodeAsNil() {
 31095  		x.JobModifyIndex = 0
 31096  	} else {
 31097  		yyv21 := &x.JobModifyIndex
 31098  		yym22 := z.DecBinary()
 31099  		_ = yym22
 31100  		if false {
 31101  		} else {
 31102  			*((*uint64)(yyv21)) = uint64(r.DecodeUint(64))
 31103  		}
 31104  	}
 31105  	yyj16++
 31106  	if yyhl16 {
 31107  		yyb16 = yyj16 > l
 31108  	} else {
 31109  		yyb16 = r.CheckBreak()
 31110  	}
 31111  	if yyb16 {
 31112  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31113  		return
 31114  	}
 31115  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31116  	if r.TryDecodeAsNil() {
 31117  		x.Index = 0
 31118  	} else {
 31119  		yyv23 := &x.Index
 31120  		yym24 := z.DecBinary()
 31121  		_ = yym24
 31122  		if false {
 31123  		} else {
 31124  			*((*uint64)(yyv23)) = uint64(r.DecodeUint(64))
 31125  		}
 31126  	}
 31127  	yyj16++
 31128  	if yyhl16 {
 31129  		yyb16 = yyj16 > l
 31130  	} else {
 31131  		yyb16 = r.CheckBreak()
 31132  	}
 31133  	if yyb16 {
 31134  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31135  		return
 31136  	}
 31137  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31138  	if r.TryDecodeAsNil() {
 31139  		x.LastContact = 0
 31140  	} else {
 31141  		yyv25 := &x.LastContact
 31142  		yym26 := z.DecBinary()
 31143  		_ = yym26
 31144  		if false {
 31145  		} else if z.HasExtensions() && z.DecExt(yyv25) {
 31146  		} else {
 31147  			*((*int64)(yyv25)) = int64(r.DecodeInt(64))
 31148  		}
 31149  	}
 31150  	yyj16++
 31151  	if yyhl16 {
 31152  		yyb16 = yyj16 > l
 31153  	} else {
 31154  		yyb16 = r.CheckBreak()
 31155  	}
 31156  	if yyb16 {
 31157  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31158  		return
 31159  	}
 31160  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31161  	if r.TryDecodeAsNil() {
 31162  		x.KnownLeader = false
 31163  	} else {
 31164  		yyv27 := &x.KnownLeader
 31165  		yym28 := z.DecBinary()
 31166  		_ = yym28
 31167  		if false {
 31168  		} else {
 31169  			*((*bool)(yyv27)) = r.DecodeBool()
 31170  		}
 31171  	}
 31172  	for {
 31173  		yyj16++
 31174  		if yyhl16 {
 31175  			yyb16 = yyj16 > l
 31176  		} else {
 31177  			yyb16 = r.CheckBreak()
 31178  		}
 31179  		if yyb16 {
 31180  			break
 31181  		}
 31182  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31183  		z.DecStructFieldNotFound(yyj16-1, "")
 31184  	}
 31185  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31186  }
 31187  
 31188  func (x *JobBatchDeregisterResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 31189  	var h codecSelfer100
 31190  	z, r := codec1978.GenHelperEncoder(e)
 31191  	_, _, _ = h, z, r
 31192  	if x == nil {
 31193  		r.EncodeNil()
 31194  	} else {
 31195  		yym1 := z.EncBinary()
 31196  		_ = yym1
 31197  		if false {
 31198  		} else if z.HasExtensions() && z.EncExt(x) {
 31199  		} else {
 31200  			yysep2 := !z.EncBinary()
 31201  			yy2arr2 := z.EncBasicHandle().StructToArray
 31202  			var yyq2 [4]bool
 31203  			_, _, _ = yysep2, yyq2, yy2arr2
 31204  			const yyr2 bool = false
 31205  			var yynn2 int
 31206  			if yyr2 || yy2arr2 {
 31207  				r.EncodeArrayStart(4)
 31208  			} else {
 31209  				yynn2 = 4
 31210  				for _, b := range yyq2 {
 31211  					if b {
 31212  						yynn2++
 31213  					}
 31214  				}
 31215  				r.EncodeMapStart(yynn2)
 31216  				yynn2 = 0
 31217  			}
 31218  			if yyr2 || yy2arr2 {
 31219  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 31220  				if x.JobEvals == nil {
 31221  					r.EncodeNil()
 31222  				} else {
 31223  					yym4 := z.EncBinary()
 31224  					_ = yym4
 31225  					if false {
 31226  					} else {
 31227  						h.encMapNamespacedIDstring((map[NamespacedID]string)(x.JobEvals), e)
 31228  					}
 31229  				}
 31230  			} else {
 31231  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 31232  				r.EncodeString(codecSelferC_UTF8100, string("JobEvals"))
 31233  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 31234  				if x.JobEvals == nil {
 31235  					r.EncodeNil()
 31236  				} else {
 31237  					yym5 := z.EncBinary()
 31238  					_ = yym5
 31239  					if false {
 31240  					} else {
 31241  						h.encMapNamespacedIDstring((map[NamespacedID]string)(x.JobEvals), e)
 31242  					}
 31243  				}
 31244  			}
 31245  			if yyr2 || yy2arr2 {
 31246  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 31247  				yym7 := z.EncBinary()
 31248  				_ = yym7
 31249  				if false {
 31250  				} else {
 31251  					r.EncodeUint(uint64(x.Index))
 31252  				}
 31253  			} else {
 31254  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 31255  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 31256  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 31257  				yym8 := z.EncBinary()
 31258  				_ = yym8
 31259  				if false {
 31260  				} else {
 31261  					r.EncodeUint(uint64(x.Index))
 31262  				}
 31263  			}
 31264  			if yyr2 || yy2arr2 {
 31265  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 31266  				yym10 := z.EncBinary()
 31267  				_ = yym10
 31268  				if false {
 31269  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 31270  				} else {
 31271  					r.EncodeInt(int64(x.LastContact))
 31272  				}
 31273  			} else {
 31274  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 31275  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 31276  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 31277  				yym11 := z.EncBinary()
 31278  				_ = yym11
 31279  				if false {
 31280  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 31281  				} else {
 31282  					r.EncodeInt(int64(x.LastContact))
 31283  				}
 31284  			}
 31285  			if yyr2 || yy2arr2 {
 31286  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 31287  				yym13 := z.EncBinary()
 31288  				_ = yym13
 31289  				if false {
 31290  				} else {
 31291  					r.EncodeBool(bool(x.KnownLeader))
 31292  				}
 31293  			} else {
 31294  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 31295  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 31296  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 31297  				yym14 := z.EncBinary()
 31298  				_ = yym14
 31299  				if false {
 31300  				} else {
 31301  					r.EncodeBool(bool(x.KnownLeader))
 31302  				}
 31303  			}
 31304  			if yyr2 || yy2arr2 {
 31305  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 31306  			} else {
 31307  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 31308  			}
 31309  		}
 31310  	}
 31311  }
 31312  
 31313  func (x *JobBatchDeregisterResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 31314  	var h codecSelfer100
 31315  	z, r := codec1978.GenHelperDecoder(d)
 31316  	_, _, _ = h, z, r
 31317  	yym1 := z.DecBinary()
 31318  	_ = yym1
 31319  	if false {
 31320  	} else if z.HasExtensions() && z.DecExt(x) {
 31321  	} else {
 31322  		yyct2 := r.ContainerType()
 31323  		if yyct2 == codecSelferValueTypeMap100 {
 31324  			yyl2 := r.ReadMapStart()
 31325  			if yyl2 == 0 {
 31326  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 31327  			} else {
 31328  				x.codecDecodeSelfFromMap(yyl2, d)
 31329  			}
 31330  		} else if yyct2 == codecSelferValueTypeArray100 {
 31331  			yyl2 := r.ReadArrayStart()
 31332  			if yyl2 == 0 {
 31333  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31334  			} else {
 31335  				x.codecDecodeSelfFromArray(yyl2, d)
 31336  			}
 31337  		} else {
 31338  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 31339  		}
 31340  	}
 31341  }
 31342  
 31343  func (x *JobBatchDeregisterResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 31344  	var h codecSelfer100
 31345  	z, r := codec1978.GenHelperDecoder(d)
 31346  	_, _, _ = h, z, r
 31347  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 31348  	_ = yys3Slc
 31349  	var yyhl3 bool = l >= 0
 31350  	for yyj3 := 0; ; yyj3++ {
 31351  		if yyhl3 {
 31352  			if yyj3 >= l {
 31353  				break
 31354  			}
 31355  		} else {
 31356  			if r.CheckBreak() {
 31357  				break
 31358  			}
 31359  		}
 31360  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 31361  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 31362  		yys3 := string(yys3Slc)
 31363  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 31364  		switch yys3 {
 31365  		case "JobEvals":
 31366  			if r.TryDecodeAsNil() {
 31367  				x.JobEvals = nil
 31368  			} else {
 31369  				yyv4 := &x.JobEvals
 31370  				yym5 := z.DecBinary()
 31371  				_ = yym5
 31372  				if false {
 31373  				} else {
 31374  					h.decMapNamespacedIDstring((*map[NamespacedID]string)(yyv4), d)
 31375  				}
 31376  			}
 31377  		case "Index":
 31378  			if r.TryDecodeAsNil() {
 31379  				x.Index = 0
 31380  			} else {
 31381  				yyv6 := &x.Index
 31382  				yym7 := z.DecBinary()
 31383  				_ = yym7
 31384  				if false {
 31385  				} else {
 31386  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 31387  				}
 31388  			}
 31389  		case "LastContact":
 31390  			if r.TryDecodeAsNil() {
 31391  				x.LastContact = 0
 31392  			} else {
 31393  				yyv8 := &x.LastContact
 31394  				yym9 := z.DecBinary()
 31395  				_ = yym9
 31396  				if false {
 31397  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 31398  				} else {
 31399  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 31400  				}
 31401  			}
 31402  		case "KnownLeader":
 31403  			if r.TryDecodeAsNil() {
 31404  				x.KnownLeader = false
 31405  			} else {
 31406  				yyv10 := &x.KnownLeader
 31407  				yym11 := z.DecBinary()
 31408  				_ = yym11
 31409  				if false {
 31410  				} else {
 31411  					*((*bool)(yyv10)) = r.DecodeBool()
 31412  				}
 31413  			}
 31414  		default:
 31415  			z.DecStructFieldNotFound(-1, yys3)
 31416  		} // end switch yys3
 31417  	} // end for yyj3
 31418  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 31419  }
 31420  
 31421  func (x *JobBatchDeregisterResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 31422  	var h codecSelfer100
 31423  	z, r := codec1978.GenHelperDecoder(d)
 31424  	_, _, _ = h, z, r
 31425  	var yyj12 int
 31426  	var yyb12 bool
 31427  	var yyhl12 bool = l >= 0
 31428  	yyj12++
 31429  	if yyhl12 {
 31430  		yyb12 = yyj12 > l
 31431  	} else {
 31432  		yyb12 = r.CheckBreak()
 31433  	}
 31434  	if yyb12 {
 31435  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31436  		return
 31437  	}
 31438  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31439  	if r.TryDecodeAsNil() {
 31440  		x.JobEvals = nil
 31441  	} else {
 31442  		yyv13 := &x.JobEvals
 31443  		yym14 := z.DecBinary()
 31444  		_ = yym14
 31445  		if false {
 31446  		} else {
 31447  			h.decMapNamespacedIDstring((*map[NamespacedID]string)(yyv13), d)
 31448  		}
 31449  	}
 31450  	yyj12++
 31451  	if yyhl12 {
 31452  		yyb12 = yyj12 > l
 31453  	} else {
 31454  		yyb12 = r.CheckBreak()
 31455  	}
 31456  	if yyb12 {
 31457  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31458  		return
 31459  	}
 31460  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31461  	if r.TryDecodeAsNil() {
 31462  		x.Index = 0
 31463  	} else {
 31464  		yyv15 := &x.Index
 31465  		yym16 := z.DecBinary()
 31466  		_ = yym16
 31467  		if false {
 31468  		} else {
 31469  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 31470  		}
 31471  	}
 31472  	yyj12++
 31473  	if yyhl12 {
 31474  		yyb12 = yyj12 > l
 31475  	} else {
 31476  		yyb12 = r.CheckBreak()
 31477  	}
 31478  	if yyb12 {
 31479  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31480  		return
 31481  	}
 31482  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31483  	if r.TryDecodeAsNil() {
 31484  		x.LastContact = 0
 31485  	} else {
 31486  		yyv17 := &x.LastContact
 31487  		yym18 := z.DecBinary()
 31488  		_ = yym18
 31489  		if false {
 31490  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 31491  		} else {
 31492  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 31493  		}
 31494  	}
 31495  	yyj12++
 31496  	if yyhl12 {
 31497  		yyb12 = yyj12 > l
 31498  	} else {
 31499  		yyb12 = r.CheckBreak()
 31500  	}
 31501  	if yyb12 {
 31502  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31503  		return
 31504  	}
 31505  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31506  	if r.TryDecodeAsNil() {
 31507  		x.KnownLeader = false
 31508  	} else {
 31509  		yyv19 := &x.KnownLeader
 31510  		yym20 := z.DecBinary()
 31511  		_ = yym20
 31512  		if false {
 31513  		} else {
 31514  			*((*bool)(yyv19)) = r.DecodeBool()
 31515  		}
 31516  	}
 31517  	for {
 31518  		yyj12++
 31519  		if yyhl12 {
 31520  			yyb12 = yyj12 > l
 31521  		} else {
 31522  			yyb12 = r.CheckBreak()
 31523  		}
 31524  		if yyb12 {
 31525  			break
 31526  		}
 31527  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31528  		z.DecStructFieldNotFound(yyj12-1, "")
 31529  	}
 31530  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31531  }
 31532  
 31533  func (x *JobValidateResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 31534  	var h codecSelfer100
 31535  	z, r := codec1978.GenHelperEncoder(e)
 31536  	_, _, _ = h, z, r
 31537  	if x == nil {
 31538  		r.EncodeNil()
 31539  	} else {
 31540  		yym1 := z.EncBinary()
 31541  		_ = yym1
 31542  		if false {
 31543  		} else if z.HasExtensions() && z.EncExt(x) {
 31544  		} else {
 31545  			yysep2 := !z.EncBinary()
 31546  			yy2arr2 := z.EncBasicHandle().StructToArray
 31547  			var yyq2 [4]bool
 31548  			_, _, _ = yysep2, yyq2, yy2arr2
 31549  			const yyr2 bool = false
 31550  			var yynn2 int
 31551  			if yyr2 || yy2arr2 {
 31552  				r.EncodeArrayStart(4)
 31553  			} else {
 31554  				yynn2 = 4
 31555  				for _, b := range yyq2 {
 31556  					if b {
 31557  						yynn2++
 31558  					}
 31559  				}
 31560  				r.EncodeMapStart(yynn2)
 31561  				yynn2 = 0
 31562  			}
 31563  			if yyr2 || yy2arr2 {
 31564  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 31565  				yym4 := z.EncBinary()
 31566  				_ = yym4
 31567  				if false {
 31568  				} else {
 31569  					r.EncodeBool(bool(x.DriverConfigValidated))
 31570  				}
 31571  			} else {
 31572  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 31573  				r.EncodeString(codecSelferC_UTF8100, string("DriverConfigValidated"))
 31574  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 31575  				yym5 := z.EncBinary()
 31576  				_ = yym5
 31577  				if false {
 31578  				} else {
 31579  					r.EncodeBool(bool(x.DriverConfigValidated))
 31580  				}
 31581  			}
 31582  			if yyr2 || yy2arr2 {
 31583  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 31584  				if x.ValidationErrors == nil {
 31585  					r.EncodeNil()
 31586  				} else {
 31587  					yym7 := z.EncBinary()
 31588  					_ = yym7
 31589  					if false {
 31590  					} else {
 31591  						z.F.EncSliceStringV(x.ValidationErrors, false, e)
 31592  					}
 31593  				}
 31594  			} else {
 31595  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 31596  				r.EncodeString(codecSelferC_UTF8100, string("ValidationErrors"))
 31597  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 31598  				if x.ValidationErrors == nil {
 31599  					r.EncodeNil()
 31600  				} else {
 31601  					yym8 := z.EncBinary()
 31602  					_ = yym8
 31603  					if false {
 31604  					} else {
 31605  						z.F.EncSliceStringV(x.ValidationErrors, false, e)
 31606  					}
 31607  				}
 31608  			}
 31609  			if yyr2 || yy2arr2 {
 31610  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 31611  				yym10 := z.EncBinary()
 31612  				_ = yym10
 31613  				if false {
 31614  				} else {
 31615  					r.EncodeString(codecSelferC_UTF8100, string(x.Error))
 31616  				}
 31617  			} else {
 31618  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 31619  				r.EncodeString(codecSelferC_UTF8100, string("Error"))
 31620  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 31621  				yym11 := z.EncBinary()
 31622  				_ = yym11
 31623  				if false {
 31624  				} else {
 31625  					r.EncodeString(codecSelferC_UTF8100, string(x.Error))
 31626  				}
 31627  			}
 31628  			if yyr2 || yy2arr2 {
 31629  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 31630  				yym13 := z.EncBinary()
 31631  				_ = yym13
 31632  				if false {
 31633  				} else {
 31634  					r.EncodeString(codecSelferC_UTF8100, string(x.Warnings))
 31635  				}
 31636  			} else {
 31637  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 31638  				r.EncodeString(codecSelferC_UTF8100, string("Warnings"))
 31639  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 31640  				yym14 := z.EncBinary()
 31641  				_ = yym14
 31642  				if false {
 31643  				} else {
 31644  					r.EncodeString(codecSelferC_UTF8100, string(x.Warnings))
 31645  				}
 31646  			}
 31647  			if yyr2 || yy2arr2 {
 31648  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 31649  			} else {
 31650  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 31651  			}
 31652  		}
 31653  	}
 31654  }
 31655  
 31656  func (x *JobValidateResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 31657  	var h codecSelfer100
 31658  	z, r := codec1978.GenHelperDecoder(d)
 31659  	_, _, _ = h, z, r
 31660  	yym1 := z.DecBinary()
 31661  	_ = yym1
 31662  	if false {
 31663  	} else if z.HasExtensions() && z.DecExt(x) {
 31664  	} else {
 31665  		yyct2 := r.ContainerType()
 31666  		if yyct2 == codecSelferValueTypeMap100 {
 31667  			yyl2 := r.ReadMapStart()
 31668  			if yyl2 == 0 {
 31669  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 31670  			} else {
 31671  				x.codecDecodeSelfFromMap(yyl2, d)
 31672  			}
 31673  		} else if yyct2 == codecSelferValueTypeArray100 {
 31674  			yyl2 := r.ReadArrayStart()
 31675  			if yyl2 == 0 {
 31676  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31677  			} else {
 31678  				x.codecDecodeSelfFromArray(yyl2, d)
 31679  			}
 31680  		} else {
 31681  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 31682  		}
 31683  	}
 31684  }
 31685  
 31686  func (x *JobValidateResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 31687  	var h codecSelfer100
 31688  	z, r := codec1978.GenHelperDecoder(d)
 31689  	_, _, _ = h, z, r
 31690  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 31691  	_ = yys3Slc
 31692  	var yyhl3 bool = l >= 0
 31693  	for yyj3 := 0; ; yyj3++ {
 31694  		if yyhl3 {
 31695  			if yyj3 >= l {
 31696  				break
 31697  			}
 31698  		} else {
 31699  			if r.CheckBreak() {
 31700  				break
 31701  			}
 31702  		}
 31703  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 31704  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 31705  		yys3 := string(yys3Slc)
 31706  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 31707  		switch yys3 {
 31708  		case "DriverConfigValidated":
 31709  			if r.TryDecodeAsNil() {
 31710  				x.DriverConfigValidated = false
 31711  			} else {
 31712  				yyv4 := &x.DriverConfigValidated
 31713  				yym5 := z.DecBinary()
 31714  				_ = yym5
 31715  				if false {
 31716  				} else {
 31717  					*((*bool)(yyv4)) = r.DecodeBool()
 31718  				}
 31719  			}
 31720  		case "ValidationErrors":
 31721  			if r.TryDecodeAsNil() {
 31722  				x.ValidationErrors = nil
 31723  			} else {
 31724  				yyv6 := &x.ValidationErrors
 31725  				yym7 := z.DecBinary()
 31726  				_ = yym7
 31727  				if false {
 31728  				} else {
 31729  					z.F.DecSliceStringX(yyv6, false, d)
 31730  				}
 31731  			}
 31732  		case "Error":
 31733  			if r.TryDecodeAsNil() {
 31734  				x.Error = ""
 31735  			} else {
 31736  				yyv8 := &x.Error
 31737  				yym9 := z.DecBinary()
 31738  				_ = yym9
 31739  				if false {
 31740  				} else {
 31741  					*((*string)(yyv8)) = r.DecodeString()
 31742  				}
 31743  			}
 31744  		case "Warnings":
 31745  			if r.TryDecodeAsNil() {
 31746  				x.Warnings = ""
 31747  			} else {
 31748  				yyv10 := &x.Warnings
 31749  				yym11 := z.DecBinary()
 31750  				_ = yym11
 31751  				if false {
 31752  				} else {
 31753  					*((*string)(yyv10)) = r.DecodeString()
 31754  				}
 31755  			}
 31756  		default:
 31757  			z.DecStructFieldNotFound(-1, yys3)
 31758  		} // end switch yys3
 31759  	} // end for yyj3
 31760  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 31761  }
 31762  
 31763  func (x *JobValidateResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 31764  	var h codecSelfer100
 31765  	z, r := codec1978.GenHelperDecoder(d)
 31766  	_, _, _ = h, z, r
 31767  	var yyj12 int
 31768  	var yyb12 bool
 31769  	var yyhl12 bool = l >= 0
 31770  	yyj12++
 31771  	if yyhl12 {
 31772  		yyb12 = yyj12 > l
 31773  	} else {
 31774  		yyb12 = r.CheckBreak()
 31775  	}
 31776  	if yyb12 {
 31777  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31778  		return
 31779  	}
 31780  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31781  	if r.TryDecodeAsNil() {
 31782  		x.DriverConfigValidated = false
 31783  	} else {
 31784  		yyv13 := &x.DriverConfigValidated
 31785  		yym14 := z.DecBinary()
 31786  		_ = yym14
 31787  		if false {
 31788  		} else {
 31789  			*((*bool)(yyv13)) = r.DecodeBool()
 31790  		}
 31791  	}
 31792  	yyj12++
 31793  	if yyhl12 {
 31794  		yyb12 = yyj12 > l
 31795  	} else {
 31796  		yyb12 = r.CheckBreak()
 31797  	}
 31798  	if yyb12 {
 31799  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31800  		return
 31801  	}
 31802  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31803  	if r.TryDecodeAsNil() {
 31804  		x.ValidationErrors = nil
 31805  	} else {
 31806  		yyv15 := &x.ValidationErrors
 31807  		yym16 := z.DecBinary()
 31808  		_ = yym16
 31809  		if false {
 31810  		} else {
 31811  			z.F.DecSliceStringX(yyv15, false, d)
 31812  		}
 31813  	}
 31814  	yyj12++
 31815  	if yyhl12 {
 31816  		yyb12 = yyj12 > l
 31817  	} else {
 31818  		yyb12 = r.CheckBreak()
 31819  	}
 31820  	if yyb12 {
 31821  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31822  		return
 31823  	}
 31824  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31825  	if r.TryDecodeAsNil() {
 31826  		x.Error = ""
 31827  	} else {
 31828  		yyv17 := &x.Error
 31829  		yym18 := z.DecBinary()
 31830  		_ = yym18
 31831  		if false {
 31832  		} else {
 31833  			*((*string)(yyv17)) = r.DecodeString()
 31834  		}
 31835  	}
 31836  	yyj12++
 31837  	if yyhl12 {
 31838  		yyb12 = yyj12 > l
 31839  	} else {
 31840  		yyb12 = r.CheckBreak()
 31841  	}
 31842  	if yyb12 {
 31843  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31844  		return
 31845  	}
 31846  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31847  	if r.TryDecodeAsNil() {
 31848  		x.Warnings = ""
 31849  	} else {
 31850  		yyv19 := &x.Warnings
 31851  		yym20 := z.DecBinary()
 31852  		_ = yym20
 31853  		if false {
 31854  		} else {
 31855  			*((*string)(yyv19)) = r.DecodeString()
 31856  		}
 31857  	}
 31858  	for {
 31859  		yyj12++
 31860  		if yyhl12 {
 31861  			yyb12 = yyj12 > l
 31862  		} else {
 31863  			yyb12 = r.CheckBreak()
 31864  		}
 31865  		if yyb12 {
 31866  			break
 31867  		}
 31868  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 31869  		z.DecStructFieldNotFound(yyj12-1, "")
 31870  	}
 31871  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 31872  }
 31873  
 31874  func (x *NodeUpdateResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 31875  	var h codecSelfer100
 31876  	z, r := codec1978.GenHelperEncoder(e)
 31877  	_, _, _ = h, z, r
 31878  	if x == nil {
 31879  		r.EncodeNil()
 31880  	} else {
 31881  		yym1 := z.EncBinary()
 31882  		_ = yym1
 31883  		if false {
 31884  		} else if z.HasExtensions() && z.EncExt(x) {
 31885  		} else {
 31886  			yysep2 := !z.EncBinary()
 31887  			yy2arr2 := z.EncBasicHandle().StructToArray
 31888  			var yyq2 [10]bool
 31889  			_, _, _ = yysep2, yyq2, yy2arr2
 31890  			const yyr2 bool = false
 31891  			var yynn2 int
 31892  			if yyr2 || yy2arr2 {
 31893  				r.EncodeArrayStart(10)
 31894  			} else {
 31895  				yynn2 = 10
 31896  				for _, b := range yyq2 {
 31897  					if b {
 31898  						yynn2++
 31899  					}
 31900  				}
 31901  				r.EncodeMapStart(yynn2)
 31902  				yynn2 = 0
 31903  			}
 31904  			if yyr2 || yy2arr2 {
 31905  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 31906  				yym4 := z.EncBinary()
 31907  				_ = yym4
 31908  				if false {
 31909  				} else if z.HasExtensions() && z.EncExt(x.HeartbeatTTL) {
 31910  				} else {
 31911  					r.EncodeInt(int64(x.HeartbeatTTL))
 31912  				}
 31913  			} else {
 31914  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 31915  				r.EncodeString(codecSelferC_UTF8100, string("HeartbeatTTL"))
 31916  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 31917  				yym5 := z.EncBinary()
 31918  				_ = yym5
 31919  				if false {
 31920  				} else if z.HasExtensions() && z.EncExt(x.HeartbeatTTL) {
 31921  				} else {
 31922  					r.EncodeInt(int64(x.HeartbeatTTL))
 31923  				}
 31924  			}
 31925  			if yyr2 || yy2arr2 {
 31926  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 31927  				if x.EvalIDs == nil {
 31928  					r.EncodeNil()
 31929  				} else {
 31930  					yym7 := z.EncBinary()
 31931  					_ = yym7
 31932  					if false {
 31933  					} else {
 31934  						z.F.EncSliceStringV(x.EvalIDs, false, e)
 31935  					}
 31936  				}
 31937  			} else {
 31938  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 31939  				r.EncodeString(codecSelferC_UTF8100, string("EvalIDs"))
 31940  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 31941  				if x.EvalIDs == nil {
 31942  					r.EncodeNil()
 31943  				} else {
 31944  					yym8 := z.EncBinary()
 31945  					_ = yym8
 31946  					if false {
 31947  					} else {
 31948  						z.F.EncSliceStringV(x.EvalIDs, false, e)
 31949  					}
 31950  				}
 31951  			}
 31952  			if yyr2 || yy2arr2 {
 31953  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 31954  				yym10 := z.EncBinary()
 31955  				_ = yym10
 31956  				if false {
 31957  				} else {
 31958  					r.EncodeUint(uint64(x.EvalCreateIndex))
 31959  				}
 31960  			} else {
 31961  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 31962  				r.EncodeString(codecSelferC_UTF8100, string("EvalCreateIndex"))
 31963  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 31964  				yym11 := z.EncBinary()
 31965  				_ = yym11
 31966  				if false {
 31967  				} else {
 31968  					r.EncodeUint(uint64(x.EvalCreateIndex))
 31969  				}
 31970  			}
 31971  			if yyr2 || yy2arr2 {
 31972  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 31973  				yym13 := z.EncBinary()
 31974  				_ = yym13
 31975  				if false {
 31976  				} else {
 31977  					r.EncodeUint(uint64(x.NodeModifyIndex))
 31978  				}
 31979  			} else {
 31980  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 31981  				r.EncodeString(codecSelferC_UTF8100, string("NodeModifyIndex"))
 31982  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 31983  				yym14 := z.EncBinary()
 31984  				_ = yym14
 31985  				if false {
 31986  				} else {
 31987  					r.EncodeUint(uint64(x.NodeModifyIndex))
 31988  				}
 31989  			}
 31990  			if yyr2 || yy2arr2 {
 31991  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 31992  				yym16 := z.EncBinary()
 31993  				_ = yym16
 31994  				if false {
 31995  				} else {
 31996  					r.EncodeString(codecSelferC_UTF8100, string(x.LeaderRPCAddr))
 31997  				}
 31998  			} else {
 31999  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 32000  				r.EncodeString(codecSelferC_UTF8100, string("LeaderRPCAddr"))
 32001  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 32002  				yym17 := z.EncBinary()
 32003  				_ = yym17
 32004  				if false {
 32005  				} else {
 32006  					r.EncodeString(codecSelferC_UTF8100, string(x.LeaderRPCAddr))
 32007  				}
 32008  			}
 32009  			if yyr2 || yy2arr2 {
 32010  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 32011  				yym19 := z.EncBinary()
 32012  				_ = yym19
 32013  				if false {
 32014  				} else {
 32015  					r.EncodeInt(int64(x.NumNodes))
 32016  				}
 32017  			} else {
 32018  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 32019  				r.EncodeString(codecSelferC_UTF8100, string("NumNodes"))
 32020  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 32021  				yym20 := z.EncBinary()
 32022  				_ = yym20
 32023  				if false {
 32024  				} else {
 32025  					r.EncodeInt(int64(x.NumNodes))
 32026  				}
 32027  			}
 32028  			if yyr2 || yy2arr2 {
 32029  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 32030  				if x.Servers == nil {
 32031  					r.EncodeNil()
 32032  				} else {
 32033  					yym22 := z.EncBinary()
 32034  					_ = yym22
 32035  					if false {
 32036  					} else {
 32037  						h.encSlicePtrtoNodeServerInfo(([]*NodeServerInfo)(x.Servers), e)
 32038  					}
 32039  				}
 32040  			} else {
 32041  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 32042  				r.EncodeString(codecSelferC_UTF8100, string("Servers"))
 32043  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 32044  				if x.Servers == nil {
 32045  					r.EncodeNil()
 32046  				} else {
 32047  					yym23 := z.EncBinary()
 32048  					_ = yym23
 32049  					if false {
 32050  					} else {
 32051  						h.encSlicePtrtoNodeServerInfo(([]*NodeServerInfo)(x.Servers), e)
 32052  					}
 32053  				}
 32054  			}
 32055  			if yyr2 || yy2arr2 {
 32056  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 32057  				yym25 := z.EncBinary()
 32058  				_ = yym25
 32059  				if false {
 32060  				} else {
 32061  					r.EncodeUint(uint64(x.Index))
 32062  				}
 32063  			} else {
 32064  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 32065  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 32066  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 32067  				yym26 := z.EncBinary()
 32068  				_ = yym26
 32069  				if false {
 32070  				} else {
 32071  					r.EncodeUint(uint64(x.Index))
 32072  				}
 32073  			}
 32074  			if yyr2 || yy2arr2 {
 32075  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 32076  				yym28 := z.EncBinary()
 32077  				_ = yym28
 32078  				if false {
 32079  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 32080  				} else {
 32081  					r.EncodeInt(int64(x.LastContact))
 32082  				}
 32083  			} else {
 32084  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 32085  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 32086  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 32087  				yym29 := z.EncBinary()
 32088  				_ = yym29
 32089  				if false {
 32090  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 32091  				} else {
 32092  					r.EncodeInt(int64(x.LastContact))
 32093  				}
 32094  			}
 32095  			if yyr2 || yy2arr2 {
 32096  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 32097  				yym31 := z.EncBinary()
 32098  				_ = yym31
 32099  				if false {
 32100  				} else {
 32101  					r.EncodeBool(bool(x.KnownLeader))
 32102  				}
 32103  			} else {
 32104  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 32105  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 32106  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 32107  				yym32 := z.EncBinary()
 32108  				_ = yym32
 32109  				if false {
 32110  				} else {
 32111  					r.EncodeBool(bool(x.KnownLeader))
 32112  				}
 32113  			}
 32114  			if yyr2 || yy2arr2 {
 32115  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 32116  			} else {
 32117  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 32118  			}
 32119  		}
 32120  	}
 32121  }
 32122  
 32123  func (x *NodeUpdateResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 32124  	var h codecSelfer100
 32125  	z, r := codec1978.GenHelperDecoder(d)
 32126  	_, _, _ = h, z, r
 32127  	yym1 := z.DecBinary()
 32128  	_ = yym1
 32129  	if false {
 32130  	} else if z.HasExtensions() && z.DecExt(x) {
 32131  	} else {
 32132  		yyct2 := r.ContainerType()
 32133  		if yyct2 == codecSelferValueTypeMap100 {
 32134  			yyl2 := r.ReadMapStart()
 32135  			if yyl2 == 0 {
 32136  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 32137  			} else {
 32138  				x.codecDecodeSelfFromMap(yyl2, d)
 32139  			}
 32140  		} else if yyct2 == codecSelferValueTypeArray100 {
 32141  			yyl2 := r.ReadArrayStart()
 32142  			if yyl2 == 0 {
 32143  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32144  			} else {
 32145  				x.codecDecodeSelfFromArray(yyl2, d)
 32146  			}
 32147  		} else {
 32148  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 32149  		}
 32150  	}
 32151  }
 32152  
 32153  func (x *NodeUpdateResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 32154  	var h codecSelfer100
 32155  	z, r := codec1978.GenHelperDecoder(d)
 32156  	_, _, _ = h, z, r
 32157  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 32158  	_ = yys3Slc
 32159  	var yyhl3 bool = l >= 0
 32160  	for yyj3 := 0; ; yyj3++ {
 32161  		if yyhl3 {
 32162  			if yyj3 >= l {
 32163  				break
 32164  			}
 32165  		} else {
 32166  			if r.CheckBreak() {
 32167  				break
 32168  			}
 32169  		}
 32170  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 32171  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 32172  		yys3 := string(yys3Slc)
 32173  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 32174  		switch yys3 {
 32175  		case "HeartbeatTTL":
 32176  			if r.TryDecodeAsNil() {
 32177  				x.HeartbeatTTL = 0
 32178  			} else {
 32179  				yyv4 := &x.HeartbeatTTL
 32180  				yym5 := z.DecBinary()
 32181  				_ = yym5
 32182  				if false {
 32183  				} else if z.HasExtensions() && z.DecExt(yyv4) {
 32184  				} else {
 32185  					*((*int64)(yyv4)) = int64(r.DecodeInt(64))
 32186  				}
 32187  			}
 32188  		case "EvalIDs":
 32189  			if r.TryDecodeAsNil() {
 32190  				x.EvalIDs = nil
 32191  			} else {
 32192  				yyv6 := &x.EvalIDs
 32193  				yym7 := z.DecBinary()
 32194  				_ = yym7
 32195  				if false {
 32196  				} else {
 32197  					z.F.DecSliceStringX(yyv6, false, d)
 32198  				}
 32199  			}
 32200  		case "EvalCreateIndex":
 32201  			if r.TryDecodeAsNil() {
 32202  				x.EvalCreateIndex = 0
 32203  			} else {
 32204  				yyv8 := &x.EvalCreateIndex
 32205  				yym9 := z.DecBinary()
 32206  				_ = yym9
 32207  				if false {
 32208  				} else {
 32209  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 32210  				}
 32211  			}
 32212  		case "NodeModifyIndex":
 32213  			if r.TryDecodeAsNil() {
 32214  				x.NodeModifyIndex = 0
 32215  			} else {
 32216  				yyv10 := &x.NodeModifyIndex
 32217  				yym11 := z.DecBinary()
 32218  				_ = yym11
 32219  				if false {
 32220  				} else {
 32221  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 32222  				}
 32223  			}
 32224  		case "LeaderRPCAddr":
 32225  			if r.TryDecodeAsNil() {
 32226  				x.LeaderRPCAddr = ""
 32227  			} else {
 32228  				yyv12 := &x.LeaderRPCAddr
 32229  				yym13 := z.DecBinary()
 32230  				_ = yym13
 32231  				if false {
 32232  				} else {
 32233  					*((*string)(yyv12)) = r.DecodeString()
 32234  				}
 32235  			}
 32236  		case "NumNodes":
 32237  			if r.TryDecodeAsNil() {
 32238  				x.NumNodes = 0
 32239  			} else {
 32240  				yyv14 := &x.NumNodes
 32241  				yym15 := z.DecBinary()
 32242  				_ = yym15
 32243  				if false {
 32244  				} else {
 32245  					*((*int32)(yyv14)) = int32(r.DecodeInt(32))
 32246  				}
 32247  			}
 32248  		case "Servers":
 32249  			if r.TryDecodeAsNil() {
 32250  				x.Servers = nil
 32251  			} else {
 32252  				yyv16 := &x.Servers
 32253  				yym17 := z.DecBinary()
 32254  				_ = yym17
 32255  				if false {
 32256  				} else {
 32257  					h.decSlicePtrtoNodeServerInfo((*[]*NodeServerInfo)(yyv16), d)
 32258  				}
 32259  			}
 32260  		case "Index":
 32261  			if r.TryDecodeAsNil() {
 32262  				x.Index = 0
 32263  			} else {
 32264  				yyv18 := &x.Index
 32265  				yym19 := z.DecBinary()
 32266  				_ = yym19
 32267  				if false {
 32268  				} else {
 32269  					*((*uint64)(yyv18)) = uint64(r.DecodeUint(64))
 32270  				}
 32271  			}
 32272  		case "LastContact":
 32273  			if r.TryDecodeAsNil() {
 32274  				x.LastContact = 0
 32275  			} else {
 32276  				yyv20 := &x.LastContact
 32277  				yym21 := z.DecBinary()
 32278  				_ = yym21
 32279  				if false {
 32280  				} else if z.HasExtensions() && z.DecExt(yyv20) {
 32281  				} else {
 32282  					*((*int64)(yyv20)) = int64(r.DecodeInt(64))
 32283  				}
 32284  			}
 32285  		case "KnownLeader":
 32286  			if r.TryDecodeAsNil() {
 32287  				x.KnownLeader = false
 32288  			} else {
 32289  				yyv22 := &x.KnownLeader
 32290  				yym23 := z.DecBinary()
 32291  				_ = yym23
 32292  				if false {
 32293  				} else {
 32294  					*((*bool)(yyv22)) = r.DecodeBool()
 32295  				}
 32296  			}
 32297  		default:
 32298  			z.DecStructFieldNotFound(-1, yys3)
 32299  		} // end switch yys3
 32300  	} // end for yyj3
 32301  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 32302  }
 32303  
 32304  func (x *NodeUpdateResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 32305  	var h codecSelfer100
 32306  	z, r := codec1978.GenHelperDecoder(d)
 32307  	_, _, _ = h, z, r
 32308  	var yyj24 int
 32309  	var yyb24 bool
 32310  	var yyhl24 bool = l >= 0
 32311  	yyj24++
 32312  	if yyhl24 {
 32313  		yyb24 = yyj24 > l
 32314  	} else {
 32315  		yyb24 = r.CheckBreak()
 32316  	}
 32317  	if yyb24 {
 32318  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32319  		return
 32320  	}
 32321  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32322  	if r.TryDecodeAsNil() {
 32323  		x.HeartbeatTTL = 0
 32324  	} else {
 32325  		yyv25 := &x.HeartbeatTTL
 32326  		yym26 := z.DecBinary()
 32327  		_ = yym26
 32328  		if false {
 32329  		} else if z.HasExtensions() && z.DecExt(yyv25) {
 32330  		} else {
 32331  			*((*int64)(yyv25)) = int64(r.DecodeInt(64))
 32332  		}
 32333  	}
 32334  	yyj24++
 32335  	if yyhl24 {
 32336  		yyb24 = yyj24 > l
 32337  	} else {
 32338  		yyb24 = r.CheckBreak()
 32339  	}
 32340  	if yyb24 {
 32341  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32342  		return
 32343  	}
 32344  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32345  	if r.TryDecodeAsNil() {
 32346  		x.EvalIDs = nil
 32347  	} else {
 32348  		yyv27 := &x.EvalIDs
 32349  		yym28 := z.DecBinary()
 32350  		_ = yym28
 32351  		if false {
 32352  		} else {
 32353  			z.F.DecSliceStringX(yyv27, false, d)
 32354  		}
 32355  	}
 32356  	yyj24++
 32357  	if yyhl24 {
 32358  		yyb24 = yyj24 > l
 32359  	} else {
 32360  		yyb24 = r.CheckBreak()
 32361  	}
 32362  	if yyb24 {
 32363  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32364  		return
 32365  	}
 32366  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32367  	if r.TryDecodeAsNil() {
 32368  		x.EvalCreateIndex = 0
 32369  	} else {
 32370  		yyv29 := &x.EvalCreateIndex
 32371  		yym30 := z.DecBinary()
 32372  		_ = yym30
 32373  		if false {
 32374  		} else {
 32375  			*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
 32376  		}
 32377  	}
 32378  	yyj24++
 32379  	if yyhl24 {
 32380  		yyb24 = yyj24 > l
 32381  	} else {
 32382  		yyb24 = r.CheckBreak()
 32383  	}
 32384  	if yyb24 {
 32385  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32386  		return
 32387  	}
 32388  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32389  	if r.TryDecodeAsNil() {
 32390  		x.NodeModifyIndex = 0
 32391  	} else {
 32392  		yyv31 := &x.NodeModifyIndex
 32393  		yym32 := z.DecBinary()
 32394  		_ = yym32
 32395  		if false {
 32396  		} else {
 32397  			*((*uint64)(yyv31)) = uint64(r.DecodeUint(64))
 32398  		}
 32399  	}
 32400  	yyj24++
 32401  	if yyhl24 {
 32402  		yyb24 = yyj24 > l
 32403  	} else {
 32404  		yyb24 = r.CheckBreak()
 32405  	}
 32406  	if yyb24 {
 32407  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32408  		return
 32409  	}
 32410  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32411  	if r.TryDecodeAsNil() {
 32412  		x.LeaderRPCAddr = ""
 32413  	} else {
 32414  		yyv33 := &x.LeaderRPCAddr
 32415  		yym34 := z.DecBinary()
 32416  		_ = yym34
 32417  		if false {
 32418  		} else {
 32419  			*((*string)(yyv33)) = r.DecodeString()
 32420  		}
 32421  	}
 32422  	yyj24++
 32423  	if yyhl24 {
 32424  		yyb24 = yyj24 > l
 32425  	} else {
 32426  		yyb24 = r.CheckBreak()
 32427  	}
 32428  	if yyb24 {
 32429  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32430  		return
 32431  	}
 32432  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32433  	if r.TryDecodeAsNil() {
 32434  		x.NumNodes = 0
 32435  	} else {
 32436  		yyv35 := &x.NumNodes
 32437  		yym36 := z.DecBinary()
 32438  		_ = yym36
 32439  		if false {
 32440  		} else {
 32441  			*((*int32)(yyv35)) = int32(r.DecodeInt(32))
 32442  		}
 32443  	}
 32444  	yyj24++
 32445  	if yyhl24 {
 32446  		yyb24 = yyj24 > l
 32447  	} else {
 32448  		yyb24 = r.CheckBreak()
 32449  	}
 32450  	if yyb24 {
 32451  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32452  		return
 32453  	}
 32454  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32455  	if r.TryDecodeAsNil() {
 32456  		x.Servers = nil
 32457  	} else {
 32458  		yyv37 := &x.Servers
 32459  		yym38 := z.DecBinary()
 32460  		_ = yym38
 32461  		if false {
 32462  		} else {
 32463  			h.decSlicePtrtoNodeServerInfo((*[]*NodeServerInfo)(yyv37), d)
 32464  		}
 32465  	}
 32466  	yyj24++
 32467  	if yyhl24 {
 32468  		yyb24 = yyj24 > l
 32469  	} else {
 32470  		yyb24 = r.CheckBreak()
 32471  	}
 32472  	if yyb24 {
 32473  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32474  		return
 32475  	}
 32476  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32477  	if r.TryDecodeAsNil() {
 32478  		x.Index = 0
 32479  	} else {
 32480  		yyv39 := &x.Index
 32481  		yym40 := z.DecBinary()
 32482  		_ = yym40
 32483  		if false {
 32484  		} else {
 32485  			*((*uint64)(yyv39)) = uint64(r.DecodeUint(64))
 32486  		}
 32487  	}
 32488  	yyj24++
 32489  	if yyhl24 {
 32490  		yyb24 = yyj24 > l
 32491  	} else {
 32492  		yyb24 = r.CheckBreak()
 32493  	}
 32494  	if yyb24 {
 32495  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32496  		return
 32497  	}
 32498  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32499  	if r.TryDecodeAsNil() {
 32500  		x.LastContact = 0
 32501  	} else {
 32502  		yyv41 := &x.LastContact
 32503  		yym42 := z.DecBinary()
 32504  		_ = yym42
 32505  		if false {
 32506  		} else if z.HasExtensions() && z.DecExt(yyv41) {
 32507  		} else {
 32508  			*((*int64)(yyv41)) = int64(r.DecodeInt(64))
 32509  		}
 32510  	}
 32511  	yyj24++
 32512  	if yyhl24 {
 32513  		yyb24 = yyj24 > l
 32514  	} else {
 32515  		yyb24 = r.CheckBreak()
 32516  	}
 32517  	if yyb24 {
 32518  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32519  		return
 32520  	}
 32521  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32522  	if r.TryDecodeAsNil() {
 32523  		x.KnownLeader = false
 32524  	} else {
 32525  		yyv43 := &x.KnownLeader
 32526  		yym44 := z.DecBinary()
 32527  		_ = yym44
 32528  		if false {
 32529  		} else {
 32530  			*((*bool)(yyv43)) = r.DecodeBool()
 32531  		}
 32532  	}
 32533  	for {
 32534  		yyj24++
 32535  		if yyhl24 {
 32536  			yyb24 = yyj24 > l
 32537  		} else {
 32538  			yyb24 = r.CheckBreak()
 32539  		}
 32540  		if yyb24 {
 32541  			break
 32542  		}
 32543  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32544  		z.DecStructFieldNotFound(yyj24-1, "")
 32545  	}
 32546  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32547  }
 32548  
 32549  func (x *NodeDrainUpdateResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 32550  	var h codecSelfer100
 32551  	z, r := codec1978.GenHelperEncoder(e)
 32552  	_, _, _ = h, z, r
 32553  	if x == nil {
 32554  		r.EncodeNil()
 32555  	} else {
 32556  		yym1 := z.EncBinary()
 32557  		_ = yym1
 32558  		if false {
 32559  		} else if z.HasExtensions() && z.EncExt(x) {
 32560  		} else {
 32561  			yysep2 := !z.EncBinary()
 32562  			yy2arr2 := z.EncBasicHandle().StructToArray
 32563  			var yyq2 [4]bool
 32564  			_, _, _ = yysep2, yyq2, yy2arr2
 32565  			const yyr2 bool = false
 32566  			var yynn2 int
 32567  			if yyr2 || yy2arr2 {
 32568  				r.EncodeArrayStart(4)
 32569  			} else {
 32570  				yynn2 = 4
 32571  				for _, b := range yyq2 {
 32572  					if b {
 32573  						yynn2++
 32574  					}
 32575  				}
 32576  				r.EncodeMapStart(yynn2)
 32577  				yynn2 = 0
 32578  			}
 32579  			if yyr2 || yy2arr2 {
 32580  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 32581  				yym4 := z.EncBinary()
 32582  				_ = yym4
 32583  				if false {
 32584  				} else {
 32585  					r.EncodeUint(uint64(x.NodeModifyIndex))
 32586  				}
 32587  			} else {
 32588  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 32589  				r.EncodeString(codecSelferC_UTF8100, string("NodeModifyIndex"))
 32590  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 32591  				yym5 := z.EncBinary()
 32592  				_ = yym5
 32593  				if false {
 32594  				} else {
 32595  					r.EncodeUint(uint64(x.NodeModifyIndex))
 32596  				}
 32597  			}
 32598  			if yyr2 || yy2arr2 {
 32599  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 32600  				if x.EvalIDs == nil {
 32601  					r.EncodeNil()
 32602  				} else {
 32603  					yym7 := z.EncBinary()
 32604  					_ = yym7
 32605  					if false {
 32606  					} else {
 32607  						z.F.EncSliceStringV(x.EvalIDs, false, e)
 32608  					}
 32609  				}
 32610  			} else {
 32611  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 32612  				r.EncodeString(codecSelferC_UTF8100, string("EvalIDs"))
 32613  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 32614  				if x.EvalIDs == nil {
 32615  					r.EncodeNil()
 32616  				} else {
 32617  					yym8 := z.EncBinary()
 32618  					_ = yym8
 32619  					if false {
 32620  					} else {
 32621  						z.F.EncSliceStringV(x.EvalIDs, false, e)
 32622  					}
 32623  				}
 32624  			}
 32625  			if yyr2 || yy2arr2 {
 32626  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 32627  				yym10 := z.EncBinary()
 32628  				_ = yym10
 32629  				if false {
 32630  				} else {
 32631  					r.EncodeUint(uint64(x.EvalCreateIndex))
 32632  				}
 32633  			} else {
 32634  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 32635  				r.EncodeString(codecSelferC_UTF8100, string("EvalCreateIndex"))
 32636  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 32637  				yym11 := z.EncBinary()
 32638  				_ = yym11
 32639  				if false {
 32640  				} else {
 32641  					r.EncodeUint(uint64(x.EvalCreateIndex))
 32642  				}
 32643  			}
 32644  			if yyr2 || yy2arr2 {
 32645  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 32646  				yym13 := z.EncBinary()
 32647  				_ = yym13
 32648  				if false {
 32649  				} else {
 32650  					r.EncodeUint(uint64(x.Index))
 32651  				}
 32652  			} else {
 32653  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 32654  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 32655  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 32656  				yym14 := z.EncBinary()
 32657  				_ = yym14
 32658  				if false {
 32659  				} else {
 32660  					r.EncodeUint(uint64(x.Index))
 32661  				}
 32662  			}
 32663  			if yyr2 || yy2arr2 {
 32664  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 32665  			} else {
 32666  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 32667  			}
 32668  		}
 32669  	}
 32670  }
 32671  
 32672  func (x *NodeDrainUpdateResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 32673  	var h codecSelfer100
 32674  	z, r := codec1978.GenHelperDecoder(d)
 32675  	_, _, _ = h, z, r
 32676  	yym1 := z.DecBinary()
 32677  	_ = yym1
 32678  	if false {
 32679  	} else if z.HasExtensions() && z.DecExt(x) {
 32680  	} else {
 32681  		yyct2 := r.ContainerType()
 32682  		if yyct2 == codecSelferValueTypeMap100 {
 32683  			yyl2 := r.ReadMapStart()
 32684  			if yyl2 == 0 {
 32685  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 32686  			} else {
 32687  				x.codecDecodeSelfFromMap(yyl2, d)
 32688  			}
 32689  		} else if yyct2 == codecSelferValueTypeArray100 {
 32690  			yyl2 := r.ReadArrayStart()
 32691  			if yyl2 == 0 {
 32692  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32693  			} else {
 32694  				x.codecDecodeSelfFromArray(yyl2, d)
 32695  			}
 32696  		} else {
 32697  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 32698  		}
 32699  	}
 32700  }
 32701  
 32702  func (x *NodeDrainUpdateResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 32703  	var h codecSelfer100
 32704  	z, r := codec1978.GenHelperDecoder(d)
 32705  	_, _, _ = h, z, r
 32706  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 32707  	_ = yys3Slc
 32708  	var yyhl3 bool = l >= 0
 32709  	for yyj3 := 0; ; yyj3++ {
 32710  		if yyhl3 {
 32711  			if yyj3 >= l {
 32712  				break
 32713  			}
 32714  		} else {
 32715  			if r.CheckBreak() {
 32716  				break
 32717  			}
 32718  		}
 32719  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 32720  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 32721  		yys3 := string(yys3Slc)
 32722  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 32723  		switch yys3 {
 32724  		case "NodeModifyIndex":
 32725  			if r.TryDecodeAsNil() {
 32726  				x.NodeModifyIndex = 0
 32727  			} else {
 32728  				yyv4 := &x.NodeModifyIndex
 32729  				yym5 := z.DecBinary()
 32730  				_ = yym5
 32731  				if false {
 32732  				} else {
 32733  					*((*uint64)(yyv4)) = uint64(r.DecodeUint(64))
 32734  				}
 32735  			}
 32736  		case "EvalIDs":
 32737  			if r.TryDecodeAsNil() {
 32738  				x.EvalIDs = nil
 32739  			} else {
 32740  				yyv6 := &x.EvalIDs
 32741  				yym7 := z.DecBinary()
 32742  				_ = yym7
 32743  				if false {
 32744  				} else {
 32745  					z.F.DecSliceStringX(yyv6, false, d)
 32746  				}
 32747  			}
 32748  		case "EvalCreateIndex":
 32749  			if r.TryDecodeAsNil() {
 32750  				x.EvalCreateIndex = 0
 32751  			} else {
 32752  				yyv8 := &x.EvalCreateIndex
 32753  				yym9 := z.DecBinary()
 32754  				_ = yym9
 32755  				if false {
 32756  				} else {
 32757  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 32758  				}
 32759  			}
 32760  		case "Index":
 32761  			if r.TryDecodeAsNil() {
 32762  				x.Index = 0
 32763  			} else {
 32764  				yyv10 := &x.Index
 32765  				yym11 := z.DecBinary()
 32766  				_ = yym11
 32767  				if false {
 32768  				} else {
 32769  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 32770  				}
 32771  			}
 32772  		default:
 32773  			z.DecStructFieldNotFound(-1, yys3)
 32774  		} // end switch yys3
 32775  	} // end for yyj3
 32776  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 32777  }
 32778  
 32779  func (x *NodeDrainUpdateResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 32780  	var h codecSelfer100
 32781  	z, r := codec1978.GenHelperDecoder(d)
 32782  	_, _, _ = h, z, r
 32783  	var yyj12 int
 32784  	var yyb12 bool
 32785  	var yyhl12 bool = l >= 0
 32786  	yyj12++
 32787  	if yyhl12 {
 32788  		yyb12 = yyj12 > l
 32789  	} else {
 32790  		yyb12 = r.CheckBreak()
 32791  	}
 32792  	if yyb12 {
 32793  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32794  		return
 32795  	}
 32796  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32797  	if r.TryDecodeAsNil() {
 32798  		x.NodeModifyIndex = 0
 32799  	} else {
 32800  		yyv13 := &x.NodeModifyIndex
 32801  		yym14 := z.DecBinary()
 32802  		_ = yym14
 32803  		if false {
 32804  		} else {
 32805  			*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 32806  		}
 32807  	}
 32808  	yyj12++
 32809  	if yyhl12 {
 32810  		yyb12 = yyj12 > l
 32811  	} else {
 32812  		yyb12 = r.CheckBreak()
 32813  	}
 32814  	if yyb12 {
 32815  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32816  		return
 32817  	}
 32818  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32819  	if r.TryDecodeAsNil() {
 32820  		x.EvalIDs = nil
 32821  	} else {
 32822  		yyv15 := &x.EvalIDs
 32823  		yym16 := z.DecBinary()
 32824  		_ = yym16
 32825  		if false {
 32826  		} else {
 32827  			z.F.DecSliceStringX(yyv15, false, d)
 32828  		}
 32829  	}
 32830  	yyj12++
 32831  	if yyhl12 {
 32832  		yyb12 = yyj12 > l
 32833  	} else {
 32834  		yyb12 = r.CheckBreak()
 32835  	}
 32836  	if yyb12 {
 32837  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32838  		return
 32839  	}
 32840  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32841  	if r.TryDecodeAsNil() {
 32842  		x.EvalCreateIndex = 0
 32843  	} else {
 32844  		yyv17 := &x.EvalCreateIndex
 32845  		yym18 := z.DecBinary()
 32846  		_ = yym18
 32847  		if false {
 32848  		} else {
 32849  			*((*uint64)(yyv17)) = uint64(r.DecodeUint(64))
 32850  		}
 32851  	}
 32852  	yyj12++
 32853  	if yyhl12 {
 32854  		yyb12 = yyj12 > l
 32855  	} else {
 32856  		yyb12 = r.CheckBreak()
 32857  	}
 32858  	if yyb12 {
 32859  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32860  		return
 32861  	}
 32862  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32863  	if r.TryDecodeAsNil() {
 32864  		x.Index = 0
 32865  	} else {
 32866  		yyv19 := &x.Index
 32867  		yym20 := z.DecBinary()
 32868  		_ = yym20
 32869  		if false {
 32870  		} else {
 32871  			*((*uint64)(yyv19)) = uint64(r.DecodeUint(64))
 32872  		}
 32873  	}
 32874  	for {
 32875  		yyj12++
 32876  		if yyhl12 {
 32877  			yyb12 = yyj12 > l
 32878  		} else {
 32879  			yyb12 = r.CheckBreak()
 32880  		}
 32881  		if yyb12 {
 32882  			break
 32883  		}
 32884  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 32885  		z.DecStructFieldNotFound(yyj12-1, "")
 32886  	}
 32887  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 32888  }
 32889  
 32890  func (x *NodeEligibilityUpdateResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 32891  	var h codecSelfer100
 32892  	z, r := codec1978.GenHelperEncoder(e)
 32893  	_, _, _ = h, z, r
 32894  	if x == nil {
 32895  		r.EncodeNil()
 32896  	} else {
 32897  		yym1 := z.EncBinary()
 32898  		_ = yym1
 32899  		if false {
 32900  		} else if z.HasExtensions() && z.EncExt(x) {
 32901  		} else {
 32902  			yysep2 := !z.EncBinary()
 32903  			yy2arr2 := z.EncBasicHandle().StructToArray
 32904  			var yyq2 [4]bool
 32905  			_, _, _ = yysep2, yyq2, yy2arr2
 32906  			const yyr2 bool = false
 32907  			var yynn2 int
 32908  			if yyr2 || yy2arr2 {
 32909  				r.EncodeArrayStart(4)
 32910  			} else {
 32911  				yynn2 = 4
 32912  				for _, b := range yyq2 {
 32913  					if b {
 32914  						yynn2++
 32915  					}
 32916  				}
 32917  				r.EncodeMapStart(yynn2)
 32918  				yynn2 = 0
 32919  			}
 32920  			if yyr2 || yy2arr2 {
 32921  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 32922  				yym4 := z.EncBinary()
 32923  				_ = yym4
 32924  				if false {
 32925  				} else {
 32926  					r.EncodeUint(uint64(x.NodeModifyIndex))
 32927  				}
 32928  			} else {
 32929  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 32930  				r.EncodeString(codecSelferC_UTF8100, string("NodeModifyIndex"))
 32931  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 32932  				yym5 := z.EncBinary()
 32933  				_ = yym5
 32934  				if false {
 32935  				} else {
 32936  					r.EncodeUint(uint64(x.NodeModifyIndex))
 32937  				}
 32938  			}
 32939  			if yyr2 || yy2arr2 {
 32940  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 32941  				if x.EvalIDs == nil {
 32942  					r.EncodeNil()
 32943  				} else {
 32944  					yym7 := z.EncBinary()
 32945  					_ = yym7
 32946  					if false {
 32947  					} else {
 32948  						z.F.EncSliceStringV(x.EvalIDs, false, e)
 32949  					}
 32950  				}
 32951  			} else {
 32952  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 32953  				r.EncodeString(codecSelferC_UTF8100, string("EvalIDs"))
 32954  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 32955  				if x.EvalIDs == nil {
 32956  					r.EncodeNil()
 32957  				} else {
 32958  					yym8 := z.EncBinary()
 32959  					_ = yym8
 32960  					if false {
 32961  					} else {
 32962  						z.F.EncSliceStringV(x.EvalIDs, false, e)
 32963  					}
 32964  				}
 32965  			}
 32966  			if yyr2 || yy2arr2 {
 32967  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 32968  				yym10 := z.EncBinary()
 32969  				_ = yym10
 32970  				if false {
 32971  				} else {
 32972  					r.EncodeUint(uint64(x.EvalCreateIndex))
 32973  				}
 32974  			} else {
 32975  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 32976  				r.EncodeString(codecSelferC_UTF8100, string("EvalCreateIndex"))
 32977  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 32978  				yym11 := z.EncBinary()
 32979  				_ = yym11
 32980  				if false {
 32981  				} else {
 32982  					r.EncodeUint(uint64(x.EvalCreateIndex))
 32983  				}
 32984  			}
 32985  			if yyr2 || yy2arr2 {
 32986  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 32987  				yym13 := z.EncBinary()
 32988  				_ = yym13
 32989  				if false {
 32990  				} else {
 32991  					r.EncodeUint(uint64(x.Index))
 32992  				}
 32993  			} else {
 32994  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 32995  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 32996  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 32997  				yym14 := z.EncBinary()
 32998  				_ = yym14
 32999  				if false {
 33000  				} else {
 33001  					r.EncodeUint(uint64(x.Index))
 33002  				}
 33003  			}
 33004  			if yyr2 || yy2arr2 {
 33005  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 33006  			} else {
 33007  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 33008  			}
 33009  		}
 33010  	}
 33011  }
 33012  
 33013  func (x *NodeEligibilityUpdateResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 33014  	var h codecSelfer100
 33015  	z, r := codec1978.GenHelperDecoder(d)
 33016  	_, _, _ = h, z, r
 33017  	yym1 := z.DecBinary()
 33018  	_ = yym1
 33019  	if false {
 33020  	} else if z.HasExtensions() && z.DecExt(x) {
 33021  	} else {
 33022  		yyct2 := r.ContainerType()
 33023  		if yyct2 == codecSelferValueTypeMap100 {
 33024  			yyl2 := r.ReadMapStart()
 33025  			if yyl2 == 0 {
 33026  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 33027  			} else {
 33028  				x.codecDecodeSelfFromMap(yyl2, d)
 33029  			}
 33030  		} else if yyct2 == codecSelferValueTypeArray100 {
 33031  			yyl2 := r.ReadArrayStart()
 33032  			if yyl2 == 0 {
 33033  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33034  			} else {
 33035  				x.codecDecodeSelfFromArray(yyl2, d)
 33036  			}
 33037  		} else {
 33038  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 33039  		}
 33040  	}
 33041  }
 33042  
 33043  func (x *NodeEligibilityUpdateResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 33044  	var h codecSelfer100
 33045  	z, r := codec1978.GenHelperDecoder(d)
 33046  	_, _, _ = h, z, r
 33047  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 33048  	_ = yys3Slc
 33049  	var yyhl3 bool = l >= 0
 33050  	for yyj3 := 0; ; yyj3++ {
 33051  		if yyhl3 {
 33052  			if yyj3 >= l {
 33053  				break
 33054  			}
 33055  		} else {
 33056  			if r.CheckBreak() {
 33057  				break
 33058  			}
 33059  		}
 33060  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 33061  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 33062  		yys3 := string(yys3Slc)
 33063  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 33064  		switch yys3 {
 33065  		case "NodeModifyIndex":
 33066  			if r.TryDecodeAsNil() {
 33067  				x.NodeModifyIndex = 0
 33068  			} else {
 33069  				yyv4 := &x.NodeModifyIndex
 33070  				yym5 := z.DecBinary()
 33071  				_ = yym5
 33072  				if false {
 33073  				} else {
 33074  					*((*uint64)(yyv4)) = uint64(r.DecodeUint(64))
 33075  				}
 33076  			}
 33077  		case "EvalIDs":
 33078  			if r.TryDecodeAsNil() {
 33079  				x.EvalIDs = nil
 33080  			} else {
 33081  				yyv6 := &x.EvalIDs
 33082  				yym7 := z.DecBinary()
 33083  				_ = yym7
 33084  				if false {
 33085  				} else {
 33086  					z.F.DecSliceStringX(yyv6, false, d)
 33087  				}
 33088  			}
 33089  		case "EvalCreateIndex":
 33090  			if r.TryDecodeAsNil() {
 33091  				x.EvalCreateIndex = 0
 33092  			} else {
 33093  				yyv8 := &x.EvalCreateIndex
 33094  				yym9 := z.DecBinary()
 33095  				_ = yym9
 33096  				if false {
 33097  				} else {
 33098  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 33099  				}
 33100  			}
 33101  		case "Index":
 33102  			if r.TryDecodeAsNil() {
 33103  				x.Index = 0
 33104  			} else {
 33105  				yyv10 := &x.Index
 33106  				yym11 := z.DecBinary()
 33107  				_ = yym11
 33108  				if false {
 33109  				} else {
 33110  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 33111  				}
 33112  			}
 33113  		default:
 33114  			z.DecStructFieldNotFound(-1, yys3)
 33115  		} // end switch yys3
 33116  	} // end for yyj3
 33117  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 33118  }
 33119  
 33120  func (x *NodeEligibilityUpdateResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 33121  	var h codecSelfer100
 33122  	z, r := codec1978.GenHelperDecoder(d)
 33123  	_, _, _ = h, z, r
 33124  	var yyj12 int
 33125  	var yyb12 bool
 33126  	var yyhl12 bool = l >= 0
 33127  	yyj12++
 33128  	if yyhl12 {
 33129  		yyb12 = yyj12 > l
 33130  	} else {
 33131  		yyb12 = r.CheckBreak()
 33132  	}
 33133  	if yyb12 {
 33134  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33135  		return
 33136  	}
 33137  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33138  	if r.TryDecodeAsNil() {
 33139  		x.NodeModifyIndex = 0
 33140  	} else {
 33141  		yyv13 := &x.NodeModifyIndex
 33142  		yym14 := z.DecBinary()
 33143  		_ = yym14
 33144  		if false {
 33145  		} else {
 33146  			*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 33147  		}
 33148  	}
 33149  	yyj12++
 33150  	if yyhl12 {
 33151  		yyb12 = yyj12 > l
 33152  	} else {
 33153  		yyb12 = r.CheckBreak()
 33154  	}
 33155  	if yyb12 {
 33156  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33157  		return
 33158  	}
 33159  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33160  	if r.TryDecodeAsNil() {
 33161  		x.EvalIDs = nil
 33162  	} else {
 33163  		yyv15 := &x.EvalIDs
 33164  		yym16 := z.DecBinary()
 33165  		_ = yym16
 33166  		if false {
 33167  		} else {
 33168  			z.F.DecSliceStringX(yyv15, false, d)
 33169  		}
 33170  	}
 33171  	yyj12++
 33172  	if yyhl12 {
 33173  		yyb12 = yyj12 > l
 33174  	} else {
 33175  		yyb12 = r.CheckBreak()
 33176  	}
 33177  	if yyb12 {
 33178  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33179  		return
 33180  	}
 33181  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33182  	if r.TryDecodeAsNil() {
 33183  		x.EvalCreateIndex = 0
 33184  	} else {
 33185  		yyv17 := &x.EvalCreateIndex
 33186  		yym18 := z.DecBinary()
 33187  		_ = yym18
 33188  		if false {
 33189  		} else {
 33190  			*((*uint64)(yyv17)) = uint64(r.DecodeUint(64))
 33191  		}
 33192  	}
 33193  	yyj12++
 33194  	if yyhl12 {
 33195  		yyb12 = yyj12 > l
 33196  	} else {
 33197  		yyb12 = r.CheckBreak()
 33198  	}
 33199  	if yyb12 {
 33200  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33201  		return
 33202  	}
 33203  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33204  	if r.TryDecodeAsNil() {
 33205  		x.Index = 0
 33206  	} else {
 33207  		yyv19 := &x.Index
 33208  		yym20 := z.DecBinary()
 33209  		_ = yym20
 33210  		if false {
 33211  		} else {
 33212  			*((*uint64)(yyv19)) = uint64(r.DecodeUint(64))
 33213  		}
 33214  	}
 33215  	for {
 33216  		yyj12++
 33217  		if yyhl12 {
 33218  			yyb12 = yyj12 > l
 33219  		} else {
 33220  			yyb12 = r.CheckBreak()
 33221  		}
 33222  		if yyb12 {
 33223  			break
 33224  		}
 33225  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33226  		z.DecStructFieldNotFound(yyj12-1, "")
 33227  	}
 33228  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33229  }
 33230  
 33231  func (x *NodeAllocsResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 33232  	var h codecSelfer100
 33233  	z, r := codec1978.GenHelperEncoder(e)
 33234  	_, _, _ = h, z, r
 33235  	if x == nil {
 33236  		r.EncodeNil()
 33237  	} else {
 33238  		yym1 := z.EncBinary()
 33239  		_ = yym1
 33240  		if false {
 33241  		} else if z.HasExtensions() && z.EncExt(x) {
 33242  		} else {
 33243  			yysep2 := !z.EncBinary()
 33244  			yy2arr2 := z.EncBasicHandle().StructToArray
 33245  			var yyq2 [4]bool
 33246  			_, _, _ = yysep2, yyq2, yy2arr2
 33247  			const yyr2 bool = false
 33248  			var yynn2 int
 33249  			if yyr2 || yy2arr2 {
 33250  				r.EncodeArrayStart(4)
 33251  			} else {
 33252  				yynn2 = 4
 33253  				for _, b := range yyq2 {
 33254  					if b {
 33255  						yynn2++
 33256  					}
 33257  				}
 33258  				r.EncodeMapStart(yynn2)
 33259  				yynn2 = 0
 33260  			}
 33261  			if yyr2 || yy2arr2 {
 33262  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 33263  				if x.Allocs == nil {
 33264  					r.EncodeNil()
 33265  				} else {
 33266  					yym4 := z.EncBinary()
 33267  					_ = yym4
 33268  					if false {
 33269  					} else {
 33270  						h.encSlicePtrtoAllocation(([]*Allocation)(x.Allocs), e)
 33271  					}
 33272  				}
 33273  			} else {
 33274  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 33275  				r.EncodeString(codecSelferC_UTF8100, string("Allocs"))
 33276  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 33277  				if x.Allocs == nil {
 33278  					r.EncodeNil()
 33279  				} else {
 33280  					yym5 := z.EncBinary()
 33281  					_ = yym5
 33282  					if false {
 33283  					} else {
 33284  						h.encSlicePtrtoAllocation(([]*Allocation)(x.Allocs), e)
 33285  					}
 33286  				}
 33287  			}
 33288  			if yyr2 || yy2arr2 {
 33289  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 33290  				yym7 := z.EncBinary()
 33291  				_ = yym7
 33292  				if false {
 33293  				} else {
 33294  					r.EncodeUint(uint64(x.Index))
 33295  				}
 33296  			} else {
 33297  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 33298  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 33299  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 33300  				yym8 := z.EncBinary()
 33301  				_ = yym8
 33302  				if false {
 33303  				} else {
 33304  					r.EncodeUint(uint64(x.Index))
 33305  				}
 33306  			}
 33307  			if yyr2 || yy2arr2 {
 33308  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 33309  				yym10 := z.EncBinary()
 33310  				_ = yym10
 33311  				if false {
 33312  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 33313  				} else {
 33314  					r.EncodeInt(int64(x.LastContact))
 33315  				}
 33316  			} else {
 33317  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 33318  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 33319  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 33320  				yym11 := z.EncBinary()
 33321  				_ = yym11
 33322  				if false {
 33323  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 33324  				} else {
 33325  					r.EncodeInt(int64(x.LastContact))
 33326  				}
 33327  			}
 33328  			if yyr2 || yy2arr2 {
 33329  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 33330  				yym13 := z.EncBinary()
 33331  				_ = yym13
 33332  				if false {
 33333  				} else {
 33334  					r.EncodeBool(bool(x.KnownLeader))
 33335  				}
 33336  			} else {
 33337  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 33338  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 33339  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 33340  				yym14 := z.EncBinary()
 33341  				_ = yym14
 33342  				if false {
 33343  				} else {
 33344  					r.EncodeBool(bool(x.KnownLeader))
 33345  				}
 33346  			}
 33347  			if yyr2 || yy2arr2 {
 33348  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 33349  			} else {
 33350  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 33351  			}
 33352  		}
 33353  	}
 33354  }
 33355  
 33356  func (x *NodeAllocsResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 33357  	var h codecSelfer100
 33358  	z, r := codec1978.GenHelperDecoder(d)
 33359  	_, _, _ = h, z, r
 33360  	yym1 := z.DecBinary()
 33361  	_ = yym1
 33362  	if false {
 33363  	} else if z.HasExtensions() && z.DecExt(x) {
 33364  	} else {
 33365  		yyct2 := r.ContainerType()
 33366  		if yyct2 == codecSelferValueTypeMap100 {
 33367  			yyl2 := r.ReadMapStart()
 33368  			if yyl2 == 0 {
 33369  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 33370  			} else {
 33371  				x.codecDecodeSelfFromMap(yyl2, d)
 33372  			}
 33373  		} else if yyct2 == codecSelferValueTypeArray100 {
 33374  			yyl2 := r.ReadArrayStart()
 33375  			if yyl2 == 0 {
 33376  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33377  			} else {
 33378  				x.codecDecodeSelfFromArray(yyl2, d)
 33379  			}
 33380  		} else {
 33381  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 33382  		}
 33383  	}
 33384  }
 33385  
 33386  func (x *NodeAllocsResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 33387  	var h codecSelfer100
 33388  	z, r := codec1978.GenHelperDecoder(d)
 33389  	_, _, _ = h, z, r
 33390  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 33391  	_ = yys3Slc
 33392  	var yyhl3 bool = l >= 0
 33393  	for yyj3 := 0; ; yyj3++ {
 33394  		if yyhl3 {
 33395  			if yyj3 >= l {
 33396  				break
 33397  			}
 33398  		} else {
 33399  			if r.CheckBreak() {
 33400  				break
 33401  			}
 33402  		}
 33403  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 33404  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 33405  		yys3 := string(yys3Slc)
 33406  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 33407  		switch yys3 {
 33408  		case "Allocs":
 33409  			if r.TryDecodeAsNil() {
 33410  				x.Allocs = nil
 33411  			} else {
 33412  				yyv4 := &x.Allocs
 33413  				yym5 := z.DecBinary()
 33414  				_ = yym5
 33415  				if false {
 33416  				} else {
 33417  					h.decSlicePtrtoAllocation((*[]*Allocation)(yyv4), d)
 33418  				}
 33419  			}
 33420  		case "Index":
 33421  			if r.TryDecodeAsNil() {
 33422  				x.Index = 0
 33423  			} else {
 33424  				yyv6 := &x.Index
 33425  				yym7 := z.DecBinary()
 33426  				_ = yym7
 33427  				if false {
 33428  				} else {
 33429  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 33430  				}
 33431  			}
 33432  		case "LastContact":
 33433  			if r.TryDecodeAsNil() {
 33434  				x.LastContact = 0
 33435  			} else {
 33436  				yyv8 := &x.LastContact
 33437  				yym9 := z.DecBinary()
 33438  				_ = yym9
 33439  				if false {
 33440  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 33441  				} else {
 33442  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 33443  				}
 33444  			}
 33445  		case "KnownLeader":
 33446  			if r.TryDecodeAsNil() {
 33447  				x.KnownLeader = false
 33448  			} else {
 33449  				yyv10 := &x.KnownLeader
 33450  				yym11 := z.DecBinary()
 33451  				_ = yym11
 33452  				if false {
 33453  				} else {
 33454  					*((*bool)(yyv10)) = r.DecodeBool()
 33455  				}
 33456  			}
 33457  		default:
 33458  			z.DecStructFieldNotFound(-1, yys3)
 33459  		} // end switch yys3
 33460  	} // end for yyj3
 33461  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 33462  }
 33463  
 33464  func (x *NodeAllocsResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 33465  	var h codecSelfer100
 33466  	z, r := codec1978.GenHelperDecoder(d)
 33467  	_, _, _ = h, z, r
 33468  	var yyj12 int
 33469  	var yyb12 bool
 33470  	var yyhl12 bool = l >= 0
 33471  	yyj12++
 33472  	if yyhl12 {
 33473  		yyb12 = yyj12 > l
 33474  	} else {
 33475  		yyb12 = r.CheckBreak()
 33476  	}
 33477  	if yyb12 {
 33478  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33479  		return
 33480  	}
 33481  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33482  	if r.TryDecodeAsNil() {
 33483  		x.Allocs = nil
 33484  	} else {
 33485  		yyv13 := &x.Allocs
 33486  		yym14 := z.DecBinary()
 33487  		_ = yym14
 33488  		if false {
 33489  		} else {
 33490  			h.decSlicePtrtoAllocation((*[]*Allocation)(yyv13), d)
 33491  		}
 33492  	}
 33493  	yyj12++
 33494  	if yyhl12 {
 33495  		yyb12 = yyj12 > l
 33496  	} else {
 33497  		yyb12 = r.CheckBreak()
 33498  	}
 33499  	if yyb12 {
 33500  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33501  		return
 33502  	}
 33503  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33504  	if r.TryDecodeAsNil() {
 33505  		x.Index = 0
 33506  	} else {
 33507  		yyv15 := &x.Index
 33508  		yym16 := z.DecBinary()
 33509  		_ = yym16
 33510  		if false {
 33511  		} else {
 33512  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 33513  		}
 33514  	}
 33515  	yyj12++
 33516  	if yyhl12 {
 33517  		yyb12 = yyj12 > l
 33518  	} else {
 33519  		yyb12 = r.CheckBreak()
 33520  	}
 33521  	if yyb12 {
 33522  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33523  		return
 33524  	}
 33525  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33526  	if r.TryDecodeAsNil() {
 33527  		x.LastContact = 0
 33528  	} else {
 33529  		yyv17 := &x.LastContact
 33530  		yym18 := z.DecBinary()
 33531  		_ = yym18
 33532  		if false {
 33533  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 33534  		} else {
 33535  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 33536  		}
 33537  	}
 33538  	yyj12++
 33539  	if yyhl12 {
 33540  		yyb12 = yyj12 > l
 33541  	} else {
 33542  		yyb12 = r.CheckBreak()
 33543  	}
 33544  	if yyb12 {
 33545  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33546  		return
 33547  	}
 33548  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33549  	if r.TryDecodeAsNil() {
 33550  		x.KnownLeader = false
 33551  	} else {
 33552  		yyv19 := &x.KnownLeader
 33553  		yym20 := z.DecBinary()
 33554  		_ = yym20
 33555  		if false {
 33556  		} else {
 33557  			*((*bool)(yyv19)) = r.DecodeBool()
 33558  		}
 33559  	}
 33560  	for {
 33561  		yyj12++
 33562  		if yyhl12 {
 33563  			yyb12 = yyj12 > l
 33564  		} else {
 33565  			yyb12 = r.CheckBreak()
 33566  		}
 33567  		if yyb12 {
 33568  			break
 33569  		}
 33570  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33571  		z.DecStructFieldNotFound(yyj12-1, "")
 33572  	}
 33573  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33574  }
 33575  
 33576  func (x *NodeClientAllocsResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 33577  	var h codecSelfer100
 33578  	z, r := codec1978.GenHelperEncoder(e)
 33579  	_, _, _ = h, z, r
 33580  	if x == nil {
 33581  		r.EncodeNil()
 33582  	} else {
 33583  		yym1 := z.EncBinary()
 33584  		_ = yym1
 33585  		if false {
 33586  		} else if z.HasExtensions() && z.EncExt(x) {
 33587  		} else {
 33588  			yysep2 := !z.EncBinary()
 33589  			yy2arr2 := z.EncBasicHandle().StructToArray
 33590  			var yyq2 [5]bool
 33591  			_, _, _ = yysep2, yyq2, yy2arr2
 33592  			const yyr2 bool = false
 33593  			var yynn2 int
 33594  			if yyr2 || yy2arr2 {
 33595  				r.EncodeArrayStart(5)
 33596  			} else {
 33597  				yynn2 = 5
 33598  				for _, b := range yyq2 {
 33599  					if b {
 33600  						yynn2++
 33601  					}
 33602  				}
 33603  				r.EncodeMapStart(yynn2)
 33604  				yynn2 = 0
 33605  			}
 33606  			if yyr2 || yy2arr2 {
 33607  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 33608  				if x.Allocs == nil {
 33609  					r.EncodeNil()
 33610  				} else {
 33611  					yym4 := z.EncBinary()
 33612  					_ = yym4
 33613  					if false {
 33614  					} else {
 33615  						z.F.EncMapStringUint64V(x.Allocs, false, e)
 33616  					}
 33617  				}
 33618  			} else {
 33619  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 33620  				r.EncodeString(codecSelferC_UTF8100, string("Allocs"))
 33621  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 33622  				if x.Allocs == nil {
 33623  					r.EncodeNil()
 33624  				} else {
 33625  					yym5 := z.EncBinary()
 33626  					_ = yym5
 33627  					if false {
 33628  					} else {
 33629  						z.F.EncMapStringUint64V(x.Allocs, false, e)
 33630  					}
 33631  				}
 33632  			}
 33633  			if yyr2 || yy2arr2 {
 33634  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 33635  				if x.MigrateTokens == nil {
 33636  					r.EncodeNil()
 33637  				} else {
 33638  					yym7 := z.EncBinary()
 33639  					_ = yym7
 33640  					if false {
 33641  					} else {
 33642  						z.F.EncMapStringStringV(x.MigrateTokens, false, e)
 33643  					}
 33644  				}
 33645  			} else {
 33646  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 33647  				r.EncodeString(codecSelferC_UTF8100, string("MigrateTokens"))
 33648  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 33649  				if x.MigrateTokens == nil {
 33650  					r.EncodeNil()
 33651  				} else {
 33652  					yym8 := z.EncBinary()
 33653  					_ = yym8
 33654  					if false {
 33655  					} else {
 33656  						z.F.EncMapStringStringV(x.MigrateTokens, false, e)
 33657  					}
 33658  				}
 33659  			}
 33660  			if yyr2 || yy2arr2 {
 33661  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 33662  				yym10 := z.EncBinary()
 33663  				_ = yym10
 33664  				if false {
 33665  				} else {
 33666  					r.EncodeUint(uint64(x.Index))
 33667  				}
 33668  			} else {
 33669  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 33670  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 33671  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 33672  				yym11 := z.EncBinary()
 33673  				_ = yym11
 33674  				if false {
 33675  				} else {
 33676  					r.EncodeUint(uint64(x.Index))
 33677  				}
 33678  			}
 33679  			if yyr2 || yy2arr2 {
 33680  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 33681  				yym13 := z.EncBinary()
 33682  				_ = yym13
 33683  				if false {
 33684  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 33685  				} else {
 33686  					r.EncodeInt(int64(x.LastContact))
 33687  				}
 33688  			} else {
 33689  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 33690  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 33691  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 33692  				yym14 := z.EncBinary()
 33693  				_ = yym14
 33694  				if false {
 33695  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 33696  				} else {
 33697  					r.EncodeInt(int64(x.LastContact))
 33698  				}
 33699  			}
 33700  			if yyr2 || yy2arr2 {
 33701  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 33702  				yym16 := z.EncBinary()
 33703  				_ = yym16
 33704  				if false {
 33705  				} else {
 33706  					r.EncodeBool(bool(x.KnownLeader))
 33707  				}
 33708  			} else {
 33709  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 33710  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 33711  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 33712  				yym17 := z.EncBinary()
 33713  				_ = yym17
 33714  				if false {
 33715  				} else {
 33716  					r.EncodeBool(bool(x.KnownLeader))
 33717  				}
 33718  			}
 33719  			if yyr2 || yy2arr2 {
 33720  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 33721  			} else {
 33722  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 33723  			}
 33724  		}
 33725  	}
 33726  }
 33727  
 33728  func (x *NodeClientAllocsResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 33729  	var h codecSelfer100
 33730  	z, r := codec1978.GenHelperDecoder(d)
 33731  	_, _, _ = h, z, r
 33732  	yym1 := z.DecBinary()
 33733  	_ = yym1
 33734  	if false {
 33735  	} else if z.HasExtensions() && z.DecExt(x) {
 33736  	} else {
 33737  		yyct2 := r.ContainerType()
 33738  		if yyct2 == codecSelferValueTypeMap100 {
 33739  			yyl2 := r.ReadMapStart()
 33740  			if yyl2 == 0 {
 33741  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 33742  			} else {
 33743  				x.codecDecodeSelfFromMap(yyl2, d)
 33744  			}
 33745  		} else if yyct2 == codecSelferValueTypeArray100 {
 33746  			yyl2 := r.ReadArrayStart()
 33747  			if yyl2 == 0 {
 33748  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33749  			} else {
 33750  				x.codecDecodeSelfFromArray(yyl2, d)
 33751  			}
 33752  		} else {
 33753  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 33754  		}
 33755  	}
 33756  }
 33757  
 33758  func (x *NodeClientAllocsResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 33759  	var h codecSelfer100
 33760  	z, r := codec1978.GenHelperDecoder(d)
 33761  	_, _, _ = h, z, r
 33762  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 33763  	_ = yys3Slc
 33764  	var yyhl3 bool = l >= 0
 33765  	for yyj3 := 0; ; yyj3++ {
 33766  		if yyhl3 {
 33767  			if yyj3 >= l {
 33768  				break
 33769  			}
 33770  		} else {
 33771  			if r.CheckBreak() {
 33772  				break
 33773  			}
 33774  		}
 33775  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 33776  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 33777  		yys3 := string(yys3Slc)
 33778  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 33779  		switch yys3 {
 33780  		case "Allocs":
 33781  			if r.TryDecodeAsNil() {
 33782  				x.Allocs = nil
 33783  			} else {
 33784  				yyv4 := &x.Allocs
 33785  				yym5 := z.DecBinary()
 33786  				_ = yym5
 33787  				if false {
 33788  				} else {
 33789  					z.F.DecMapStringUint64X(yyv4, false, d)
 33790  				}
 33791  			}
 33792  		case "MigrateTokens":
 33793  			if r.TryDecodeAsNil() {
 33794  				x.MigrateTokens = nil
 33795  			} else {
 33796  				yyv6 := &x.MigrateTokens
 33797  				yym7 := z.DecBinary()
 33798  				_ = yym7
 33799  				if false {
 33800  				} else {
 33801  					z.F.DecMapStringStringX(yyv6, false, d)
 33802  				}
 33803  			}
 33804  		case "Index":
 33805  			if r.TryDecodeAsNil() {
 33806  				x.Index = 0
 33807  			} else {
 33808  				yyv8 := &x.Index
 33809  				yym9 := z.DecBinary()
 33810  				_ = yym9
 33811  				if false {
 33812  				} else {
 33813  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 33814  				}
 33815  			}
 33816  		case "LastContact":
 33817  			if r.TryDecodeAsNil() {
 33818  				x.LastContact = 0
 33819  			} else {
 33820  				yyv10 := &x.LastContact
 33821  				yym11 := z.DecBinary()
 33822  				_ = yym11
 33823  				if false {
 33824  				} else if z.HasExtensions() && z.DecExt(yyv10) {
 33825  				} else {
 33826  					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
 33827  				}
 33828  			}
 33829  		case "KnownLeader":
 33830  			if r.TryDecodeAsNil() {
 33831  				x.KnownLeader = false
 33832  			} else {
 33833  				yyv12 := &x.KnownLeader
 33834  				yym13 := z.DecBinary()
 33835  				_ = yym13
 33836  				if false {
 33837  				} else {
 33838  					*((*bool)(yyv12)) = r.DecodeBool()
 33839  				}
 33840  			}
 33841  		default:
 33842  			z.DecStructFieldNotFound(-1, yys3)
 33843  		} // end switch yys3
 33844  	} // end for yyj3
 33845  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 33846  }
 33847  
 33848  func (x *NodeClientAllocsResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 33849  	var h codecSelfer100
 33850  	z, r := codec1978.GenHelperDecoder(d)
 33851  	_, _, _ = h, z, r
 33852  	var yyj14 int
 33853  	var yyb14 bool
 33854  	var yyhl14 bool = l >= 0
 33855  	yyj14++
 33856  	if yyhl14 {
 33857  		yyb14 = yyj14 > l
 33858  	} else {
 33859  		yyb14 = r.CheckBreak()
 33860  	}
 33861  	if yyb14 {
 33862  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33863  		return
 33864  	}
 33865  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33866  	if r.TryDecodeAsNil() {
 33867  		x.Allocs = nil
 33868  	} else {
 33869  		yyv15 := &x.Allocs
 33870  		yym16 := z.DecBinary()
 33871  		_ = yym16
 33872  		if false {
 33873  		} else {
 33874  			z.F.DecMapStringUint64X(yyv15, false, d)
 33875  		}
 33876  	}
 33877  	yyj14++
 33878  	if yyhl14 {
 33879  		yyb14 = yyj14 > l
 33880  	} else {
 33881  		yyb14 = r.CheckBreak()
 33882  	}
 33883  	if yyb14 {
 33884  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33885  		return
 33886  	}
 33887  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33888  	if r.TryDecodeAsNil() {
 33889  		x.MigrateTokens = nil
 33890  	} else {
 33891  		yyv17 := &x.MigrateTokens
 33892  		yym18 := z.DecBinary()
 33893  		_ = yym18
 33894  		if false {
 33895  		} else {
 33896  			z.F.DecMapStringStringX(yyv17, false, d)
 33897  		}
 33898  	}
 33899  	yyj14++
 33900  	if yyhl14 {
 33901  		yyb14 = yyj14 > l
 33902  	} else {
 33903  		yyb14 = r.CheckBreak()
 33904  	}
 33905  	if yyb14 {
 33906  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33907  		return
 33908  	}
 33909  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33910  	if r.TryDecodeAsNil() {
 33911  		x.Index = 0
 33912  	} else {
 33913  		yyv19 := &x.Index
 33914  		yym20 := z.DecBinary()
 33915  		_ = yym20
 33916  		if false {
 33917  		} else {
 33918  			*((*uint64)(yyv19)) = uint64(r.DecodeUint(64))
 33919  		}
 33920  	}
 33921  	yyj14++
 33922  	if yyhl14 {
 33923  		yyb14 = yyj14 > l
 33924  	} else {
 33925  		yyb14 = r.CheckBreak()
 33926  	}
 33927  	if yyb14 {
 33928  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33929  		return
 33930  	}
 33931  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33932  	if r.TryDecodeAsNil() {
 33933  		x.LastContact = 0
 33934  	} else {
 33935  		yyv21 := &x.LastContact
 33936  		yym22 := z.DecBinary()
 33937  		_ = yym22
 33938  		if false {
 33939  		} else if z.HasExtensions() && z.DecExt(yyv21) {
 33940  		} else {
 33941  			*((*int64)(yyv21)) = int64(r.DecodeInt(64))
 33942  		}
 33943  	}
 33944  	yyj14++
 33945  	if yyhl14 {
 33946  		yyb14 = yyj14 > l
 33947  	} else {
 33948  		yyb14 = r.CheckBreak()
 33949  	}
 33950  	if yyb14 {
 33951  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33952  		return
 33953  	}
 33954  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33955  	if r.TryDecodeAsNil() {
 33956  		x.KnownLeader = false
 33957  	} else {
 33958  		yyv23 := &x.KnownLeader
 33959  		yym24 := z.DecBinary()
 33960  		_ = yym24
 33961  		if false {
 33962  		} else {
 33963  			*((*bool)(yyv23)) = r.DecodeBool()
 33964  		}
 33965  	}
 33966  	for {
 33967  		yyj14++
 33968  		if yyhl14 {
 33969  			yyb14 = yyj14 > l
 33970  		} else {
 33971  			yyb14 = r.CheckBreak()
 33972  		}
 33973  		if yyb14 {
 33974  			break
 33975  		}
 33976  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 33977  		z.DecStructFieldNotFound(yyj14-1, "")
 33978  	}
 33979  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 33980  }
 33981  
 33982  func (x *SingleNodeResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 33983  	var h codecSelfer100
 33984  	z, r := codec1978.GenHelperEncoder(e)
 33985  	_, _, _ = h, z, r
 33986  	if x == nil {
 33987  		r.EncodeNil()
 33988  	} else {
 33989  		yym1 := z.EncBinary()
 33990  		_ = yym1
 33991  		if false {
 33992  		} else if z.HasExtensions() && z.EncExt(x) {
 33993  		} else {
 33994  			yysep2 := !z.EncBinary()
 33995  			yy2arr2 := z.EncBasicHandle().StructToArray
 33996  			var yyq2 [4]bool
 33997  			_, _, _ = yysep2, yyq2, yy2arr2
 33998  			const yyr2 bool = false
 33999  			var yynn2 int
 34000  			if yyr2 || yy2arr2 {
 34001  				r.EncodeArrayStart(4)
 34002  			} else {
 34003  				yynn2 = 4
 34004  				for _, b := range yyq2 {
 34005  					if b {
 34006  						yynn2++
 34007  					}
 34008  				}
 34009  				r.EncodeMapStart(yynn2)
 34010  				yynn2 = 0
 34011  			}
 34012  			if yyr2 || yy2arr2 {
 34013  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 34014  				if x.Node == nil {
 34015  					r.EncodeNil()
 34016  				} else {
 34017  					x.Node.CodecEncodeSelf(e)
 34018  				}
 34019  			} else {
 34020  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 34021  				r.EncodeString(codecSelferC_UTF8100, string("Node"))
 34022  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 34023  				if x.Node == nil {
 34024  					r.EncodeNil()
 34025  				} else {
 34026  					x.Node.CodecEncodeSelf(e)
 34027  				}
 34028  			}
 34029  			if yyr2 || yy2arr2 {
 34030  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 34031  				yym7 := z.EncBinary()
 34032  				_ = yym7
 34033  				if false {
 34034  				} else {
 34035  					r.EncodeUint(uint64(x.Index))
 34036  				}
 34037  			} else {
 34038  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 34039  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 34040  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 34041  				yym8 := z.EncBinary()
 34042  				_ = yym8
 34043  				if false {
 34044  				} else {
 34045  					r.EncodeUint(uint64(x.Index))
 34046  				}
 34047  			}
 34048  			if yyr2 || yy2arr2 {
 34049  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 34050  				yym10 := z.EncBinary()
 34051  				_ = yym10
 34052  				if false {
 34053  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 34054  				} else {
 34055  					r.EncodeInt(int64(x.LastContact))
 34056  				}
 34057  			} else {
 34058  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 34059  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 34060  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 34061  				yym11 := z.EncBinary()
 34062  				_ = yym11
 34063  				if false {
 34064  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 34065  				} else {
 34066  					r.EncodeInt(int64(x.LastContact))
 34067  				}
 34068  			}
 34069  			if yyr2 || yy2arr2 {
 34070  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 34071  				yym13 := z.EncBinary()
 34072  				_ = yym13
 34073  				if false {
 34074  				} else {
 34075  					r.EncodeBool(bool(x.KnownLeader))
 34076  				}
 34077  			} else {
 34078  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 34079  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 34080  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 34081  				yym14 := z.EncBinary()
 34082  				_ = yym14
 34083  				if false {
 34084  				} else {
 34085  					r.EncodeBool(bool(x.KnownLeader))
 34086  				}
 34087  			}
 34088  			if yyr2 || yy2arr2 {
 34089  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 34090  			} else {
 34091  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 34092  			}
 34093  		}
 34094  	}
 34095  }
 34096  
 34097  func (x *SingleNodeResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 34098  	var h codecSelfer100
 34099  	z, r := codec1978.GenHelperDecoder(d)
 34100  	_, _, _ = h, z, r
 34101  	yym1 := z.DecBinary()
 34102  	_ = yym1
 34103  	if false {
 34104  	} else if z.HasExtensions() && z.DecExt(x) {
 34105  	} else {
 34106  		yyct2 := r.ContainerType()
 34107  		if yyct2 == codecSelferValueTypeMap100 {
 34108  			yyl2 := r.ReadMapStart()
 34109  			if yyl2 == 0 {
 34110  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 34111  			} else {
 34112  				x.codecDecodeSelfFromMap(yyl2, d)
 34113  			}
 34114  		} else if yyct2 == codecSelferValueTypeArray100 {
 34115  			yyl2 := r.ReadArrayStart()
 34116  			if yyl2 == 0 {
 34117  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34118  			} else {
 34119  				x.codecDecodeSelfFromArray(yyl2, d)
 34120  			}
 34121  		} else {
 34122  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 34123  		}
 34124  	}
 34125  }
 34126  
 34127  func (x *SingleNodeResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 34128  	var h codecSelfer100
 34129  	z, r := codec1978.GenHelperDecoder(d)
 34130  	_, _, _ = h, z, r
 34131  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 34132  	_ = yys3Slc
 34133  	var yyhl3 bool = l >= 0
 34134  	for yyj3 := 0; ; yyj3++ {
 34135  		if yyhl3 {
 34136  			if yyj3 >= l {
 34137  				break
 34138  			}
 34139  		} else {
 34140  			if r.CheckBreak() {
 34141  				break
 34142  			}
 34143  		}
 34144  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 34145  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 34146  		yys3 := string(yys3Slc)
 34147  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 34148  		switch yys3 {
 34149  		case "Node":
 34150  			if r.TryDecodeAsNil() {
 34151  				if x.Node != nil {
 34152  					x.Node = nil
 34153  				}
 34154  			} else {
 34155  				if x.Node == nil {
 34156  					x.Node = new(Node)
 34157  				}
 34158  				x.Node.CodecDecodeSelf(d)
 34159  			}
 34160  		case "Index":
 34161  			if r.TryDecodeAsNil() {
 34162  				x.Index = 0
 34163  			} else {
 34164  				yyv5 := &x.Index
 34165  				yym6 := z.DecBinary()
 34166  				_ = yym6
 34167  				if false {
 34168  				} else {
 34169  					*((*uint64)(yyv5)) = uint64(r.DecodeUint(64))
 34170  				}
 34171  			}
 34172  		case "LastContact":
 34173  			if r.TryDecodeAsNil() {
 34174  				x.LastContact = 0
 34175  			} else {
 34176  				yyv7 := &x.LastContact
 34177  				yym8 := z.DecBinary()
 34178  				_ = yym8
 34179  				if false {
 34180  				} else if z.HasExtensions() && z.DecExt(yyv7) {
 34181  				} else {
 34182  					*((*int64)(yyv7)) = int64(r.DecodeInt(64))
 34183  				}
 34184  			}
 34185  		case "KnownLeader":
 34186  			if r.TryDecodeAsNil() {
 34187  				x.KnownLeader = false
 34188  			} else {
 34189  				yyv9 := &x.KnownLeader
 34190  				yym10 := z.DecBinary()
 34191  				_ = yym10
 34192  				if false {
 34193  				} else {
 34194  					*((*bool)(yyv9)) = r.DecodeBool()
 34195  				}
 34196  			}
 34197  		default:
 34198  			z.DecStructFieldNotFound(-1, yys3)
 34199  		} // end switch yys3
 34200  	} // end for yyj3
 34201  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 34202  }
 34203  
 34204  func (x *SingleNodeResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 34205  	var h codecSelfer100
 34206  	z, r := codec1978.GenHelperDecoder(d)
 34207  	_, _, _ = h, z, r
 34208  	var yyj11 int
 34209  	var yyb11 bool
 34210  	var yyhl11 bool = l >= 0
 34211  	yyj11++
 34212  	if yyhl11 {
 34213  		yyb11 = yyj11 > l
 34214  	} else {
 34215  		yyb11 = r.CheckBreak()
 34216  	}
 34217  	if yyb11 {
 34218  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34219  		return
 34220  	}
 34221  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 34222  	if r.TryDecodeAsNil() {
 34223  		if x.Node != nil {
 34224  			x.Node = nil
 34225  		}
 34226  	} else {
 34227  		if x.Node == nil {
 34228  			x.Node = new(Node)
 34229  		}
 34230  		x.Node.CodecDecodeSelf(d)
 34231  	}
 34232  	yyj11++
 34233  	if yyhl11 {
 34234  		yyb11 = yyj11 > l
 34235  	} else {
 34236  		yyb11 = r.CheckBreak()
 34237  	}
 34238  	if yyb11 {
 34239  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34240  		return
 34241  	}
 34242  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 34243  	if r.TryDecodeAsNil() {
 34244  		x.Index = 0
 34245  	} else {
 34246  		yyv13 := &x.Index
 34247  		yym14 := z.DecBinary()
 34248  		_ = yym14
 34249  		if false {
 34250  		} else {
 34251  			*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 34252  		}
 34253  	}
 34254  	yyj11++
 34255  	if yyhl11 {
 34256  		yyb11 = yyj11 > l
 34257  	} else {
 34258  		yyb11 = r.CheckBreak()
 34259  	}
 34260  	if yyb11 {
 34261  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34262  		return
 34263  	}
 34264  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 34265  	if r.TryDecodeAsNil() {
 34266  		x.LastContact = 0
 34267  	} else {
 34268  		yyv15 := &x.LastContact
 34269  		yym16 := z.DecBinary()
 34270  		_ = yym16
 34271  		if false {
 34272  		} else if z.HasExtensions() && z.DecExt(yyv15) {
 34273  		} else {
 34274  			*((*int64)(yyv15)) = int64(r.DecodeInt(64))
 34275  		}
 34276  	}
 34277  	yyj11++
 34278  	if yyhl11 {
 34279  		yyb11 = yyj11 > l
 34280  	} else {
 34281  		yyb11 = r.CheckBreak()
 34282  	}
 34283  	if yyb11 {
 34284  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34285  		return
 34286  	}
 34287  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 34288  	if r.TryDecodeAsNil() {
 34289  		x.KnownLeader = false
 34290  	} else {
 34291  		yyv17 := &x.KnownLeader
 34292  		yym18 := z.DecBinary()
 34293  		_ = yym18
 34294  		if false {
 34295  		} else {
 34296  			*((*bool)(yyv17)) = r.DecodeBool()
 34297  		}
 34298  	}
 34299  	for {
 34300  		yyj11++
 34301  		if yyhl11 {
 34302  			yyb11 = yyj11 > l
 34303  		} else {
 34304  			yyb11 = r.CheckBreak()
 34305  		}
 34306  		if yyb11 {
 34307  			break
 34308  		}
 34309  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 34310  		z.DecStructFieldNotFound(yyj11-1, "")
 34311  	}
 34312  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34313  }
 34314  
 34315  func (x *NodeListResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 34316  	var h codecSelfer100
 34317  	z, r := codec1978.GenHelperEncoder(e)
 34318  	_, _, _ = h, z, r
 34319  	if x == nil {
 34320  		r.EncodeNil()
 34321  	} else {
 34322  		yym1 := z.EncBinary()
 34323  		_ = yym1
 34324  		if false {
 34325  		} else if z.HasExtensions() && z.EncExt(x) {
 34326  		} else {
 34327  			yysep2 := !z.EncBinary()
 34328  			yy2arr2 := z.EncBasicHandle().StructToArray
 34329  			var yyq2 [4]bool
 34330  			_, _, _ = yysep2, yyq2, yy2arr2
 34331  			const yyr2 bool = false
 34332  			var yynn2 int
 34333  			if yyr2 || yy2arr2 {
 34334  				r.EncodeArrayStart(4)
 34335  			} else {
 34336  				yynn2 = 4
 34337  				for _, b := range yyq2 {
 34338  					if b {
 34339  						yynn2++
 34340  					}
 34341  				}
 34342  				r.EncodeMapStart(yynn2)
 34343  				yynn2 = 0
 34344  			}
 34345  			if yyr2 || yy2arr2 {
 34346  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 34347  				if x.Nodes == nil {
 34348  					r.EncodeNil()
 34349  				} else {
 34350  					yym4 := z.EncBinary()
 34351  					_ = yym4
 34352  					if false {
 34353  					} else {
 34354  						h.encSlicePtrtoNodeListStub(([]*NodeListStub)(x.Nodes), e)
 34355  					}
 34356  				}
 34357  			} else {
 34358  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 34359  				r.EncodeString(codecSelferC_UTF8100, string("Nodes"))
 34360  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 34361  				if x.Nodes == nil {
 34362  					r.EncodeNil()
 34363  				} else {
 34364  					yym5 := z.EncBinary()
 34365  					_ = yym5
 34366  					if false {
 34367  					} else {
 34368  						h.encSlicePtrtoNodeListStub(([]*NodeListStub)(x.Nodes), e)
 34369  					}
 34370  				}
 34371  			}
 34372  			if yyr2 || yy2arr2 {
 34373  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 34374  				yym7 := z.EncBinary()
 34375  				_ = yym7
 34376  				if false {
 34377  				} else {
 34378  					r.EncodeUint(uint64(x.Index))
 34379  				}
 34380  			} else {
 34381  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 34382  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 34383  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 34384  				yym8 := z.EncBinary()
 34385  				_ = yym8
 34386  				if false {
 34387  				} else {
 34388  					r.EncodeUint(uint64(x.Index))
 34389  				}
 34390  			}
 34391  			if yyr2 || yy2arr2 {
 34392  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 34393  				yym10 := z.EncBinary()
 34394  				_ = yym10
 34395  				if false {
 34396  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 34397  				} else {
 34398  					r.EncodeInt(int64(x.LastContact))
 34399  				}
 34400  			} else {
 34401  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 34402  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 34403  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 34404  				yym11 := z.EncBinary()
 34405  				_ = yym11
 34406  				if false {
 34407  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 34408  				} else {
 34409  					r.EncodeInt(int64(x.LastContact))
 34410  				}
 34411  			}
 34412  			if yyr2 || yy2arr2 {
 34413  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 34414  				yym13 := z.EncBinary()
 34415  				_ = yym13
 34416  				if false {
 34417  				} else {
 34418  					r.EncodeBool(bool(x.KnownLeader))
 34419  				}
 34420  			} else {
 34421  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 34422  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 34423  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 34424  				yym14 := z.EncBinary()
 34425  				_ = yym14
 34426  				if false {
 34427  				} else {
 34428  					r.EncodeBool(bool(x.KnownLeader))
 34429  				}
 34430  			}
 34431  			if yyr2 || yy2arr2 {
 34432  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 34433  			} else {
 34434  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 34435  			}
 34436  		}
 34437  	}
 34438  }
 34439  
 34440  func (x *NodeListResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 34441  	var h codecSelfer100
 34442  	z, r := codec1978.GenHelperDecoder(d)
 34443  	_, _, _ = h, z, r
 34444  	yym1 := z.DecBinary()
 34445  	_ = yym1
 34446  	if false {
 34447  	} else if z.HasExtensions() && z.DecExt(x) {
 34448  	} else {
 34449  		yyct2 := r.ContainerType()
 34450  		if yyct2 == codecSelferValueTypeMap100 {
 34451  			yyl2 := r.ReadMapStart()
 34452  			if yyl2 == 0 {
 34453  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 34454  			} else {
 34455  				x.codecDecodeSelfFromMap(yyl2, d)
 34456  			}
 34457  		} else if yyct2 == codecSelferValueTypeArray100 {
 34458  			yyl2 := r.ReadArrayStart()
 34459  			if yyl2 == 0 {
 34460  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34461  			} else {
 34462  				x.codecDecodeSelfFromArray(yyl2, d)
 34463  			}
 34464  		} else {
 34465  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 34466  		}
 34467  	}
 34468  }
 34469  
 34470  func (x *NodeListResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 34471  	var h codecSelfer100
 34472  	z, r := codec1978.GenHelperDecoder(d)
 34473  	_, _, _ = h, z, r
 34474  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 34475  	_ = yys3Slc
 34476  	var yyhl3 bool = l >= 0
 34477  	for yyj3 := 0; ; yyj3++ {
 34478  		if yyhl3 {
 34479  			if yyj3 >= l {
 34480  				break
 34481  			}
 34482  		} else {
 34483  			if r.CheckBreak() {
 34484  				break
 34485  			}
 34486  		}
 34487  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 34488  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 34489  		yys3 := string(yys3Slc)
 34490  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 34491  		switch yys3 {
 34492  		case "Nodes":
 34493  			if r.TryDecodeAsNil() {
 34494  				x.Nodes = nil
 34495  			} else {
 34496  				yyv4 := &x.Nodes
 34497  				yym5 := z.DecBinary()
 34498  				_ = yym5
 34499  				if false {
 34500  				} else {
 34501  					h.decSlicePtrtoNodeListStub((*[]*NodeListStub)(yyv4), d)
 34502  				}
 34503  			}
 34504  		case "Index":
 34505  			if r.TryDecodeAsNil() {
 34506  				x.Index = 0
 34507  			} else {
 34508  				yyv6 := &x.Index
 34509  				yym7 := z.DecBinary()
 34510  				_ = yym7
 34511  				if false {
 34512  				} else {
 34513  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 34514  				}
 34515  			}
 34516  		case "LastContact":
 34517  			if r.TryDecodeAsNil() {
 34518  				x.LastContact = 0
 34519  			} else {
 34520  				yyv8 := &x.LastContact
 34521  				yym9 := z.DecBinary()
 34522  				_ = yym9
 34523  				if false {
 34524  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 34525  				} else {
 34526  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 34527  				}
 34528  			}
 34529  		case "KnownLeader":
 34530  			if r.TryDecodeAsNil() {
 34531  				x.KnownLeader = false
 34532  			} else {
 34533  				yyv10 := &x.KnownLeader
 34534  				yym11 := z.DecBinary()
 34535  				_ = yym11
 34536  				if false {
 34537  				} else {
 34538  					*((*bool)(yyv10)) = r.DecodeBool()
 34539  				}
 34540  			}
 34541  		default:
 34542  			z.DecStructFieldNotFound(-1, yys3)
 34543  		} // end switch yys3
 34544  	} // end for yyj3
 34545  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 34546  }
 34547  
 34548  func (x *NodeListResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 34549  	var h codecSelfer100
 34550  	z, r := codec1978.GenHelperDecoder(d)
 34551  	_, _, _ = h, z, r
 34552  	var yyj12 int
 34553  	var yyb12 bool
 34554  	var yyhl12 bool = l >= 0
 34555  	yyj12++
 34556  	if yyhl12 {
 34557  		yyb12 = yyj12 > l
 34558  	} else {
 34559  		yyb12 = r.CheckBreak()
 34560  	}
 34561  	if yyb12 {
 34562  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34563  		return
 34564  	}
 34565  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 34566  	if r.TryDecodeAsNil() {
 34567  		x.Nodes = nil
 34568  	} else {
 34569  		yyv13 := &x.Nodes
 34570  		yym14 := z.DecBinary()
 34571  		_ = yym14
 34572  		if false {
 34573  		} else {
 34574  			h.decSlicePtrtoNodeListStub((*[]*NodeListStub)(yyv13), d)
 34575  		}
 34576  	}
 34577  	yyj12++
 34578  	if yyhl12 {
 34579  		yyb12 = yyj12 > l
 34580  	} else {
 34581  		yyb12 = r.CheckBreak()
 34582  	}
 34583  	if yyb12 {
 34584  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34585  		return
 34586  	}
 34587  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 34588  	if r.TryDecodeAsNil() {
 34589  		x.Index = 0
 34590  	} else {
 34591  		yyv15 := &x.Index
 34592  		yym16 := z.DecBinary()
 34593  		_ = yym16
 34594  		if false {
 34595  		} else {
 34596  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 34597  		}
 34598  	}
 34599  	yyj12++
 34600  	if yyhl12 {
 34601  		yyb12 = yyj12 > l
 34602  	} else {
 34603  		yyb12 = r.CheckBreak()
 34604  	}
 34605  	if yyb12 {
 34606  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34607  		return
 34608  	}
 34609  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 34610  	if r.TryDecodeAsNil() {
 34611  		x.LastContact = 0
 34612  	} else {
 34613  		yyv17 := &x.LastContact
 34614  		yym18 := z.DecBinary()
 34615  		_ = yym18
 34616  		if false {
 34617  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 34618  		} else {
 34619  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 34620  		}
 34621  	}
 34622  	yyj12++
 34623  	if yyhl12 {
 34624  		yyb12 = yyj12 > l
 34625  	} else {
 34626  		yyb12 = r.CheckBreak()
 34627  	}
 34628  	if yyb12 {
 34629  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34630  		return
 34631  	}
 34632  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 34633  	if r.TryDecodeAsNil() {
 34634  		x.KnownLeader = false
 34635  	} else {
 34636  		yyv19 := &x.KnownLeader
 34637  		yym20 := z.DecBinary()
 34638  		_ = yym20
 34639  		if false {
 34640  		} else {
 34641  			*((*bool)(yyv19)) = r.DecodeBool()
 34642  		}
 34643  	}
 34644  	for {
 34645  		yyj12++
 34646  		if yyhl12 {
 34647  			yyb12 = yyj12 > l
 34648  		} else {
 34649  			yyb12 = r.CheckBreak()
 34650  		}
 34651  		if yyb12 {
 34652  			break
 34653  		}
 34654  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 34655  		z.DecStructFieldNotFound(yyj12-1, "")
 34656  	}
 34657  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34658  }
 34659  
 34660  func (x *SingleJobResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 34661  	var h codecSelfer100
 34662  	z, r := codec1978.GenHelperEncoder(e)
 34663  	_, _, _ = h, z, r
 34664  	if x == nil {
 34665  		r.EncodeNil()
 34666  	} else {
 34667  		yym1 := z.EncBinary()
 34668  		_ = yym1
 34669  		if false {
 34670  		} else if z.HasExtensions() && z.EncExt(x) {
 34671  		} else {
 34672  			yysep2 := !z.EncBinary()
 34673  			yy2arr2 := z.EncBasicHandle().StructToArray
 34674  			var yyq2 [4]bool
 34675  			_, _, _ = yysep2, yyq2, yy2arr2
 34676  			const yyr2 bool = false
 34677  			var yynn2 int
 34678  			if yyr2 || yy2arr2 {
 34679  				r.EncodeArrayStart(4)
 34680  			} else {
 34681  				yynn2 = 4
 34682  				for _, b := range yyq2 {
 34683  					if b {
 34684  						yynn2++
 34685  					}
 34686  				}
 34687  				r.EncodeMapStart(yynn2)
 34688  				yynn2 = 0
 34689  			}
 34690  			if yyr2 || yy2arr2 {
 34691  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 34692  				if x.Job == nil {
 34693  					r.EncodeNil()
 34694  				} else {
 34695  					x.Job.CodecEncodeSelf(e)
 34696  				}
 34697  			} else {
 34698  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 34699  				r.EncodeString(codecSelferC_UTF8100, string("Job"))
 34700  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 34701  				if x.Job == nil {
 34702  					r.EncodeNil()
 34703  				} else {
 34704  					x.Job.CodecEncodeSelf(e)
 34705  				}
 34706  			}
 34707  			if yyr2 || yy2arr2 {
 34708  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 34709  				yym7 := z.EncBinary()
 34710  				_ = yym7
 34711  				if false {
 34712  				} else {
 34713  					r.EncodeUint(uint64(x.Index))
 34714  				}
 34715  			} else {
 34716  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 34717  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 34718  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 34719  				yym8 := z.EncBinary()
 34720  				_ = yym8
 34721  				if false {
 34722  				} else {
 34723  					r.EncodeUint(uint64(x.Index))
 34724  				}
 34725  			}
 34726  			if yyr2 || yy2arr2 {
 34727  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 34728  				yym10 := z.EncBinary()
 34729  				_ = yym10
 34730  				if false {
 34731  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 34732  				} else {
 34733  					r.EncodeInt(int64(x.LastContact))
 34734  				}
 34735  			} else {
 34736  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 34737  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 34738  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 34739  				yym11 := z.EncBinary()
 34740  				_ = yym11
 34741  				if false {
 34742  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 34743  				} else {
 34744  					r.EncodeInt(int64(x.LastContact))
 34745  				}
 34746  			}
 34747  			if yyr2 || yy2arr2 {
 34748  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 34749  				yym13 := z.EncBinary()
 34750  				_ = yym13
 34751  				if false {
 34752  				} else {
 34753  					r.EncodeBool(bool(x.KnownLeader))
 34754  				}
 34755  			} else {
 34756  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 34757  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 34758  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 34759  				yym14 := z.EncBinary()
 34760  				_ = yym14
 34761  				if false {
 34762  				} else {
 34763  					r.EncodeBool(bool(x.KnownLeader))
 34764  				}
 34765  			}
 34766  			if yyr2 || yy2arr2 {
 34767  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 34768  			} else {
 34769  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 34770  			}
 34771  		}
 34772  	}
 34773  }
 34774  
 34775  func (x *SingleJobResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 34776  	var h codecSelfer100
 34777  	z, r := codec1978.GenHelperDecoder(d)
 34778  	_, _, _ = h, z, r
 34779  	yym1 := z.DecBinary()
 34780  	_ = yym1
 34781  	if false {
 34782  	} else if z.HasExtensions() && z.DecExt(x) {
 34783  	} else {
 34784  		yyct2 := r.ContainerType()
 34785  		if yyct2 == codecSelferValueTypeMap100 {
 34786  			yyl2 := r.ReadMapStart()
 34787  			if yyl2 == 0 {
 34788  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 34789  			} else {
 34790  				x.codecDecodeSelfFromMap(yyl2, d)
 34791  			}
 34792  		} else if yyct2 == codecSelferValueTypeArray100 {
 34793  			yyl2 := r.ReadArrayStart()
 34794  			if yyl2 == 0 {
 34795  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34796  			} else {
 34797  				x.codecDecodeSelfFromArray(yyl2, d)
 34798  			}
 34799  		} else {
 34800  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 34801  		}
 34802  	}
 34803  }
 34804  
 34805  func (x *SingleJobResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 34806  	var h codecSelfer100
 34807  	z, r := codec1978.GenHelperDecoder(d)
 34808  	_, _, _ = h, z, r
 34809  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 34810  	_ = yys3Slc
 34811  	var yyhl3 bool = l >= 0
 34812  	for yyj3 := 0; ; yyj3++ {
 34813  		if yyhl3 {
 34814  			if yyj3 >= l {
 34815  				break
 34816  			}
 34817  		} else {
 34818  			if r.CheckBreak() {
 34819  				break
 34820  			}
 34821  		}
 34822  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 34823  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 34824  		yys3 := string(yys3Slc)
 34825  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 34826  		switch yys3 {
 34827  		case "Job":
 34828  			if r.TryDecodeAsNil() {
 34829  				if x.Job != nil {
 34830  					x.Job = nil
 34831  				}
 34832  			} else {
 34833  				if x.Job == nil {
 34834  					x.Job = new(Job)
 34835  				}
 34836  				x.Job.CodecDecodeSelf(d)
 34837  			}
 34838  		case "Index":
 34839  			if r.TryDecodeAsNil() {
 34840  				x.Index = 0
 34841  			} else {
 34842  				yyv5 := &x.Index
 34843  				yym6 := z.DecBinary()
 34844  				_ = yym6
 34845  				if false {
 34846  				} else {
 34847  					*((*uint64)(yyv5)) = uint64(r.DecodeUint(64))
 34848  				}
 34849  			}
 34850  		case "LastContact":
 34851  			if r.TryDecodeAsNil() {
 34852  				x.LastContact = 0
 34853  			} else {
 34854  				yyv7 := &x.LastContact
 34855  				yym8 := z.DecBinary()
 34856  				_ = yym8
 34857  				if false {
 34858  				} else if z.HasExtensions() && z.DecExt(yyv7) {
 34859  				} else {
 34860  					*((*int64)(yyv7)) = int64(r.DecodeInt(64))
 34861  				}
 34862  			}
 34863  		case "KnownLeader":
 34864  			if r.TryDecodeAsNil() {
 34865  				x.KnownLeader = false
 34866  			} else {
 34867  				yyv9 := &x.KnownLeader
 34868  				yym10 := z.DecBinary()
 34869  				_ = yym10
 34870  				if false {
 34871  				} else {
 34872  					*((*bool)(yyv9)) = r.DecodeBool()
 34873  				}
 34874  			}
 34875  		default:
 34876  			z.DecStructFieldNotFound(-1, yys3)
 34877  		} // end switch yys3
 34878  	} // end for yyj3
 34879  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 34880  }
 34881  
 34882  func (x *SingleJobResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 34883  	var h codecSelfer100
 34884  	z, r := codec1978.GenHelperDecoder(d)
 34885  	_, _, _ = h, z, r
 34886  	var yyj11 int
 34887  	var yyb11 bool
 34888  	var yyhl11 bool = l >= 0
 34889  	yyj11++
 34890  	if yyhl11 {
 34891  		yyb11 = yyj11 > l
 34892  	} else {
 34893  		yyb11 = r.CheckBreak()
 34894  	}
 34895  	if yyb11 {
 34896  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34897  		return
 34898  	}
 34899  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 34900  	if r.TryDecodeAsNil() {
 34901  		if x.Job != nil {
 34902  			x.Job = nil
 34903  		}
 34904  	} else {
 34905  		if x.Job == nil {
 34906  			x.Job = new(Job)
 34907  		}
 34908  		x.Job.CodecDecodeSelf(d)
 34909  	}
 34910  	yyj11++
 34911  	if yyhl11 {
 34912  		yyb11 = yyj11 > l
 34913  	} else {
 34914  		yyb11 = r.CheckBreak()
 34915  	}
 34916  	if yyb11 {
 34917  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34918  		return
 34919  	}
 34920  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 34921  	if r.TryDecodeAsNil() {
 34922  		x.Index = 0
 34923  	} else {
 34924  		yyv13 := &x.Index
 34925  		yym14 := z.DecBinary()
 34926  		_ = yym14
 34927  		if false {
 34928  		} else {
 34929  			*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 34930  		}
 34931  	}
 34932  	yyj11++
 34933  	if yyhl11 {
 34934  		yyb11 = yyj11 > l
 34935  	} else {
 34936  		yyb11 = r.CheckBreak()
 34937  	}
 34938  	if yyb11 {
 34939  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34940  		return
 34941  	}
 34942  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 34943  	if r.TryDecodeAsNil() {
 34944  		x.LastContact = 0
 34945  	} else {
 34946  		yyv15 := &x.LastContact
 34947  		yym16 := z.DecBinary()
 34948  		_ = yym16
 34949  		if false {
 34950  		} else if z.HasExtensions() && z.DecExt(yyv15) {
 34951  		} else {
 34952  			*((*int64)(yyv15)) = int64(r.DecodeInt(64))
 34953  		}
 34954  	}
 34955  	yyj11++
 34956  	if yyhl11 {
 34957  		yyb11 = yyj11 > l
 34958  	} else {
 34959  		yyb11 = r.CheckBreak()
 34960  	}
 34961  	if yyb11 {
 34962  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34963  		return
 34964  	}
 34965  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 34966  	if r.TryDecodeAsNil() {
 34967  		x.KnownLeader = false
 34968  	} else {
 34969  		yyv17 := &x.KnownLeader
 34970  		yym18 := z.DecBinary()
 34971  		_ = yym18
 34972  		if false {
 34973  		} else {
 34974  			*((*bool)(yyv17)) = r.DecodeBool()
 34975  		}
 34976  	}
 34977  	for {
 34978  		yyj11++
 34979  		if yyhl11 {
 34980  			yyb11 = yyj11 > l
 34981  		} else {
 34982  			yyb11 = r.CheckBreak()
 34983  		}
 34984  		if yyb11 {
 34985  			break
 34986  		}
 34987  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 34988  		z.DecStructFieldNotFound(yyj11-1, "")
 34989  	}
 34990  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 34991  }
 34992  
 34993  func (x *JobSummaryResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 34994  	var h codecSelfer100
 34995  	z, r := codec1978.GenHelperEncoder(e)
 34996  	_, _, _ = h, z, r
 34997  	if x == nil {
 34998  		r.EncodeNil()
 34999  	} else {
 35000  		yym1 := z.EncBinary()
 35001  		_ = yym1
 35002  		if false {
 35003  		} else if z.HasExtensions() && z.EncExt(x) {
 35004  		} else {
 35005  			yysep2 := !z.EncBinary()
 35006  			yy2arr2 := z.EncBasicHandle().StructToArray
 35007  			var yyq2 [4]bool
 35008  			_, _, _ = yysep2, yyq2, yy2arr2
 35009  			const yyr2 bool = false
 35010  			var yynn2 int
 35011  			if yyr2 || yy2arr2 {
 35012  				r.EncodeArrayStart(4)
 35013  			} else {
 35014  				yynn2 = 4
 35015  				for _, b := range yyq2 {
 35016  					if b {
 35017  						yynn2++
 35018  					}
 35019  				}
 35020  				r.EncodeMapStart(yynn2)
 35021  				yynn2 = 0
 35022  			}
 35023  			if yyr2 || yy2arr2 {
 35024  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 35025  				if x.JobSummary == nil {
 35026  					r.EncodeNil()
 35027  				} else {
 35028  					x.JobSummary.CodecEncodeSelf(e)
 35029  				}
 35030  			} else {
 35031  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 35032  				r.EncodeString(codecSelferC_UTF8100, string("JobSummary"))
 35033  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 35034  				if x.JobSummary == nil {
 35035  					r.EncodeNil()
 35036  				} else {
 35037  					x.JobSummary.CodecEncodeSelf(e)
 35038  				}
 35039  			}
 35040  			if yyr2 || yy2arr2 {
 35041  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 35042  				yym7 := z.EncBinary()
 35043  				_ = yym7
 35044  				if false {
 35045  				} else {
 35046  					r.EncodeUint(uint64(x.Index))
 35047  				}
 35048  			} else {
 35049  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 35050  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 35051  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 35052  				yym8 := z.EncBinary()
 35053  				_ = yym8
 35054  				if false {
 35055  				} else {
 35056  					r.EncodeUint(uint64(x.Index))
 35057  				}
 35058  			}
 35059  			if yyr2 || yy2arr2 {
 35060  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 35061  				yym10 := z.EncBinary()
 35062  				_ = yym10
 35063  				if false {
 35064  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 35065  				} else {
 35066  					r.EncodeInt(int64(x.LastContact))
 35067  				}
 35068  			} else {
 35069  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 35070  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 35071  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 35072  				yym11 := z.EncBinary()
 35073  				_ = yym11
 35074  				if false {
 35075  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 35076  				} else {
 35077  					r.EncodeInt(int64(x.LastContact))
 35078  				}
 35079  			}
 35080  			if yyr2 || yy2arr2 {
 35081  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 35082  				yym13 := z.EncBinary()
 35083  				_ = yym13
 35084  				if false {
 35085  				} else {
 35086  					r.EncodeBool(bool(x.KnownLeader))
 35087  				}
 35088  			} else {
 35089  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 35090  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 35091  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 35092  				yym14 := z.EncBinary()
 35093  				_ = yym14
 35094  				if false {
 35095  				} else {
 35096  					r.EncodeBool(bool(x.KnownLeader))
 35097  				}
 35098  			}
 35099  			if yyr2 || yy2arr2 {
 35100  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 35101  			} else {
 35102  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 35103  			}
 35104  		}
 35105  	}
 35106  }
 35107  
 35108  func (x *JobSummaryResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 35109  	var h codecSelfer100
 35110  	z, r := codec1978.GenHelperDecoder(d)
 35111  	_, _, _ = h, z, r
 35112  	yym1 := z.DecBinary()
 35113  	_ = yym1
 35114  	if false {
 35115  	} else if z.HasExtensions() && z.DecExt(x) {
 35116  	} else {
 35117  		yyct2 := r.ContainerType()
 35118  		if yyct2 == codecSelferValueTypeMap100 {
 35119  			yyl2 := r.ReadMapStart()
 35120  			if yyl2 == 0 {
 35121  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 35122  			} else {
 35123  				x.codecDecodeSelfFromMap(yyl2, d)
 35124  			}
 35125  		} else if yyct2 == codecSelferValueTypeArray100 {
 35126  			yyl2 := r.ReadArrayStart()
 35127  			if yyl2 == 0 {
 35128  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35129  			} else {
 35130  				x.codecDecodeSelfFromArray(yyl2, d)
 35131  			}
 35132  		} else {
 35133  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 35134  		}
 35135  	}
 35136  }
 35137  
 35138  func (x *JobSummaryResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 35139  	var h codecSelfer100
 35140  	z, r := codec1978.GenHelperDecoder(d)
 35141  	_, _, _ = h, z, r
 35142  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 35143  	_ = yys3Slc
 35144  	var yyhl3 bool = l >= 0
 35145  	for yyj3 := 0; ; yyj3++ {
 35146  		if yyhl3 {
 35147  			if yyj3 >= l {
 35148  				break
 35149  			}
 35150  		} else {
 35151  			if r.CheckBreak() {
 35152  				break
 35153  			}
 35154  		}
 35155  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 35156  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 35157  		yys3 := string(yys3Slc)
 35158  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 35159  		switch yys3 {
 35160  		case "JobSummary":
 35161  			if r.TryDecodeAsNil() {
 35162  				if x.JobSummary != nil {
 35163  					x.JobSummary = nil
 35164  				}
 35165  			} else {
 35166  				if x.JobSummary == nil {
 35167  					x.JobSummary = new(JobSummary)
 35168  				}
 35169  				x.JobSummary.CodecDecodeSelf(d)
 35170  			}
 35171  		case "Index":
 35172  			if r.TryDecodeAsNil() {
 35173  				x.Index = 0
 35174  			} else {
 35175  				yyv5 := &x.Index
 35176  				yym6 := z.DecBinary()
 35177  				_ = yym6
 35178  				if false {
 35179  				} else {
 35180  					*((*uint64)(yyv5)) = uint64(r.DecodeUint(64))
 35181  				}
 35182  			}
 35183  		case "LastContact":
 35184  			if r.TryDecodeAsNil() {
 35185  				x.LastContact = 0
 35186  			} else {
 35187  				yyv7 := &x.LastContact
 35188  				yym8 := z.DecBinary()
 35189  				_ = yym8
 35190  				if false {
 35191  				} else if z.HasExtensions() && z.DecExt(yyv7) {
 35192  				} else {
 35193  					*((*int64)(yyv7)) = int64(r.DecodeInt(64))
 35194  				}
 35195  			}
 35196  		case "KnownLeader":
 35197  			if r.TryDecodeAsNil() {
 35198  				x.KnownLeader = false
 35199  			} else {
 35200  				yyv9 := &x.KnownLeader
 35201  				yym10 := z.DecBinary()
 35202  				_ = yym10
 35203  				if false {
 35204  				} else {
 35205  					*((*bool)(yyv9)) = r.DecodeBool()
 35206  				}
 35207  			}
 35208  		default:
 35209  			z.DecStructFieldNotFound(-1, yys3)
 35210  		} // end switch yys3
 35211  	} // end for yyj3
 35212  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 35213  }
 35214  
 35215  func (x *JobSummaryResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 35216  	var h codecSelfer100
 35217  	z, r := codec1978.GenHelperDecoder(d)
 35218  	_, _, _ = h, z, r
 35219  	var yyj11 int
 35220  	var yyb11 bool
 35221  	var yyhl11 bool = l >= 0
 35222  	yyj11++
 35223  	if yyhl11 {
 35224  		yyb11 = yyj11 > l
 35225  	} else {
 35226  		yyb11 = r.CheckBreak()
 35227  	}
 35228  	if yyb11 {
 35229  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35230  		return
 35231  	}
 35232  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 35233  	if r.TryDecodeAsNil() {
 35234  		if x.JobSummary != nil {
 35235  			x.JobSummary = nil
 35236  		}
 35237  	} else {
 35238  		if x.JobSummary == nil {
 35239  			x.JobSummary = new(JobSummary)
 35240  		}
 35241  		x.JobSummary.CodecDecodeSelf(d)
 35242  	}
 35243  	yyj11++
 35244  	if yyhl11 {
 35245  		yyb11 = yyj11 > l
 35246  	} else {
 35247  		yyb11 = r.CheckBreak()
 35248  	}
 35249  	if yyb11 {
 35250  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35251  		return
 35252  	}
 35253  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 35254  	if r.TryDecodeAsNil() {
 35255  		x.Index = 0
 35256  	} else {
 35257  		yyv13 := &x.Index
 35258  		yym14 := z.DecBinary()
 35259  		_ = yym14
 35260  		if false {
 35261  		} else {
 35262  			*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 35263  		}
 35264  	}
 35265  	yyj11++
 35266  	if yyhl11 {
 35267  		yyb11 = yyj11 > l
 35268  	} else {
 35269  		yyb11 = r.CheckBreak()
 35270  	}
 35271  	if yyb11 {
 35272  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35273  		return
 35274  	}
 35275  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 35276  	if r.TryDecodeAsNil() {
 35277  		x.LastContact = 0
 35278  	} else {
 35279  		yyv15 := &x.LastContact
 35280  		yym16 := z.DecBinary()
 35281  		_ = yym16
 35282  		if false {
 35283  		} else if z.HasExtensions() && z.DecExt(yyv15) {
 35284  		} else {
 35285  			*((*int64)(yyv15)) = int64(r.DecodeInt(64))
 35286  		}
 35287  	}
 35288  	yyj11++
 35289  	if yyhl11 {
 35290  		yyb11 = yyj11 > l
 35291  	} else {
 35292  		yyb11 = r.CheckBreak()
 35293  	}
 35294  	if yyb11 {
 35295  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35296  		return
 35297  	}
 35298  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 35299  	if r.TryDecodeAsNil() {
 35300  		x.KnownLeader = false
 35301  	} else {
 35302  		yyv17 := &x.KnownLeader
 35303  		yym18 := z.DecBinary()
 35304  		_ = yym18
 35305  		if false {
 35306  		} else {
 35307  			*((*bool)(yyv17)) = r.DecodeBool()
 35308  		}
 35309  	}
 35310  	for {
 35311  		yyj11++
 35312  		if yyhl11 {
 35313  			yyb11 = yyj11 > l
 35314  		} else {
 35315  			yyb11 = r.CheckBreak()
 35316  		}
 35317  		if yyb11 {
 35318  			break
 35319  		}
 35320  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 35321  		z.DecStructFieldNotFound(yyj11-1, "")
 35322  	}
 35323  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35324  }
 35325  
 35326  func (x *JobDispatchResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 35327  	var h codecSelfer100
 35328  	z, r := codec1978.GenHelperEncoder(e)
 35329  	_, _, _ = h, z, r
 35330  	if x == nil {
 35331  		r.EncodeNil()
 35332  	} else {
 35333  		yym1 := z.EncBinary()
 35334  		_ = yym1
 35335  		if false {
 35336  		} else if z.HasExtensions() && z.EncExt(x) {
 35337  		} else {
 35338  			yysep2 := !z.EncBinary()
 35339  			yy2arr2 := z.EncBasicHandle().StructToArray
 35340  			var yyq2 [5]bool
 35341  			_, _, _ = yysep2, yyq2, yy2arr2
 35342  			const yyr2 bool = false
 35343  			var yynn2 int
 35344  			if yyr2 || yy2arr2 {
 35345  				r.EncodeArrayStart(5)
 35346  			} else {
 35347  				yynn2 = 5
 35348  				for _, b := range yyq2 {
 35349  					if b {
 35350  						yynn2++
 35351  					}
 35352  				}
 35353  				r.EncodeMapStart(yynn2)
 35354  				yynn2 = 0
 35355  			}
 35356  			if yyr2 || yy2arr2 {
 35357  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 35358  				yym4 := z.EncBinary()
 35359  				_ = yym4
 35360  				if false {
 35361  				} else {
 35362  					r.EncodeString(codecSelferC_UTF8100, string(x.DispatchedJobID))
 35363  				}
 35364  			} else {
 35365  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 35366  				r.EncodeString(codecSelferC_UTF8100, string("DispatchedJobID"))
 35367  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 35368  				yym5 := z.EncBinary()
 35369  				_ = yym5
 35370  				if false {
 35371  				} else {
 35372  					r.EncodeString(codecSelferC_UTF8100, string(x.DispatchedJobID))
 35373  				}
 35374  			}
 35375  			if yyr2 || yy2arr2 {
 35376  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 35377  				yym7 := z.EncBinary()
 35378  				_ = yym7
 35379  				if false {
 35380  				} else {
 35381  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 35382  				}
 35383  			} else {
 35384  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 35385  				r.EncodeString(codecSelferC_UTF8100, string("EvalID"))
 35386  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 35387  				yym8 := z.EncBinary()
 35388  				_ = yym8
 35389  				if false {
 35390  				} else {
 35391  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 35392  				}
 35393  			}
 35394  			if yyr2 || yy2arr2 {
 35395  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 35396  				yym10 := z.EncBinary()
 35397  				_ = yym10
 35398  				if false {
 35399  				} else {
 35400  					r.EncodeUint(uint64(x.EvalCreateIndex))
 35401  				}
 35402  			} else {
 35403  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 35404  				r.EncodeString(codecSelferC_UTF8100, string("EvalCreateIndex"))
 35405  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 35406  				yym11 := z.EncBinary()
 35407  				_ = yym11
 35408  				if false {
 35409  				} else {
 35410  					r.EncodeUint(uint64(x.EvalCreateIndex))
 35411  				}
 35412  			}
 35413  			if yyr2 || yy2arr2 {
 35414  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 35415  				yym13 := z.EncBinary()
 35416  				_ = yym13
 35417  				if false {
 35418  				} else {
 35419  					r.EncodeUint(uint64(x.JobCreateIndex))
 35420  				}
 35421  			} else {
 35422  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 35423  				r.EncodeString(codecSelferC_UTF8100, string("JobCreateIndex"))
 35424  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 35425  				yym14 := z.EncBinary()
 35426  				_ = yym14
 35427  				if false {
 35428  				} else {
 35429  					r.EncodeUint(uint64(x.JobCreateIndex))
 35430  				}
 35431  			}
 35432  			if yyr2 || yy2arr2 {
 35433  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 35434  				yym16 := z.EncBinary()
 35435  				_ = yym16
 35436  				if false {
 35437  				} else {
 35438  					r.EncodeUint(uint64(x.Index))
 35439  				}
 35440  			} else {
 35441  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 35442  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 35443  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 35444  				yym17 := z.EncBinary()
 35445  				_ = yym17
 35446  				if false {
 35447  				} else {
 35448  					r.EncodeUint(uint64(x.Index))
 35449  				}
 35450  			}
 35451  			if yyr2 || yy2arr2 {
 35452  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 35453  			} else {
 35454  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 35455  			}
 35456  		}
 35457  	}
 35458  }
 35459  
 35460  func (x *JobDispatchResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 35461  	var h codecSelfer100
 35462  	z, r := codec1978.GenHelperDecoder(d)
 35463  	_, _, _ = h, z, r
 35464  	yym1 := z.DecBinary()
 35465  	_ = yym1
 35466  	if false {
 35467  	} else if z.HasExtensions() && z.DecExt(x) {
 35468  	} else {
 35469  		yyct2 := r.ContainerType()
 35470  		if yyct2 == codecSelferValueTypeMap100 {
 35471  			yyl2 := r.ReadMapStart()
 35472  			if yyl2 == 0 {
 35473  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 35474  			} else {
 35475  				x.codecDecodeSelfFromMap(yyl2, d)
 35476  			}
 35477  		} else if yyct2 == codecSelferValueTypeArray100 {
 35478  			yyl2 := r.ReadArrayStart()
 35479  			if yyl2 == 0 {
 35480  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35481  			} else {
 35482  				x.codecDecodeSelfFromArray(yyl2, d)
 35483  			}
 35484  		} else {
 35485  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 35486  		}
 35487  	}
 35488  }
 35489  
 35490  func (x *JobDispatchResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 35491  	var h codecSelfer100
 35492  	z, r := codec1978.GenHelperDecoder(d)
 35493  	_, _, _ = h, z, r
 35494  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 35495  	_ = yys3Slc
 35496  	var yyhl3 bool = l >= 0
 35497  	for yyj3 := 0; ; yyj3++ {
 35498  		if yyhl3 {
 35499  			if yyj3 >= l {
 35500  				break
 35501  			}
 35502  		} else {
 35503  			if r.CheckBreak() {
 35504  				break
 35505  			}
 35506  		}
 35507  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 35508  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 35509  		yys3 := string(yys3Slc)
 35510  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 35511  		switch yys3 {
 35512  		case "DispatchedJobID":
 35513  			if r.TryDecodeAsNil() {
 35514  				x.DispatchedJobID = ""
 35515  			} else {
 35516  				yyv4 := &x.DispatchedJobID
 35517  				yym5 := z.DecBinary()
 35518  				_ = yym5
 35519  				if false {
 35520  				} else {
 35521  					*((*string)(yyv4)) = r.DecodeString()
 35522  				}
 35523  			}
 35524  		case "EvalID":
 35525  			if r.TryDecodeAsNil() {
 35526  				x.EvalID = ""
 35527  			} else {
 35528  				yyv6 := &x.EvalID
 35529  				yym7 := z.DecBinary()
 35530  				_ = yym7
 35531  				if false {
 35532  				} else {
 35533  					*((*string)(yyv6)) = r.DecodeString()
 35534  				}
 35535  			}
 35536  		case "EvalCreateIndex":
 35537  			if r.TryDecodeAsNil() {
 35538  				x.EvalCreateIndex = 0
 35539  			} else {
 35540  				yyv8 := &x.EvalCreateIndex
 35541  				yym9 := z.DecBinary()
 35542  				_ = yym9
 35543  				if false {
 35544  				} else {
 35545  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 35546  				}
 35547  			}
 35548  		case "JobCreateIndex":
 35549  			if r.TryDecodeAsNil() {
 35550  				x.JobCreateIndex = 0
 35551  			} else {
 35552  				yyv10 := &x.JobCreateIndex
 35553  				yym11 := z.DecBinary()
 35554  				_ = yym11
 35555  				if false {
 35556  				} else {
 35557  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 35558  				}
 35559  			}
 35560  		case "Index":
 35561  			if r.TryDecodeAsNil() {
 35562  				x.Index = 0
 35563  			} else {
 35564  				yyv12 := &x.Index
 35565  				yym13 := z.DecBinary()
 35566  				_ = yym13
 35567  				if false {
 35568  				} else {
 35569  					*((*uint64)(yyv12)) = uint64(r.DecodeUint(64))
 35570  				}
 35571  			}
 35572  		default:
 35573  			z.DecStructFieldNotFound(-1, yys3)
 35574  		} // end switch yys3
 35575  	} // end for yyj3
 35576  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 35577  }
 35578  
 35579  func (x *JobDispatchResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 35580  	var h codecSelfer100
 35581  	z, r := codec1978.GenHelperDecoder(d)
 35582  	_, _, _ = h, z, r
 35583  	var yyj14 int
 35584  	var yyb14 bool
 35585  	var yyhl14 bool = l >= 0
 35586  	yyj14++
 35587  	if yyhl14 {
 35588  		yyb14 = yyj14 > l
 35589  	} else {
 35590  		yyb14 = r.CheckBreak()
 35591  	}
 35592  	if yyb14 {
 35593  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35594  		return
 35595  	}
 35596  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 35597  	if r.TryDecodeAsNil() {
 35598  		x.DispatchedJobID = ""
 35599  	} else {
 35600  		yyv15 := &x.DispatchedJobID
 35601  		yym16 := z.DecBinary()
 35602  		_ = yym16
 35603  		if false {
 35604  		} else {
 35605  			*((*string)(yyv15)) = r.DecodeString()
 35606  		}
 35607  	}
 35608  	yyj14++
 35609  	if yyhl14 {
 35610  		yyb14 = yyj14 > l
 35611  	} else {
 35612  		yyb14 = r.CheckBreak()
 35613  	}
 35614  	if yyb14 {
 35615  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35616  		return
 35617  	}
 35618  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 35619  	if r.TryDecodeAsNil() {
 35620  		x.EvalID = ""
 35621  	} else {
 35622  		yyv17 := &x.EvalID
 35623  		yym18 := z.DecBinary()
 35624  		_ = yym18
 35625  		if false {
 35626  		} else {
 35627  			*((*string)(yyv17)) = r.DecodeString()
 35628  		}
 35629  	}
 35630  	yyj14++
 35631  	if yyhl14 {
 35632  		yyb14 = yyj14 > l
 35633  	} else {
 35634  		yyb14 = r.CheckBreak()
 35635  	}
 35636  	if yyb14 {
 35637  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35638  		return
 35639  	}
 35640  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 35641  	if r.TryDecodeAsNil() {
 35642  		x.EvalCreateIndex = 0
 35643  	} else {
 35644  		yyv19 := &x.EvalCreateIndex
 35645  		yym20 := z.DecBinary()
 35646  		_ = yym20
 35647  		if false {
 35648  		} else {
 35649  			*((*uint64)(yyv19)) = uint64(r.DecodeUint(64))
 35650  		}
 35651  	}
 35652  	yyj14++
 35653  	if yyhl14 {
 35654  		yyb14 = yyj14 > l
 35655  	} else {
 35656  		yyb14 = r.CheckBreak()
 35657  	}
 35658  	if yyb14 {
 35659  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35660  		return
 35661  	}
 35662  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 35663  	if r.TryDecodeAsNil() {
 35664  		x.JobCreateIndex = 0
 35665  	} else {
 35666  		yyv21 := &x.JobCreateIndex
 35667  		yym22 := z.DecBinary()
 35668  		_ = yym22
 35669  		if false {
 35670  		} else {
 35671  			*((*uint64)(yyv21)) = uint64(r.DecodeUint(64))
 35672  		}
 35673  	}
 35674  	yyj14++
 35675  	if yyhl14 {
 35676  		yyb14 = yyj14 > l
 35677  	} else {
 35678  		yyb14 = r.CheckBreak()
 35679  	}
 35680  	if yyb14 {
 35681  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35682  		return
 35683  	}
 35684  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 35685  	if r.TryDecodeAsNil() {
 35686  		x.Index = 0
 35687  	} else {
 35688  		yyv23 := &x.Index
 35689  		yym24 := z.DecBinary()
 35690  		_ = yym24
 35691  		if false {
 35692  		} else {
 35693  			*((*uint64)(yyv23)) = uint64(r.DecodeUint(64))
 35694  		}
 35695  	}
 35696  	for {
 35697  		yyj14++
 35698  		if yyhl14 {
 35699  			yyb14 = yyj14 > l
 35700  		} else {
 35701  			yyb14 = r.CheckBreak()
 35702  		}
 35703  		if yyb14 {
 35704  			break
 35705  		}
 35706  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 35707  		z.DecStructFieldNotFound(yyj14-1, "")
 35708  	}
 35709  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35710  }
 35711  
 35712  func (x *JobListResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 35713  	var h codecSelfer100
 35714  	z, r := codec1978.GenHelperEncoder(e)
 35715  	_, _, _ = h, z, r
 35716  	if x == nil {
 35717  		r.EncodeNil()
 35718  	} else {
 35719  		yym1 := z.EncBinary()
 35720  		_ = yym1
 35721  		if false {
 35722  		} else if z.HasExtensions() && z.EncExt(x) {
 35723  		} else {
 35724  			yysep2 := !z.EncBinary()
 35725  			yy2arr2 := z.EncBasicHandle().StructToArray
 35726  			var yyq2 [4]bool
 35727  			_, _, _ = yysep2, yyq2, yy2arr2
 35728  			const yyr2 bool = false
 35729  			var yynn2 int
 35730  			if yyr2 || yy2arr2 {
 35731  				r.EncodeArrayStart(4)
 35732  			} else {
 35733  				yynn2 = 4
 35734  				for _, b := range yyq2 {
 35735  					if b {
 35736  						yynn2++
 35737  					}
 35738  				}
 35739  				r.EncodeMapStart(yynn2)
 35740  				yynn2 = 0
 35741  			}
 35742  			if yyr2 || yy2arr2 {
 35743  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 35744  				if x.Jobs == nil {
 35745  					r.EncodeNil()
 35746  				} else {
 35747  					yym4 := z.EncBinary()
 35748  					_ = yym4
 35749  					if false {
 35750  					} else {
 35751  						h.encSlicePtrtoJobListStub(([]*JobListStub)(x.Jobs), e)
 35752  					}
 35753  				}
 35754  			} else {
 35755  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 35756  				r.EncodeString(codecSelferC_UTF8100, string("Jobs"))
 35757  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 35758  				if x.Jobs == nil {
 35759  					r.EncodeNil()
 35760  				} else {
 35761  					yym5 := z.EncBinary()
 35762  					_ = yym5
 35763  					if false {
 35764  					} else {
 35765  						h.encSlicePtrtoJobListStub(([]*JobListStub)(x.Jobs), e)
 35766  					}
 35767  				}
 35768  			}
 35769  			if yyr2 || yy2arr2 {
 35770  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 35771  				yym7 := z.EncBinary()
 35772  				_ = yym7
 35773  				if false {
 35774  				} else {
 35775  					r.EncodeUint(uint64(x.Index))
 35776  				}
 35777  			} else {
 35778  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 35779  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 35780  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 35781  				yym8 := z.EncBinary()
 35782  				_ = yym8
 35783  				if false {
 35784  				} else {
 35785  					r.EncodeUint(uint64(x.Index))
 35786  				}
 35787  			}
 35788  			if yyr2 || yy2arr2 {
 35789  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 35790  				yym10 := z.EncBinary()
 35791  				_ = yym10
 35792  				if false {
 35793  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 35794  				} else {
 35795  					r.EncodeInt(int64(x.LastContact))
 35796  				}
 35797  			} else {
 35798  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 35799  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 35800  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 35801  				yym11 := z.EncBinary()
 35802  				_ = yym11
 35803  				if false {
 35804  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 35805  				} else {
 35806  					r.EncodeInt(int64(x.LastContact))
 35807  				}
 35808  			}
 35809  			if yyr2 || yy2arr2 {
 35810  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 35811  				yym13 := z.EncBinary()
 35812  				_ = yym13
 35813  				if false {
 35814  				} else {
 35815  					r.EncodeBool(bool(x.KnownLeader))
 35816  				}
 35817  			} else {
 35818  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 35819  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 35820  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 35821  				yym14 := z.EncBinary()
 35822  				_ = yym14
 35823  				if false {
 35824  				} else {
 35825  					r.EncodeBool(bool(x.KnownLeader))
 35826  				}
 35827  			}
 35828  			if yyr2 || yy2arr2 {
 35829  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 35830  			} else {
 35831  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 35832  			}
 35833  		}
 35834  	}
 35835  }
 35836  
 35837  func (x *JobListResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 35838  	var h codecSelfer100
 35839  	z, r := codec1978.GenHelperDecoder(d)
 35840  	_, _, _ = h, z, r
 35841  	yym1 := z.DecBinary()
 35842  	_ = yym1
 35843  	if false {
 35844  	} else if z.HasExtensions() && z.DecExt(x) {
 35845  	} else {
 35846  		yyct2 := r.ContainerType()
 35847  		if yyct2 == codecSelferValueTypeMap100 {
 35848  			yyl2 := r.ReadMapStart()
 35849  			if yyl2 == 0 {
 35850  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 35851  			} else {
 35852  				x.codecDecodeSelfFromMap(yyl2, d)
 35853  			}
 35854  		} else if yyct2 == codecSelferValueTypeArray100 {
 35855  			yyl2 := r.ReadArrayStart()
 35856  			if yyl2 == 0 {
 35857  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35858  			} else {
 35859  				x.codecDecodeSelfFromArray(yyl2, d)
 35860  			}
 35861  		} else {
 35862  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 35863  		}
 35864  	}
 35865  }
 35866  
 35867  func (x *JobListResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 35868  	var h codecSelfer100
 35869  	z, r := codec1978.GenHelperDecoder(d)
 35870  	_, _, _ = h, z, r
 35871  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 35872  	_ = yys3Slc
 35873  	var yyhl3 bool = l >= 0
 35874  	for yyj3 := 0; ; yyj3++ {
 35875  		if yyhl3 {
 35876  			if yyj3 >= l {
 35877  				break
 35878  			}
 35879  		} else {
 35880  			if r.CheckBreak() {
 35881  				break
 35882  			}
 35883  		}
 35884  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 35885  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 35886  		yys3 := string(yys3Slc)
 35887  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 35888  		switch yys3 {
 35889  		case "Jobs":
 35890  			if r.TryDecodeAsNil() {
 35891  				x.Jobs = nil
 35892  			} else {
 35893  				yyv4 := &x.Jobs
 35894  				yym5 := z.DecBinary()
 35895  				_ = yym5
 35896  				if false {
 35897  				} else {
 35898  					h.decSlicePtrtoJobListStub((*[]*JobListStub)(yyv4), d)
 35899  				}
 35900  			}
 35901  		case "Index":
 35902  			if r.TryDecodeAsNil() {
 35903  				x.Index = 0
 35904  			} else {
 35905  				yyv6 := &x.Index
 35906  				yym7 := z.DecBinary()
 35907  				_ = yym7
 35908  				if false {
 35909  				} else {
 35910  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 35911  				}
 35912  			}
 35913  		case "LastContact":
 35914  			if r.TryDecodeAsNil() {
 35915  				x.LastContact = 0
 35916  			} else {
 35917  				yyv8 := &x.LastContact
 35918  				yym9 := z.DecBinary()
 35919  				_ = yym9
 35920  				if false {
 35921  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 35922  				} else {
 35923  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 35924  				}
 35925  			}
 35926  		case "KnownLeader":
 35927  			if r.TryDecodeAsNil() {
 35928  				x.KnownLeader = false
 35929  			} else {
 35930  				yyv10 := &x.KnownLeader
 35931  				yym11 := z.DecBinary()
 35932  				_ = yym11
 35933  				if false {
 35934  				} else {
 35935  					*((*bool)(yyv10)) = r.DecodeBool()
 35936  				}
 35937  			}
 35938  		default:
 35939  			z.DecStructFieldNotFound(-1, yys3)
 35940  		} // end switch yys3
 35941  	} // end for yyj3
 35942  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 35943  }
 35944  
 35945  func (x *JobListResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 35946  	var h codecSelfer100
 35947  	z, r := codec1978.GenHelperDecoder(d)
 35948  	_, _, _ = h, z, r
 35949  	var yyj12 int
 35950  	var yyb12 bool
 35951  	var yyhl12 bool = l >= 0
 35952  	yyj12++
 35953  	if yyhl12 {
 35954  		yyb12 = yyj12 > l
 35955  	} else {
 35956  		yyb12 = r.CheckBreak()
 35957  	}
 35958  	if yyb12 {
 35959  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35960  		return
 35961  	}
 35962  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 35963  	if r.TryDecodeAsNil() {
 35964  		x.Jobs = nil
 35965  	} else {
 35966  		yyv13 := &x.Jobs
 35967  		yym14 := z.DecBinary()
 35968  		_ = yym14
 35969  		if false {
 35970  		} else {
 35971  			h.decSlicePtrtoJobListStub((*[]*JobListStub)(yyv13), d)
 35972  		}
 35973  	}
 35974  	yyj12++
 35975  	if yyhl12 {
 35976  		yyb12 = yyj12 > l
 35977  	} else {
 35978  		yyb12 = r.CheckBreak()
 35979  	}
 35980  	if yyb12 {
 35981  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 35982  		return
 35983  	}
 35984  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 35985  	if r.TryDecodeAsNil() {
 35986  		x.Index = 0
 35987  	} else {
 35988  		yyv15 := &x.Index
 35989  		yym16 := z.DecBinary()
 35990  		_ = yym16
 35991  		if false {
 35992  		} else {
 35993  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 35994  		}
 35995  	}
 35996  	yyj12++
 35997  	if yyhl12 {
 35998  		yyb12 = yyj12 > l
 35999  	} else {
 36000  		yyb12 = r.CheckBreak()
 36001  	}
 36002  	if yyb12 {
 36003  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36004  		return
 36005  	}
 36006  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 36007  	if r.TryDecodeAsNil() {
 36008  		x.LastContact = 0
 36009  	} else {
 36010  		yyv17 := &x.LastContact
 36011  		yym18 := z.DecBinary()
 36012  		_ = yym18
 36013  		if false {
 36014  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 36015  		} else {
 36016  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 36017  		}
 36018  	}
 36019  	yyj12++
 36020  	if yyhl12 {
 36021  		yyb12 = yyj12 > l
 36022  	} else {
 36023  		yyb12 = r.CheckBreak()
 36024  	}
 36025  	if yyb12 {
 36026  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36027  		return
 36028  	}
 36029  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 36030  	if r.TryDecodeAsNil() {
 36031  		x.KnownLeader = false
 36032  	} else {
 36033  		yyv19 := &x.KnownLeader
 36034  		yym20 := z.DecBinary()
 36035  		_ = yym20
 36036  		if false {
 36037  		} else {
 36038  			*((*bool)(yyv19)) = r.DecodeBool()
 36039  		}
 36040  	}
 36041  	for {
 36042  		yyj12++
 36043  		if yyhl12 {
 36044  			yyb12 = yyj12 > l
 36045  		} else {
 36046  			yyb12 = r.CheckBreak()
 36047  		}
 36048  		if yyb12 {
 36049  			break
 36050  		}
 36051  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 36052  		z.DecStructFieldNotFound(yyj12-1, "")
 36053  	}
 36054  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36055  }
 36056  
 36057  func (x *JobVersionsRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 36058  	var h codecSelfer100
 36059  	z, r := codec1978.GenHelperEncoder(e)
 36060  	_, _, _ = h, z, r
 36061  	if x == nil {
 36062  		r.EncodeNil()
 36063  	} else {
 36064  		yym1 := z.EncBinary()
 36065  		_ = yym1
 36066  		if false {
 36067  		} else if z.HasExtensions() && z.EncExt(x) {
 36068  		} else {
 36069  			yysep2 := !z.EncBinary()
 36070  			yy2arr2 := z.EncBasicHandle().StructToArray
 36071  			var yyq2 [10]bool
 36072  			_, _, _ = yysep2, yyq2, yy2arr2
 36073  			const yyr2 bool = false
 36074  			var yynn2 int
 36075  			if yyr2 || yy2arr2 {
 36076  				r.EncodeArrayStart(10)
 36077  			} else {
 36078  				yynn2 = 10
 36079  				for _, b := range yyq2 {
 36080  					if b {
 36081  						yynn2++
 36082  					}
 36083  				}
 36084  				r.EncodeMapStart(yynn2)
 36085  				yynn2 = 0
 36086  			}
 36087  			if yyr2 || yy2arr2 {
 36088  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 36089  				yym4 := z.EncBinary()
 36090  				_ = yym4
 36091  				if false {
 36092  				} else {
 36093  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 36094  				}
 36095  			} else {
 36096  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 36097  				r.EncodeString(codecSelferC_UTF8100, string("JobID"))
 36098  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 36099  				yym5 := z.EncBinary()
 36100  				_ = yym5
 36101  				if false {
 36102  				} else {
 36103  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 36104  				}
 36105  			}
 36106  			if yyr2 || yy2arr2 {
 36107  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 36108  				yym7 := z.EncBinary()
 36109  				_ = yym7
 36110  				if false {
 36111  				} else {
 36112  					r.EncodeBool(bool(x.Diffs))
 36113  				}
 36114  			} else {
 36115  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 36116  				r.EncodeString(codecSelferC_UTF8100, string("Diffs"))
 36117  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 36118  				yym8 := z.EncBinary()
 36119  				_ = yym8
 36120  				if false {
 36121  				} else {
 36122  					r.EncodeBool(bool(x.Diffs))
 36123  				}
 36124  			}
 36125  			if yyr2 || yy2arr2 {
 36126  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 36127  				yym10 := z.EncBinary()
 36128  				_ = yym10
 36129  				if false {
 36130  				} else {
 36131  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 36132  				}
 36133  			} else {
 36134  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 36135  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 36136  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 36137  				yym11 := z.EncBinary()
 36138  				_ = yym11
 36139  				if false {
 36140  				} else {
 36141  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 36142  				}
 36143  			}
 36144  			if yyr2 || yy2arr2 {
 36145  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 36146  				yym13 := z.EncBinary()
 36147  				_ = yym13
 36148  				if false {
 36149  				} else {
 36150  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 36151  				}
 36152  			} else {
 36153  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 36154  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 36155  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 36156  				yym14 := z.EncBinary()
 36157  				_ = yym14
 36158  				if false {
 36159  				} else {
 36160  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 36161  				}
 36162  			}
 36163  			if yyr2 || yy2arr2 {
 36164  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 36165  				yym16 := z.EncBinary()
 36166  				_ = yym16
 36167  				if false {
 36168  				} else {
 36169  					r.EncodeUint(uint64(x.MinQueryIndex))
 36170  				}
 36171  			} else {
 36172  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 36173  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 36174  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 36175  				yym17 := z.EncBinary()
 36176  				_ = yym17
 36177  				if false {
 36178  				} else {
 36179  					r.EncodeUint(uint64(x.MinQueryIndex))
 36180  				}
 36181  			}
 36182  			if yyr2 || yy2arr2 {
 36183  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 36184  				yym19 := z.EncBinary()
 36185  				_ = yym19
 36186  				if false {
 36187  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 36188  				} else {
 36189  					r.EncodeInt(int64(x.MaxQueryTime))
 36190  				}
 36191  			} else {
 36192  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 36193  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 36194  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 36195  				yym20 := z.EncBinary()
 36196  				_ = yym20
 36197  				if false {
 36198  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 36199  				} else {
 36200  					r.EncodeInt(int64(x.MaxQueryTime))
 36201  				}
 36202  			}
 36203  			if yyr2 || yy2arr2 {
 36204  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 36205  				yym22 := z.EncBinary()
 36206  				_ = yym22
 36207  				if false {
 36208  				} else {
 36209  					r.EncodeBool(bool(x.AllowStale))
 36210  				}
 36211  			} else {
 36212  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 36213  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 36214  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 36215  				yym23 := z.EncBinary()
 36216  				_ = yym23
 36217  				if false {
 36218  				} else {
 36219  					r.EncodeBool(bool(x.AllowStale))
 36220  				}
 36221  			}
 36222  			if yyr2 || yy2arr2 {
 36223  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 36224  				yym25 := z.EncBinary()
 36225  				_ = yym25
 36226  				if false {
 36227  				} else {
 36228  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 36229  				}
 36230  			} else {
 36231  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 36232  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 36233  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 36234  				yym26 := z.EncBinary()
 36235  				_ = yym26
 36236  				if false {
 36237  				} else {
 36238  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 36239  				}
 36240  			}
 36241  			if yyr2 || yy2arr2 {
 36242  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 36243  				yym28 := z.EncBinary()
 36244  				_ = yym28
 36245  				if false {
 36246  				} else {
 36247  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 36248  				}
 36249  			} else {
 36250  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 36251  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 36252  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 36253  				yym29 := z.EncBinary()
 36254  				_ = yym29
 36255  				if false {
 36256  				} else {
 36257  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 36258  				}
 36259  			}
 36260  			if yyr2 || yy2arr2 {
 36261  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 36262  				yym31 := z.EncBinary()
 36263  				_ = yym31
 36264  				if false {
 36265  				} else {
 36266  					r.EncodeBool(bool(x.Forwarded))
 36267  				}
 36268  			} else {
 36269  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 36270  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 36271  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 36272  				yym32 := z.EncBinary()
 36273  				_ = yym32
 36274  				if false {
 36275  				} else {
 36276  					r.EncodeBool(bool(x.Forwarded))
 36277  				}
 36278  			}
 36279  			if yyr2 || yy2arr2 {
 36280  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 36281  			} else {
 36282  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 36283  			}
 36284  		}
 36285  	}
 36286  }
 36287  
 36288  func (x *JobVersionsRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 36289  	var h codecSelfer100
 36290  	z, r := codec1978.GenHelperDecoder(d)
 36291  	_, _, _ = h, z, r
 36292  	yym1 := z.DecBinary()
 36293  	_ = yym1
 36294  	if false {
 36295  	} else if z.HasExtensions() && z.DecExt(x) {
 36296  	} else {
 36297  		yyct2 := r.ContainerType()
 36298  		if yyct2 == codecSelferValueTypeMap100 {
 36299  			yyl2 := r.ReadMapStart()
 36300  			if yyl2 == 0 {
 36301  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 36302  			} else {
 36303  				x.codecDecodeSelfFromMap(yyl2, d)
 36304  			}
 36305  		} else if yyct2 == codecSelferValueTypeArray100 {
 36306  			yyl2 := r.ReadArrayStart()
 36307  			if yyl2 == 0 {
 36308  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36309  			} else {
 36310  				x.codecDecodeSelfFromArray(yyl2, d)
 36311  			}
 36312  		} else {
 36313  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 36314  		}
 36315  	}
 36316  }
 36317  
 36318  func (x *JobVersionsRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 36319  	var h codecSelfer100
 36320  	z, r := codec1978.GenHelperDecoder(d)
 36321  	_, _, _ = h, z, r
 36322  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 36323  	_ = yys3Slc
 36324  	var yyhl3 bool = l >= 0
 36325  	for yyj3 := 0; ; yyj3++ {
 36326  		if yyhl3 {
 36327  			if yyj3 >= l {
 36328  				break
 36329  			}
 36330  		} else {
 36331  			if r.CheckBreak() {
 36332  				break
 36333  			}
 36334  		}
 36335  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 36336  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 36337  		yys3 := string(yys3Slc)
 36338  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 36339  		switch yys3 {
 36340  		case "JobID":
 36341  			if r.TryDecodeAsNil() {
 36342  				x.JobID = ""
 36343  			} else {
 36344  				yyv4 := &x.JobID
 36345  				yym5 := z.DecBinary()
 36346  				_ = yym5
 36347  				if false {
 36348  				} else {
 36349  					*((*string)(yyv4)) = r.DecodeString()
 36350  				}
 36351  			}
 36352  		case "Diffs":
 36353  			if r.TryDecodeAsNil() {
 36354  				x.Diffs = false
 36355  			} else {
 36356  				yyv6 := &x.Diffs
 36357  				yym7 := z.DecBinary()
 36358  				_ = yym7
 36359  				if false {
 36360  				} else {
 36361  					*((*bool)(yyv6)) = r.DecodeBool()
 36362  				}
 36363  			}
 36364  		case "Region":
 36365  			if r.TryDecodeAsNil() {
 36366  				x.Region = ""
 36367  			} else {
 36368  				yyv8 := &x.Region
 36369  				yym9 := z.DecBinary()
 36370  				_ = yym9
 36371  				if false {
 36372  				} else {
 36373  					*((*string)(yyv8)) = r.DecodeString()
 36374  				}
 36375  			}
 36376  		case "Namespace":
 36377  			if r.TryDecodeAsNil() {
 36378  				x.Namespace = ""
 36379  			} else {
 36380  				yyv10 := &x.Namespace
 36381  				yym11 := z.DecBinary()
 36382  				_ = yym11
 36383  				if false {
 36384  				} else {
 36385  					*((*string)(yyv10)) = r.DecodeString()
 36386  				}
 36387  			}
 36388  		case "MinQueryIndex":
 36389  			if r.TryDecodeAsNil() {
 36390  				x.MinQueryIndex = 0
 36391  			} else {
 36392  				yyv12 := &x.MinQueryIndex
 36393  				yym13 := z.DecBinary()
 36394  				_ = yym13
 36395  				if false {
 36396  				} else {
 36397  					*((*uint64)(yyv12)) = uint64(r.DecodeUint(64))
 36398  				}
 36399  			}
 36400  		case "MaxQueryTime":
 36401  			if r.TryDecodeAsNil() {
 36402  				x.MaxQueryTime = 0
 36403  			} else {
 36404  				yyv14 := &x.MaxQueryTime
 36405  				yym15 := z.DecBinary()
 36406  				_ = yym15
 36407  				if false {
 36408  				} else if z.HasExtensions() && z.DecExt(yyv14) {
 36409  				} else {
 36410  					*((*int64)(yyv14)) = int64(r.DecodeInt(64))
 36411  				}
 36412  			}
 36413  		case "AllowStale":
 36414  			if r.TryDecodeAsNil() {
 36415  				x.AllowStale = false
 36416  			} else {
 36417  				yyv16 := &x.AllowStale
 36418  				yym17 := z.DecBinary()
 36419  				_ = yym17
 36420  				if false {
 36421  				} else {
 36422  					*((*bool)(yyv16)) = r.DecodeBool()
 36423  				}
 36424  			}
 36425  		case "Prefix":
 36426  			if r.TryDecodeAsNil() {
 36427  				x.Prefix = ""
 36428  			} else {
 36429  				yyv18 := &x.Prefix
 36430  				yym19 := z.DecBinary()
 36431  				_ = yym19
 36432  				if false {
 36433  				} else {
 36434  					*((*string)(yyv18)) = r.DecodeString()
 36435  				}
 36436  			}
 36437  		case "AuthToken":
 36438  			if r.TryDecodeAsNil() {
 36439  				x.AuthToken = ""
 36440  			} else {
 36441  				yyv20 := &x.AuthToken
 36442  				yym21 := z.DecBinary()
 36443  				_ = yym21
 36444  				if false {
 36445  				} else {
 36446  					*((*string)(yyv20)) = r.DecodeString()
 36447  				}
 36448  			}
 36449  		case "Forwarded":
 36450  			if r.TryDecodeAsNil() {
 36451  				x.Forwarded = false
 36452  			} else {
 36453  				yyv22 := &x.Forwarded
 36454  				yym23 := z.DecBinary()
 36455  				_ = yym23
 36456  				if false {
 36457  				} else {
 36458  					*((*bool)(yyv22)) = r.DecodeBool()
 36459  				}
 36460  			}
 36461  		default:
 36462  			z.DecStructFieldNotFound(-1, yys3)
 36463  		} // end switch yys3
 36464  	} // end for yyj3
 36465  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 36466  }
 36467  
 36468  func (x *JobVersionsRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 36469  	var h codecSelfer100
 36470  	z, r := codec1978.GenHelperDecoder(d)
 36471  	_, _, _ = h, z, r
 36472  	var yyj24 int
 36473  	var yyb24 bool
 36474  	var yyhl24 bool = l >= 0
 36475  	yyj24++
 36476  	if yyhl24 {
 36477  		yyb24 = yyj24 > l
 36478  	} else {
 36479  		yyb24 = r.CheckBreak()
 36480  	}
 36481  	if yyb24 {
 36482  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36483  		return
 36484  	}
 36485  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 36486  	if r.TryDecodeAsNil() {
 36487  		x.JobID = ""
 36488  	} else {
 36489  		yyv25 := &x.JobID
 36490  		yym26 := z.DecBinary()
 36491  		_ = yym26
 36492  		if false {
 36493  		} else {
 36494  			*((*string)(yyv25)) = r.DecodeString()
 36495  		}
 36496  	}
 36497  	yyj24++
 36498  	if yyhl24 {
 36499  		yyb24 = yyj24 > l
 36500  	} else {
 36501  		yyb24 = r.CheckBreak()
 36502  	}
 36503  	if yyb24 {
 36504  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36505  		return
 36506  	}
 36507  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 36508  	if r.TryDecodeAsNil() {
 36509  		x.Diffs = false
 36510  	} else {
 36511  		yyv27 := &x.Diffs
 36512  		yym28 := z.DecBinary()
 36513  		_ = yym28
 36514  		if false {
 36515  		} else {
 36516  			*((*bool)(yyv27)) = r.DecodeBool()
 36517  		}
 36518  	}
 36519  	yyj24++
 36520  	if yyhl24 {
 36521  		yyb24 = yyj24 > l
 36522  	} else {
 36523  		yyb24 = r.CheckBreak()
 36524  	}
 36525  	if yyb24 {
 36526  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36527  		return
 36528  	}
 36529  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 36530  	if r.TryDecodeAsNil() {
 36531  		x.Region = ""
 36532  	} else {
 36533  		yyv29 := &x.Region
 36534  		yym30 := z.DecBinary()
 36535  		_ = yym30
 36536  		if false {
 36537  		} else {
 36538  			*((*string)(yyv29)) = r.DecodeString()
 36539  		}
 36540  	}
 36541  	yyj24++
 36542  	if yyhl24 {
 36543  		yyb24 = yyj24 > l
 36544  	} else {
 36545  		yyb24 = r.CheckBreak()
 36546  	}
 36547  	if yyb24 {
 36548  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36549  		return
 36550  	}
 36551  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 36552  	if r.TryDecodeAsNil() {
 36553  		x.Namespace = ""
 36554  	} else {
 36555  		yyv31 := &x.Namespace
 36556  		yym32 := z.DecBinary()
 36557  		_ = yym32
 36558  		if false {
 36559  		} else {
 36560  			*((*string)(yyv31)) = r.DecodeString()
 36561  		}
 36562  	}
 36563  	yyj24++
 36564  	if yyhl24 {
 36565  		yyb24 = yyj24 > l
 36566  	} else {
 36567  		yyb24 = r.CheckBreak()
 36568  	}
 36569  	if yyb24 {
 36570  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36571  		return
 36572  	}
 36573  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 36574  	if r.TryDecodeAsNil() {
 36575  		x.MinQueryIndex = 0
 36576  	} else {
 36577  		yyv33 := &x.MinQueryIndex
 36578  		yym34 := z.DecBinary()
 36579  		_ = yym34
 36580  		if false {
 36581  		} else {
 36582  			*((*uint64)(yyv33)) = uint64(r.DecodeUint(64))
 36583  		}
 36584  	}
 36585  	yyj24++
 36586  	if yyhl24 {
 36587  		yyb24 = yyj24 > l
 36588  	} else {
 36589  		yyb24 = r.CheckBreak()
 36590  	}
 36591  	if yyb24 {
 36592  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36593  		return
 36594  	}
 36595  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 36596  	if r.TryDecodeAsNil() {
 36597  		x.MaxQueryTime = 0
 36598  	} else {
 36599  		yyv35 := &x.MaxQueryTime
 36600  		yym36 := z.DecBinary()
 36601  		_ = yym36
 36602  		if false {
 36603  		} else if z.HasExtensions() && z.DecExt(yyv35) {
 36604  		} else {
 36605  			*((*int64)(yyv35)) = int64(r.DecodeInt(64))
 36606  		}
 36607  	}
 36608  	yyj24++
 36609  	if yyhl24 {
 36610  		yyb24 = yyj24 > l
 36611  	} else {
 36612  		yyb24 = r.CheckBreak()
 36613  	}
 36614  	if yyb24 {
 36615  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36616  		return
 36617  	}
 36618  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 36619  	if r.TryDecodeAsNil() {
 36620  		x.AllowStale = false
 36621  	} else {
 36622  		yyv37 := &x.AllowStale
 36623  		yym38 := z.DecBinary()
 36624  		_ = yym38
 36625  		if false {
 36626  		} else {
 36627  			*((*bool)(yyv37)) = r.DecodeBool()
 36628  		}
 36629  	}
 36630  	yyj24++
 36631  	if yyhl24 {
 36632  		yyb24 = yyj24 > l
 36633  	} else {
 36634  		yyb24 = r.CheckBreak()
 36635  	}
 36636  	if yyb24 {
 36637  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36638  		return
 36639  	}
 36640  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 36641  	if r.TryDecodeAsNil() {
 36642  		x.Prefix = ""
 36643  	} else {
 36644  		yyv39 := &x.Prefix
 36645  		yym40 := z.DecBinary()
 36646  		_ = yym40
 36647  		if false {
 36648  		} else {
 36649  			*((*string)(yyv39)) = r.DecodeString()
 36650  		}
 36651  	}
 36652  	yyj24++
 36653  	if yyhl24 {
 36654  		yyb24 = yyj24 > l
 36655  	} else {
 36656  		yyb24 = r.CheckBreak()
 36657  	}
 36658  	if yyb24 {
 36659  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36660  		return
 36661  	}
 36662  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 36663  	if r.TryDecodeAsNil() {
 36664  		x.AuthToken = ""
 36665  	} else {
 36666  		yyv41 := &x.AuthToken
 36667  		yym42 := z.DecBinary()
 36668  		_ = yym42
 36669  		if false {
 36670  		} else {
 36671  			*((*string)(yyv41)) = r.DecodeString()
 36672  		}
 36673  	}
 36674  	yyj24++
 36675  	if yyhl24 {
 36676  		yyb24 = yyj24 > l
 36677  	} else {
 36678  		yyb24 = r.CheckBreak()
 36679  	}
 36680  	if yyb24 {
 36681  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36682  		return
 36683  	}
 36684  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 36685  	if r.TryDecodeAsNil() {
 36686  		x.Forwarded = false
 36687  	} else {
 36688  		yyv43 := &x.Forwarded
 36689  		yym44 := z.DecBinary()
 36690  		_ = yym44
 36691  		if false {
 36692  		} else {
 36693  			*((*bool)(yyv43)) = r.DecodeBool()
 36694  		}
 36695  	}
 36696  	for {
 36697  		yyj24++
 36698  		if yyhl24 {
 36699  			yyb24 = yyj24 > l
 36700  		} else {
 36701  			yyb24 = r.CheckBreak()
 36702  		}
 36703  		if yyb24 {
 36704  			break
 36705  		}
 36706  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 36707  		z.DecStructFieldNotFound(yyj24-1, "")
 36708  	}
 36709  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36710  }
 36711  
 36712  func (x *JobVersionsResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 36713  	var h codecSelfer100
 36714  	z, r := codec1978.GenHelperEncoder(e)
 36715  	_, _, _ = h, z, r
 36716  	if x == nil {
 36717  		r.EncodeNil()
 36718  	} else {
 36719  		yym1 := z.EncBinary()
 36720  		_ = yym1
 36721  		if false {
 36722  		} else if z.HasExtensions() && z.EncExt(x) {
 36723  		} else {
 36724  			yysep2 := !z.EncBinary()
 36725  			yy2arr2 := z.EncBasicHandle().StructToArray
 36726  			var yyq2 [5]bool
 36727  			_, _, _ = yysep2, yyq2, yy2arr2
 36728  			const yyr2 bool = false
 36729  			var yynn2 int
 36730  			if yyr2 || yy2arr2 {
 36731  				r.EncodeArrayStart(5)
 36732  			} else {
 36733  				yynn2 = 5
 36734  				for _, b := range yyq2 {
 36735  					if b {
 36736  						yynn2++
 36737  					}
 36738  				}
 36739  				r.EncodeMapStart(yynn2)
 36740  				yynn2 = 0
 36741  			}
 36742  			if yyr2 || yy2arr2 {
 36743  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 36744  				if x.Versions == nil {
 36745  					r.EncodeNil()
 36746  				} else {
 36747  					yym4 := z.EncBinary()
 36748  					_ = yym4
 36749  					if false {
 36750  					} else {
 36751  						h.encSlicePtrtoJob(([]*Job)(x.Versions), e)
 36752  					}
 36753  				}
 36754  			} else {
 36755  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 36756  				r.EncodeString(codecSelferC_UTF8100, string("Versions"))
 36757  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 36758  				if x.Versions == nil {
 36759  					r.EncodeNil()
 36760  				} else {
 36761  					yym5 := z.EncBinary()
 36762  					_ = yym5
 36763  					if false {
 36764  					} else {
 36765  						h.encSlicePtrtoJob(([]*Job)(x.Versions), e)
 36766  					}
 36767  				}
 36768  			}
 36769  			if yyr2 || yy2arr2 {
 36770  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 36771  				if x.Diffs == nil {
 36772  					r.EncodeNil()
 36773  				} else {
 36774  					yym7 := z.EncBinary()
 36775  					_ = yym7
 36776  					if false {
 36777  					} else {
 36778  						h.encSlicePtrtoJobDiff(([]*JobDiff)(x.Diffs), e)
 36779  					}
 36780  				}
 36781  			} else {
 36782  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 36783  				r.EncodeString(codecSelferC_UTF8100, string("Diffs"))
 36784  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 36785  				if x.Diffs == nil {
 36786  					r.EncodeNil()
 36787  				} else {
 36788  					yym8 := z.EncBinary()
 36789  					_ = yym8
 36790  					if false {
 36791  					} else {
 36792  						h.encSlicePtrtoJobDiff(([]*JobDiff)(x.Diffs), e)
 36793  					}
 36794  				}
 36795  			}
 36796  			if yyr2 || yy2arr2 {
 36797  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 36798  				yym10 := z.EncBinary()
 36799  				_ = yym10
 36800  				if false {
 36801  				} else {
 36802  					r.EncodeUint(uint64(x.Index))
 36803  				}
 36804  			} else {
 36805  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 36806  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 36807  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 36808  				yym11 := z.EncBinary()
 36809  				_ = yym11
 36810  				if false {
 36811  				} else {
 36812  					r.EncodeUint(uint64(x.Index))
 36813  				}
 36814  			}
 36815  			if yyr2 || yy2arr2 {
 36816  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 36817  				yym13 := z.EncBinary()
 36818  				_ = yym13
 36819  				if false {
 36820  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 36821  				} else {
 36822  					r.EncodeInt(int64(x.LastContact))
 36823  				}
 36824  			} else {
 36825  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 36826  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 36827  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 36828  				yym14 := z.EncBinary()
 36829  				_ = yym14
 36830  				if false {
 36831  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 36832  				} else {
 36833  					r.EncodeInt(int64(x.LastContact))
 36834  				}
 36835  			}
 36836  			if yyr2 || yy2arr2 {
 36837  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 36838  				yym16 := z.EncBinary()
 36839  				_ = yym16
 36840  				if false {
 36841  				} else {
 36842  					r.EncodeBool(bool(x.KnownLeader))
 36843  				}
 36844  			} else {
 36845  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 36846  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 36847  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 36848  				yym17 := z.EncBinary()
 36849  				_ = yym17
 36850  				if false {
 36851  				} else {
 36852  					r.EncodeBool(bool(x.KnownLeader))
 36853  				}
 36854  			}
 36855  			if yyr2 || yy2arr2 {
 36856  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 36857  			} else {
 36858  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 36859  			}
 36860  		}
 36861  	}
 36862  }
 36863  
 36864  func (x *JobVersionsResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 36865  	var h codecSelfer100
 36866  	z, r := codec1978.GenHelperDecoder(d)
 36867  	_, _, _ = h, z, r
 36868  	yym1 := z.DecBinary()
 36869  	_ = yym1
 36870  	if false {
 36871  	} else if z.HasExtensions() && z.DecExt(x) {
 36872  	} else {
 36873  		yyct2 := r.ContainerType()
 36874  		if yyct2 == codecSelferValueTypeMap100 {
 36875  			yyl2 := r.ReadMapStart()
 36876  			if yyl2 == 0 {
 36877  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 36878  			} else {
 36879  				x.codecDecodeSelfFromMap(yyl2, d)
 36880  			}
 36881  		} else if yyct2 == codecSelferValueTypeArray100 {
 36882  			yyl2 := r.ReadArrayStart()
 36883  			if yyl2 == 0 {
 36884  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36885  			} else {
 36886  				x.codecDecodeSelfFromArray(yyl2, d)
 36887  			}
 36888  		} else {
 36889  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 36890  		}
 36891  	}
 36892  }
 36893  
 36894  func (x *JobVersionsResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 36895  	var h codecSelfer100
 36896  	z, r := codec1978.GenHelperDecoder(d)
 36897  	_, _, _ = h, z, r
 36898  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 36899  	_ = yys3Slc
 36900  	var yyhl3 bool = l >= 0
 36901  	for yyj3 := 0; ; yyj3++ {
 36902  		if yyhl3 {
 36903  			if yyj3 >= l {
 36904  				break
 36905  			}
 36906  		} else {
 36907  			if r.CheckBreak() {
 36908  				break
 36909  			}
 36910  		}
 36911  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 36912  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 36913  		yys3 := string(yys3Slc)
 36914  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 36915  		switch yys3 {
 36916  		case "Versions":
 36917  			if r.TryDecodeAsNil() {
 36918  				x.Versions = nil
 36919  			} else {
 36920  				yyv4 := &x.Versions
 36921  				yym5 := z.DecBinary()
 36922  				_ = yym5
 36923  				if false {
 36924  				} else {
 36925  					h.decSlicePtrtoJob((*[]*Job)(yyv4), d)
 36926  				}
 36927  			}
 36928  		case "Diffs":
 36929  			if r.TryDecodeAsNil() {
 36930  				x.Diffs = nil
 36931  			} else {
 36932  				yyv6 := &x.Diffs
 36933  				yym7 := z.DecBinary()
 36934  				_ = yym7
 36935  				if false {
 36936  				} else {
 36937  					h.decSlicePtrtoJobDiff((*[]*JobDiff)(yyv6), d)
 36938  				}
 36939  			}
 36940  		case "Index":
 36941  			if r.TryDecodeAsNil() {
 36942  				x.Index = 0
 36943  			} else {
 36944  				yyv8 := &x.Index
 36945  				yym9 := z.DecBinary()
 36946  				_ = yym9
 36947  				if false {
 36948  				} else {
 36949  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 36950  				}
 36951  			}
 36952  		case "LastContact":
 36953  			if r.TryDecodeAsNil() {
 36954  				x.LastContact = 0
 36955  			} else {
 36956  				yyv10 := &x.LastContact
 36957  				yym11 := z.DecBinary()
 36958  				_ = yym11
 36959  				if false {
 36960  				} else if z.HasExtensions() && z.DecExt(yyv10) {
 36961  				} else {
 36962  					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
 36963  				}
 36964  			}
 36965  		case "KnownLeader":
 36966  			if r.TryDecodeAsNil() {
 36967  				x.KnownLeader = false
 36968  			} else {
 36969  				yyv12 := &x.KnownLeader
 36970  				yym13 := z.DecBinary()
 36971  				_ = yym13
 36972  				if false {
 36973  				} else {
 36974  					*((*bool)(yyv12)) = r.DecodeBool()
 36975  				}
 36976  			}
 36977  		default:
 36978  			z.DecStructFieldNotFound(-1, yys3)
 36979  		} // end switch yys3
 36980  	} // end for yyj3
 36981  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 36982  }
 36983  
 36984  func (x *JobVersionsResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 36985  	var h codecSelfer100
 36986  	z, r := codec1978.GenHelperDecoder(d)
 36987  	_, _, _ = h, z, r
 36988  	var yyj14 int
 36989  	var yyb14 bool
 36990  	var yyhl14 bool = l >= 0
 36991  	yyj14++
 36992  	if yyhl14 {
 36993  		yyb14 = yyj14 > l
 36994  	} else {
 36995  		yyb14 = r.CheckBreak()
 36996  	}
 36997  	if yyb14 {
 36998  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 36999  		return
 37000  	}
 37001  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37002  	if r.TryDecodeAsNil() {
 37003  		x.Versions = nil
 37004  	} else {
 37005  		yyv15 := &x.Versions
 37006  		yym16 := z.DecBinary()
 37007  		_ = yym16
 37008  		if false {
 37009  		} else {
 37010  			h.decSlicePtrtoJob((*[]*Job)(yyv15), d)
 37011  		}
 37012  	}
 37013  	yyj14++
 37014  	if yyhl14 {
 37015  		yyb14 = yyj14 > l
 37016  	} else {
 37017  		yyb14 = r.CheckBreak()
 37018  	}
 37019  	if yyb14 {
 37020  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37021  		return
 37022  	}
 37023  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37024  	if r.TryDecodeAsNil() {
 37025  		x.Diffs = nil
 37026  	} else {
 37027  		yyv17 := &x.Diffs
 37028  		yym18 := z.DecBinary()
 37029  		_ = yym18
 37030  		if false {
 37031  		} else {
 37032  			h.decSlicePtrtoJobDiff((*[]*JobDiff)(yyv17), d)
 37033  		}
 37034  	}
 37035  	yyj14++
 37036  	if yyhl14 {
 37037  		yyb14 = yyj14 > l
 37038  	} else {
 37039  		yyb14 = r.CheckBreak()
 37040  	}
 37041  	if yyb14 {
 37042  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37043  		return
 37044  	}
 37045  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37046  	if r.TryDecodeAsNil() {
 37047  		x.Index = 0
 37048  	} else {
 37049  		yyv19 := &x.Index
 37050  		yym20 := z.DecBinary()
 37051  		_ = yym20
 37052  		if false {
 37053  		} else {
 37054  			*((*uint64)(yyv19)) = uint64(r.DecodeUint(64))
 37055  		}
 37056  	}
 37057  	yyj14++
 37058  	if yyhl14 {
 37059  		yyb14 = yyj14 > l
 37060  	} else {
 37061  		yyb14 = r.CheckBreak()
 37062  	}
 37063  	if yyb14 {
 37064  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37065  		return
 37066  	}
 37067  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37068  	if r.TryDecodeAsNil() {
 37069  		x.LastContact = 0
 37070  	} else {
 37071  		yyv21 := &x.LastContact
 37072  		yym22 := z.DecBinary()
 37073  		_ = yym22
 37074  		if false {
 37075  		} else if z.HasExtensions() && z.DecExt(yyv21) {
 37076  		} else {
 37077  			*((*int64)(yyv21)) = int64(r.DecodeInt(64))
 37078  		}
 37079  	}
 37080  	yyj14++
 37081  	if yyhl14 {
 37082  		yyb14 = yyj14 > l
 37083  	} else {
 37084  		yyb14 = r.CheckBreak()
 37085  	}
 37086  	if yyb14 {
 37087  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37088  		return
 37089  	}
 37090  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37091  	if r.TryDecodeAsNil() {
 37092  		x.KnownLeader = false
 37093  	} else {
 37094  		yyv23 := &x.KnownLeader
 37095  		yym24 := z.DecBinary()
 37096  		_ = yym24
 37097  		if false {
 37098  		} else {
 37099  			*((*bool)(yyv23)) = r.DecodeBool()
 37100  		}
 37101  	}
 37102  	for {
 37103  		yyj14++
 37104  		if yyhl14 {
 37105  			yyb14 = yyj14 > l
 37106  		} else {
 37107  			yyb14 = r.CheckBreak()
 37108  		}
 37109  		if yyb14 {
 37110  			break
 37111  		}
 37112  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37113  		z.DecStructFieldNotFound(yyj14-1, "")
 37114  	}
 37115  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37116  }
 37117  
 37118  func (x *JobPlanResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 37119  	var h codecSelfer100
 37120  	z, r := codec1978.GenHelperEncoder(e)
 37121  	_, _, _ = h, z, r
 37122  	if x == nil {
 37123  		r.EncodeNil()
 37124  	} else {
 37125  		yym1 := z.EncBinary()
 37126  		_ = yym1
 37127  		if false {
 37128  		} else if z.HasExtensions() && z.EncExt(x) {
 37129  		} else {
 37130  			yysep2 := !z.EncBinary()
 37131  			yy2arr2 := z.EncBasicHandle().StructToArray
 37132  			var yyq2 [8]bool
 37133  			_, _, _ = yysep2, yyq2, yy2arr2
 37134  			const yyr2 bool = false
 37135  			var yynn2 int
 37136  			if yyr2 || yy2arr2 {
 37137  				r.EncodeArrayStart(8)
 37138  			} else {
 37139  				yynn2 = 8
 37140  				for _, b := range yyq2 {
 37141  					if b {
 37142  						yynn2++
 37143  					}
 37144  				}
 37145  				r.EncodeMapStart(yynn2)
 37146  				yynn2 = 0
 37147  			}
 37148  			if yyr2 || yy2arr2 {
 37149  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 37150  				if x.Annotations == nil {
 37151  					r.EncodeNil()
 37152  				} else {
 37153  					x.Annotations.CodecEncodeSelf(e)
 37154  				}
 37155  			} else {
 37156  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 37157  				r.EncodeString(codecSelferC_UTF8100, string("Annotations"))
 37158  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 37159  				if x.Annotations == nil {
 37160  					r.EncodeNil()
 37161  				} else {
 37162  					x.Annotations.CodecEncodeSelf(e)
 37163  				}
 37164  			}
 37165  			if yyr2 || yy2arr2 {
 37166  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 37167  				if x.FailedTGAllocs == nil {
 37168  					r.EncodeNil()
 37169  				} else {
 37170  					yym7 := z.EncBinary()
 37171  					_ = yym7
 37172  					if false {
 37173  					} else {
 37174  						h.encMapstringPtrtoAllocMetric((map[string]*AllocMetric)(x.FailedTGAllocs), e)
 37175  					}
 37176  				}
 37177  			} else {
 37178  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 37179  				r.EncodeString(codecSelferC_UTF8100, string("FailedTGAllocs"))
 37180  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 37181  				if x.FailedTGAllocs == nil {
 37182  					r.EncodeNil()
 37183  				} else {
 37184  					yym8 := z.EncBinary()
 37185  					_ = yym8
 37186  					if false {
 37187  					} else {
 37188  						h.encMapstringPtrtoAllocMetric((map[string]*AllocMetric)(x.FailedTGAllocs), e)
 37189  					}
 37190  				}
 37191  			}
 37192  			if yyr2 || yy2arr2 {
 37193  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 37194  				yym10 := z.EncBinary()
 37195  				_ = yym10
 37196  				if false {
 37197  				} else {
 37198  					r.EncodeUint(uint64(x.JobModifyIndex))
 37199  				}
 37200  			} else {
 37201  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 37202  				r.EncodeString(codecSelferC_UTF8100, string("JobModifyIndex"))
 37203  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 37204  				yym11 := z.EncBinary()
 37205  				_ = yym11
 37206  				if false {
 37207  				} else {
 37208  					r.EncodeUint(uint64(x.JobModifyIndex))
 37209  				}
 37210  			}
 37211  			if yyr2 || yy2arr2 {
 37212  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 37213  				if x.CreatedEvals == nil {
 37214  					r.EncodeNil()
 37215  				} else {
 37216  					yym13 := z.EncBinary()
 37217  					_ = yym13
 37218  					if false {
 37219  					} else {
 37220  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.CreatedEvals), e)
 37221  					}
 37222  				}
 37223  			} else {
 37224  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 37225  				r.EncodeString(codecSelferC_UTF8100, string("CreatedEvals"))
 37226  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 37227  				if x.CreatedEvals == nil {
 37228  					r.EncodeNil()
 37229  				} else {
 37230  					yym14 := z.EncBinary()
 37231  					_ = yym14
 37232  					if false {
 37233  					} else {
 37234  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.CreatedEvals), e)
 37235  					}
 37236  				}
 37237  			}
 37238  			if yyr2 || yy2arr2 {
 37239  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 37240  				if x.Diff == nil {
 37241  					r.EncodeNil()
 37242  				} else {
 37243  					yym16 := z.EncBinary()
 37244  					_ = yym16
 37245  					if false {
 37246  					} else if z.HasExtensions() && z.EncExt(x.Diff) {
 37247  					} else {
 37248  						z.EncFallback(x.Diff)
 37249  					}
 37250  				}
 37251  			} else {
 37252  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 37253  				r.EncodeString(codecSelferC_UTF8100, string("Diff"))
 37254  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 37255  				if x.Diff == nil {
 37256  					r.EncodeNil()
 37257  				} else {
 37258  					yym17 := z.EncBinary()
 37259  					_ = yym17
 37260  					if false {
 37261  					} else if z.HasExtensions() && z.EncExt(x.Diff) {
 37262  					} else {
 37263  						z.EncFallback(x.Diff)
 37264  					}
 37265  				}
 37266  			}
 37267  			if yyr2 || yy2arr2 {
 37268  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 37269  				yy19 := &x.NextPeriodicLaunch
 37270  				yym20 := z.EncBinary()
 37271  				_ = yym20
 37272  				if false {
 37273  				} else if yym21 := z.TimeRtidIfBinc(); yym21 != 0 {
 37274  					r.EncodeBuiltin(yym21, yy19)
 37275  				} else if z.HasExtensions() && z.EncExt(yy19) {
 37276  				} else if yym20 {
 37277  					z.EncBinaryMarshal(yy19)
 37278  				} else if !yym20 && z.IsJSONHandle() {
 37279  					z.EncJSONMarshal(yy19)
 37280  				} else {
 37281  					z.EncFallback(yy19)
 37282  				}
 37283  			} else {
 37284  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 37285  				r.EncodeString(codecSelferC_UTF8100, string("NextPeriodicLaunch"))
 37286  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 37287  				yy22 := &x.NextPeriodicLaunch
 37288  				yym23 := z.EncBinary()
 37289  				_ = yym23
 37290  				if false {
 37291  				} else if yym24 := z.TimeRtidIfBinc(); yym24 != 0 {
 37292  					r.EncodeBuiltin(yym24, yy22)
 37293  				} else if z.HasExtensions() && z.EncExt(yy22) {
 37294  				} else if yym23 {
 37295  					z.EncBinaryMarshal(yy22)
 37296  				} else if !yym23 && z.IsJSONHandle() {
 37297  					z.EncJSONMarshal(yy22)
 37298  				} else {
 37299  					z.EncFallback(yy22)
 37300  				}
 37301  			}
 37302  			if yyr2 || yy2arr2 {
 37303  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 37304  				yym26 := z.EncBinary()
 37305  				_ = yym26
 37306  				if false {
 37307  				} else {
 37308  					r.EncodeString(codecSelferC_UTF8100, string(x.Warnings))
 37309  				}
 37310  			} else {
 37311  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 37312  				r.EncodeString(codecSelferC_UTF8100, string("Warnings"))
 37313  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 37314  				yym27 := z.EncBinary()
 37315  				_ = yym27
 37316  				if false {
 37317  				} else {
 37318  					r.EncodeString(codecSelferC_UTF8100, string(x.Warnings))
 37319  				}
 37320  			}
 37321  			if yyr2 || yy2arr2 {
 37322  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 37323  				yym29 := z.EncBinary()
 37324  				_ = yym29
 37325  				if false {
 37326  				} else {
 37327  					r.EncodeUint(uint64(x.Index))
 37328  				}
 37329  			} else {
 37330  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 37331  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 37332  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 37333  				yym30 := z.EncBinary()
 37334  				_ = yym30
 37335  				if false {
 37336  				} else {
 37337  					r.EncodeUint(uint64(x.Index))
 37338  				}
 37339  			}
 37340  			if yyr2 || yy2arr2 {
 37341  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 37342  			} else {
 37343  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 37344  			}
 37345  		}
 37346  	}
 37347  }
 37348  
 37349  func (x *JobPlanResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 37350  	var h codecSelfer100
 37351  	z, r := codec1978.GenHelperDecoder(d)
 37352  	_, _, _ = h, z, r
 37353  	yym1 := z.DecBinary()
 37354  	_ = yym1
 37355  	if false {
 37356  	} else if z.HasExtensions() && z.DecExt(x) {
 37357  	} else {
 37358  		yyct2 := r.ContainerType()
 37359  		if yyct2 == codecSelferValueTypeMap100 {
 37360  			yyl2 := r.ReadMapStart()
 37361  			if yyl2 == 0 {
 37362  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 37363  			} else {
 37364  				x.codecDecodeSelfFromMap(yyl2, d)
 37365  			}
 37366  		} else if yyct2 == codecSelferValueTypeArray100 {
 37367  			yyl2 := r.ReadArrayStart()
 37368  			if yyl2 == 0 {
 37369  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37370  			} else {
 37371  				x.codecDecodeSelfFromArray(yyl2, d)
 37372  			}
 37373  		} else {
 37374  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 37375  		}
 37376  	}
 37377  }
 37378  
 37379  func (x *JobPlanResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 37380  	var h codecSelfer100
 37381  	z, r := codec1978.GenHelperDecoder(d)
 37382  	_, _, _ = h, z, r
 37383  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 37384  	_ = yys3Slc
 37385  	var yyhl3 bool = l >= 0
 37386  	for yyj3 := 0; ; yyj3++ {
 37387  		if yyhl3 {
 37388  			if yyj3 >= l {
 37389  				break
 37390  			}
 37391  		} else {
 37392  			if r.CheckBreak() {
 37393  				break
 37394  			}
 37395  		}
 37396  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 37397  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 37398  		yys3 := string(yys3Slc)
 37399  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 37400  		switch yys3 {
 37401  		case "Annotations":
 37402  			if r.TryDecodeAsNil() {
 37403  				if x.Annotations != nil {
 37404  					x.Annotations = nil
 37405  				}
 37406  			} else {
 37407  				if x.Annotations == nil {
 37408  					x.Annotations = new(PlanAnnotations)
 37409  				}
 37410  				x.Annotations.CodecDecodeSelf(d)
 37411  			}
 37412  		case "FailedTGAllocs":
 37413  			if r.TryDecodeAsNil() {
 37414  				x.FailedTGAllocs = nil
 37415  			} else {
 37416  				yyv5 := &x.FailedTGAllocs
 37417  				yym6 := z.DecBinary()
 37418  				_ = yym6
 37419  				if false {
 37420  				} else {
 37421  					h.decMapstringPtrtoAllocMetric((*map[string]*AllocMetric)(yyv5), d)
 37422  				}
 37423  			}
 37424  		case "JobModifyIndex":
 37425  			if r.TryDecodeAsNil() {
 37426  				x.JobModifyIndex = 0
 37427  			} else {
 37428  				yyv7 := &x.JobModifyIndex
 37429  				yym8 := z.DecBinary()
 37430  				_ = yym8
 37431  				if false {
 37432  				} else {
 37433  					*((*uint64)(yyv7)) = uint64(r.DecodeUint(64))
 37434  				}
 37435  			}
 37436  		case "CreatedEvals":
 37437  			if r.TryDecodeAsNil() {
 37438  				x.CreatedEvals = nil
 37439  			} else {
 37440  				yyv9 := &x.CreatedEvals
 37441  				yym10 := z.DecBinary()
 37442  				_ = yym10
 37443  				if false {
 37444  				} else {
 37445  					h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv9), d)
 37446  				}
 37447  			}
 37448  		case "Diff":
 37449  			if r.TryDecodeAsNil() {
 37450  				if x.Diff != nil {
 37451  					x.Diff = nil
 37452  				}
 37453  			} else {
 37454  				if x.Diff == nil {
 37455  					x.Diff = new(JobDiff)
 37456  				}
 37457  				yym12 := z.DecBinary()
 37458  				_ = yym12
 37459  				if false {
 37460  				} else if z.HasExtensions() && z.DecExt(x.Diff) {
 37461  				} else {
 37462  					z.DecFallback(x.Diff, false)
 37463  				}
 37464  			}
 37465  		case "NextPeriodicLaunch":
 37466  			if r.TryDecodeAsNil() {
 37467  				x.NextPeriodicLaunch = time.Time{}
 37468  			} else {
 37469  				yyv13 := &x.NextPeriodicLaunch
 37470  				yym14 := z.DecBinary()
 37471  				_ = yym14
 37472  				if false {
 37473  				} else if yym15 := z.TimeRtidIfBinc(); yym15 != 0 {
 37474  					r.DecodeBuiltin(yym15, yyv13)
 37475  				} else if z.HasExtensions() && z.DecExt(yyv13) {
 37476  				} else if yym14 {
 37477  					z.DecBinaryUnmarshal(yyv13)
 37478  				} else if !yym14 && z.IsJSONHandle() {
 37479  					z.DecJSONUnmarshal(yyv13)
 37480  				} else {
 37481  					z.DecFallback(yyv13, false)
 37482  				}
 37483  			}
 37484  		case "Warnings":
 37485  			if r.TryDecodeAsNil() {
 37486  				x.Warnings = ""
 37487  			} else {
 37488  				yyv16 := &x.Warnings
 37489  				yym17 := z.DecBinary()
 37490  				_ = yym17
 37491  				if false {
 37492  				} else {
 37493  					*((*string)(yyv16)) = r.DecodeString()
 37494  				}
 37495  			}
 37496  		case "Index":
 37497  			if r.TryDecodeAsNil() {
 37498  				x.Index = 0
 37499  			} else {
 37500  				yyv18 := &x.Index
 37501  				yym19 := z.DecBinary()
 37502  				_ = yym19
 37503  				if false {
 37504  				} else {
 37505  					*((*uint64)(yyv18)) = uint64(r.DecodeUint(64))
 37506  				}
 37507  			}
 37508  		default:
 37509  			z.DecStructFieldNotFound(-1, yys3)
 37510  		} // end switch yys3
 37511  	} // end for yyj3
 37512  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 37513  }
 37514  
 37515  func (x *JobPlanResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 37516  	var h codecSelfer100
 37517  	z, r := codec1978.GenHelperDecoder(d)
 37518  	_, _, _ = h, z, r
 37519  	var yyj20 int
 37520  	var yyb20 bool
 37521  	var yyhl20 bool = l >= 0
 37522  	yyj20++
 37523  	if yyhl20 {
 37524  		yyb20 = yyj20 > l
 37525  	} else {
 37526  		yyb20 = r.CheckBreak()
 37527  	}
 37528  	if yyb20 {
 37529  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37530  		return
 37531  	}
 37532  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37533  	if r.TryDecodeAsNil() {
 37534  		if x.Annotations != nil {
 37535  			x.Annotations = nil
 37536  		}
 37537  	} else {
 37538  		if x.Annotations == nil {
 37539  			x.Annotations = new(PlanAnnotations)
 37540  		}
 37541  		x.Annotations.CodecDecodeSelf(d)
 37542  	}
 37543  	yyj20++
 37544  	if yyhl20 {
 37545  		yyb20 = yyj20 > l
 37546  	} else {
 37547  		yyb20 = r.CheckBreak()
 37548  	}
 37549  	if yyb20 {
 37550  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37551  		return
 37552  	}
 37553  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37554  	if r.TryDecodeAsNil() {
 37555  		x.FailedTGAllocs = nil
 37556  	} else {
 37557  		yyv22 := &x.FailedTGAllocs
 37558  		yym23 := z.DecBinary()
 37559  		_ = yym23
 37560  		if false {
 37561  		} else {
 37562  			h.decMapstringPtrtoAllocMetric((*map[string]*AllocMetric)(yyv22), d)
 37563  		}
 37564  	}
 37565  	yyj20++
 37566  	if yyhl20 {
 37567  		yyb20 = yyj20 > l
 37568  	} else {
 37569  		yyb20 = r.CheckBreak()
 37570  	}
 37571  	if yyb20 {
 37572  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37573  		return
 37574  	}
 37575  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37576  	if r.TryDecodeAsNil() {
 37577  		x.JobModifyIndex = 0
 37578  	} else {
 37579  		yyv24 := &x.JobModifyIndex
 37580  		yym25 := z.DecBinary()
 37581  		_ = yym25
 37582  		if false {
 37583  		} else {
 37584  			*((*uint64)(yyv24)) = uint64(r.DecodeUint(64))
 37585  		}
 37586  	}
 37587  	yyj20++
 37588  	if yyhl20 {
 37589  		yyb20 = yyj20 > l
 37590  	} else {
 37591  		yyb20 = r.CheckBreak()
 37592  	}
 37593  	if yyb20 {
 37594  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37595  		return
 37596  	}
 37597  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37598  	if r.TryDecodeAsNil() {
 37599  		x.CreatedEvals = nil
 37600  	} else {
 37601  		yyv26 := &x.CreatedEvals
 37602  		yym27 := z.DecBinary()
 37603  		_ = yym27
 37604  		if false {
 37605  		} else {
 37606  			h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv26), d)
 37607  		}
 37608  	}
 37609  	yyj20++
 37610  	if yyhl20 {
 37611  		yyb20 = yyj20 > l
 37612  	} else {
 37613  		yyb20 = r.CheckBreak()
 37614  	}
 37615  	if yyb20 {
 37616  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37617  		return
 37618  	}
 37619  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37620  	if r.TryDecodeAsNil() {
 37621  		if x.Diff != nil {
 37622  			x.Diff = nil
 37623  		}
 37624  	} else {
 37625  		if x.Diff == nil {
 37626  			x.Diff = new(JobDiff)
 37627  		}
 37628  		yym29 := z.DecBinary()
 37629  		_ = yym29
 37630  		if false {
 37631  		} else if z.HasExtensions() && z.DecExt(x.Diff) {
 37632  		} else {
 37633  			z.DecFallback(x.Diff, false)
 37634  		}
 37635  	}
 37636  	yyj20++
 37637  	if yyhl20 {
 37638  		yyb20 = yyj20 > l
 37639  	} else {
 37640  		yyb20 = r.CheckBreak()
 37641  	}
 37642  	if yyb20 {
 37643  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37644  		return
 37645  	}
 37646  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37647  	if r.TryDecodeAsNil() {
 37648  		x.NextPeriodicLaunch = time.Time{}
 37649  	} else {
 37650  		yyv30 := &x.NextPeriodicLaunch
 37651  		yym31 := z.DecBinary()
 37652  		_ = yym31
 37653  		if false {
 37654  		} else if yym32 := z.TimeRtidIfBinc(); yym32 != 0 {
 37655  			r.DecodeBuiltin(yym32, yyv30)
 37656  		} else if z.HasExtensions() && z.DecExt(yyv30) {
 37657  		} else if yym31 {
 37658  			z.DecBinaryUnmarshal(yyv30)
 37659  		} else if !yym31 && z.IsJSONHandle() {
 37660  			z.DecJSONUnmarshal(yyv30)
 37661  		} else {
 37662  			z.DecFallback(yyv30, false)
 37663  		}
 37664  	}
 37665  	yyj20++
 37666  	if yyhl20 {
 37667  		yyb20 = yyj20 > l
 37668  	} else {
 37669  		yyb20 = r.CheckBreak()
 37670  	}
 37671  	if yyb20 {
 37672  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37673  		return
 37674  	}
 37675  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37676  	if r.TryDecodeAsNil() {
 37677  		x.Warnings = ""
 37678  	} else {
 37679  		yyv33 := &x.Warnings
 37680  		yym34 := z.DecBinary()
 37681  		_ = yym34
 37682  		if false {
 37683  		} else {
 37684  			*((*string)(yyv33)) = r.DecodeString()
 37685  		}
 37686  	}
 37687  	yyj20++
 37688  	if yyhl20 {
 37689  		yyb20 = yyj20 > l
 37690  	} else {
 37691  		yyb20 = r.CheckBreak()
 37692  	}
 37693  	if yyb20 {
 37694  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37695  		return
 37696  	}
 37697  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37698  	if r.TryDecodeAsNil() {
 37699  		x.Index = 0
 37700  	} else {
 37701  		yyv35 := &x.Index
 37702  		yym36 := z.DecBinary()
 37703  		_ = yym36
 37704  		if false {
 37705  		} else {
 37706  			*((*uint64)(yyv35)) = uint64(r.DecodeUint(64))
 37707  		}
 37708  	}
 37709  	for {
 37710  		yyj20++
 37711  		if yyhl20 {
 37712  			yyb20 = yyj20 > l
 37713  		} else {
 37714  			yyb20 = r.CheckBreak()
 37715  		}
 37716  		if yyb20 {
 37717  			break
 37718  		}
 37719  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37720  		z.DecStructFieldNotFound(yyj20-1, "")
 37721  	}
 37722  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37723  }
 37724  
 37725  func (x *SingleAllocResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 37726  	var h codecSelfer100
 37727  	z, r := codec1978.GenHelperEncoder(e)
 37728  	_, _, _ = h, z, r
 37729  	if x == nil {
 37730  		r.EncodeNil()
 37731  	} else {
 37732  		yym1 := z.EncBinary()
 37733  		_ = yym1
 37734  		if false {
 37735  		} else if z.HasExtensions() && z.EncExt(x) {
 37736  		} else {
 37737  			yysep2 := !z.EncBinary()
 37738  			yy2arr2 := z.EncBasicHandle().StructToArray
 37739  			var yyq2 [4]bool
 37740  			_, _, _ = yysep2, yyq2, yy2arr2
 37741  			const yyr2 bool = false
 37742  			var yynn2 int
 37743  			if yyr2 || yy2arr2 {
 37744  				r.EncodeArrayStart(4)
 37745  			} else {
 37746  				yynn2 = 4
 37747  				for _, b := range yyq2 {
 37748  					if b {
 37749  						yynn2++
 37750  					}
 37751  				}
 37752  				r.EncodeMapStart(yynn2)
 37753  				yynn2 = 0
 37754  			}
 37755  			if yyr2 || yy2arr2 {
 37756  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 37757  				if x.Alloc == nil {
 37758  					r.EncodeNil()
 37759  				} else {
 37760  					x.Alloc.CodecEncodeSelf(e)
 37761  				}
 37762  			} else {
 37763  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 37764  				r.EncodeString(codecSelferC_UTF8100, string("Alloc"))
 37765  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 37766  				if x.Alloc == nil {
 37767  					r.EncodeNil()
 37768  				} else {
 37769  					x.Alloc.CodecEncodeSelf(e)
 37770  				}
 37771  			}
 37772  			if yyr2 || yy2arr2 {
 37773  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 37774  				yym7 := z.EncBinary()
 37775  				_ = yym7
 37776  				if false {
 37777  				} else {
 37778  					r.EncodeUint(uint64(x.Index))
 37779  				}
 37780  			} else {
 37781  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 37782  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 37783  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 37784  				yym8 := z.EncBinary()
 37785  				_ = yym8
 37786  				if false {
 37787  				} else {
 37788  					r.EncodeUint(uint64(x.Index))
 37789  				}
 37790  			}
 37791  			if yyr2 || yy2arr2 {
 37792  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 37793  				yym10 := z.EncBinary()
 37794  				_ = yym10
 37795  				if false {
 37796  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 37797  				} else {
 37798  					r.EncodeInt(int64(x.LastContact))
 37799  				}
 37800  			} else {
 37801  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 37802  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 37803  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 37804  				yym11 := z.EncBinary()
 37805  				_ = yym11
 37806  				if false {
 37807  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 37808  				} else {
 37809  					r.EncodeInt(int64(x.LastContact))
 37810  				}
 37811  			}
 37812  			if yyr2 || yy2arr2 {
 37813  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 37814  				yym13 := z.EncBinary()
 37815  				_ = yym13
 37816  				if false {
 37817  				} else {
 37818  					r.EncodeBool(bool(x.KnownLeader))
 37819  				}
 37820  			} else {
 37821  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 37822  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 37823  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 37824  				yym14 := z.EncBinary()
 37825  				_ = yym14
 37826  				if false {
 37827  				} else {
 37828  					r.EncodeBool(bool(x.KnownLeader))
 37829  				}
 37830  			}
 37831  			if yyr2 || yy2arr2 {
 37832  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 37833  			} else {
 37834  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 37835  			}
 37836  		}
 37837  	}
 37838  }
 37839  
 37840  func (x *SingleAllocResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 37841  	var h codecSelfer100
 37842  	z, r := codec1978.GenHelperDecoder(d)
 37843  	_, _, _ = h, z, r
 37844  	yym1 := z.DecBinary()
 37845  	_ = yym1
 37846  	if false {
 37847  	} else if z.HasExtensions() && z.DecExt(x) {
 37848  	} else {
 37849  		yyct2 := r.ContainerType()
 37850  		if yyct2 == codecSelferValueTypeMap100 {
 37851  			yyl2 := r.ReadMapStart()
 37852  			if yyl2 == 0 {
 37853  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 37854  			} else {
 37855  				x.codecDecodeSelfFromMap(yyl2, d)
 37856  			}
 37857  		} else if yyct2 == codecSelferValueTypeArray100 {
 37858  			yyl2 := r.ReadArrayStart()
 37859  			if yyl2 == 0 {
 37860  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37861  			} else {
 37862  				x.codecDecodeSelfFromArray(yyl2, d)
 37863  			}
 37864  		} else {
 37865  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 37866  		}
 37867  	}
 37868  }
 37869  
 37870  func (x *SingleAllocResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 37871  	var h codecSelfer100
 37872  	z, r := codec1978.GenHelperDecoder(d)
 37873  	_, _, _ = h, z, r
 37874  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 37875  	_ = yys3Slc
 37876  	var yyhl3 bool = l >= 0
 37877  	for yyj3 := 0; ; yyj3++ {
 37878  		if yyhl3 {
 37879  			if yyj3 >= l {
 37880  				break
 37881  			}
 37882  		} else {
 37883  			if r.CheckBreak() {
 37884  				break
 37885  			}
 37886  		}
 37887  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 37888  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 37889  		yys3 := string(yys3Slc)
 37890  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 37891  		switch yys3 {
 37892  		case "Alloc":
 37893  			if r.TryDecodeAsNil() {
 37894  				if x.Alloc != nil {
 37895  					x.Alloc = nil
 37896  				}
 37897  			} else {
 37898  				if x.Alloc == nil {
 37899  					x.Alloc = new(Allocation)
 37900  				}
 37901  				x.Alloc.CodecDecodeSelf(d)
 37902  			}
 37903  		case "Index":
 37904  			if r.TryDecodeAsNil() {
 37905  				x.Index = 0
 37906  			} else {
 37907  				yyv5 := &x.Index
 37908  				yym6 := z.DecBinary()
 37909  				_ = yym6
 37910  				if false {
 37911  				} else {
 37912  					*((*uint64)(yyv5)) = uint64(r.DecodeUint(64))
 37913  				}
 37914  			}
 37915  		case "LastContact":
 37916  			if r.TryDecodeAsNil() {
 37917  				x.LastContact = 0
 37918  			} else {
 37919  				yyv7 := &x.LastContact
 37920  				yym8 := z.DecBinary()
 37921  				_ = yym8
 37922  				if false {
 37923  				} else if z.HasExtensions() && z.DecExt(yyv7) {
 37924  				} else {
 37925  					*((*int64)(yyv7)) = int64(r.DecodeInt(64))
 37926  				}
 37927  			}
 37928  		case "KnownLeader":
 37929  			if r.TryDecodeAsNil() {
 37930  				x.KnownLeader = false
 37931  			} else {
 37932  				yyv9 := &x.KnownLeader
 37933  				yym10 := z.DecBinary()
 37934  				_ = yym10
 37935  				if false {
 37936  				} else {
 37937  					*((*bool)(yyv9)) = r.DecodeBool()
 37938  				}
 37939  			}
 37940  		default:
 37941  			z.DecStructFieldNotFound(-1, yys3)
 37942  		} // end switch yys3
 37943  	} // end for yyj3
 37944  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 37945  }
 37946  
 37947  func (x *SingleAllocResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 37948  	var h codecSelfer100
 37949  	z, r := codec1978.GenHelperDecoder(d)
 37950  	_, _, _ = h, z, r
 37951  	var yyj11 int
 37952  	var yyb11 bool
 37953  	var yyhl11 bool = l >= 0
 37954  	yyj11++
 37955  	if yyhl11 {
 37956  		yyb11 = yyj11 > l
 37957  	} else {
 37958  		yyb11 = r.CheckBreak()
 37959  	}
 37960  	if yyb11 {
 37961  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37962  		return
 37963  	}
 37964  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37965  	if r.TryDecodeAsNil() {
 37966  		if x.Alloc != nil {
 37967  			x.Alloc = nil
 37968  		}
 37969  	} else {
 37970  		if x.Alloc == nil {
 37971  			x.Alloc = new(Allocation)
 37972  		}
 37973  		x.Alloc.CodecDecodeSelf(d)
 37974  	}
 37975  	yyj11++
 37976  	if yyhl11 {
 37977  		yyb11 = yyj11 > l
 37978  	} else {
 37979  		yyb11 = r.CheckBreak()
 37980  	}
 37981  	if yyb11 {
 37982  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 37983  		return
 37984  	}
 37985  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 37986  	if r.TryDecodeAsNil() {
 37987  		x.Index = 0
 37988  	} else {
 37989  		yyv13 := &x.Index
 37990  		yym14 := z.DecBinary()
 37991  		_ = yym14
 37992  		if false {
 37993  		} else {
 37994  			*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 37995  		}
 37996  	}
 37997  	yyj11++
 37998  	if yyhl11 {
 37999  		yyb11 = yyj11 > l
 38000  	} else {
 38001  		yyb11 = r.CheckBreak()
 38002  	}
 38003  	if yyb11 {
 38004  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38005  		return
 38006  	}
 38007  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 38008  	if r.TryDecodeAsNil() {
 38009  		x.LastContact = 0
 38010  	} else {
 38011  		yyv15 := &x.LastContact
 38012  		yym16 := z.DecBinary()
 38013  		_ = yym16
 38014  		if false {
 38015  		} else if z.HasExtensions() && z.DecExt(yyv15) {
 38016  		} else {
 38017  			*((*int64)(yyv15)) = int64(r.DecodeInt(64))
 38018  		}
 38019  	}
 38020  	yyj11++
 38021  	if yyhl11 {
 38022  		yyb11 = yyj11 > l
 38023  	} else {
 38024  		yyb11 = r.CheckBreak()
 38025  	}
 38026  	if yyb11 {
 38027  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38028  		return
 38029  	}
 38030  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 38031  	if r.TryDecodeAsNil() {
 38032  		x.KnownLeader = false
 38033  	} else {
 38034  		yyv17 := &x.KnownLeader
 38035  		yym18 := z.DecBinary()
 38036  		_ = yym18
 38037  		if false {
 38038  		} else {
 38039  			*((*bool)(yyv17)) = r.DecodeBool()
 38040  		}
 38041  	}
 38042  	for {
 38043  		yyj11++
 38044  		if yyhl11 {
 38045  			yyb11 = yyj11 > l
 38046  		} else {
 38047  			yyb11 = r.CheckBreak()
 38048  		}
 38049  		if yyb11 {
 38050  			break
 38051  		}
 38052  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 38053  		z.DecStructFieldNotFound(yyj11-1, "")
 38054  	}
 38055  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38056  }
 38057  
 38058  func (x *AllocsGetResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 38059  	var h codecSelfer100
 38060  	z, r := codec1978.GenHelperEncoder(e)
 38061  	_, _, _ = h, z, r
 38062  	if x == nil {
 38063  		r.EncodeNil()
 38064  	} else {
 38065  		yym1 := z.EncBinary()
 38066  		_ = yym1
 38067  		if false {
 38068  		} else if z.HasExtensions() && z.EncExt(x) {
 38069  		} else {
 38070  			yysep2 := !z.EncBinary()
 38071  			yy2arr2 := z.EncBasicHandle().StructToArray
 38072  			var yyq2 [4]bool
 38073  			_, _, _ = yysep2, yyq2, yy2arr2
 38074  			const yyr2 bool = false
 38075  			var yynn2 int
 38076  			if yyr2 || yy2arr2 {
 38077  				r.EncodeArrayStart(4)
 38078  			} else {
 38079  				yynn2 = 4
 38080  				for _, b := range yyq2 {
 38081  					if b {
 38082  						yynn2++
 38083  					}
 38084  				}
 38085  				r.EncodeMapStart(yynn2)
 38086  				yynn2 = 0
 38087  			}
 38088  			if yyr2 || yy2arr2 {
 38089  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 38090  				if x.Allocs == nil {
 38091  					r.EncodeNil()
 38092  				} else {
 38093  					yym4 := z.EncBinary()
 38094  					_ = yym4
 38095  					if false {
 38096  					} else {
 38097  						h.encSlicePtrtoAllocation(([]*Allocation)(x.Allocs), e)
 38098  					}
 38099  				}
 38100  			} else {
 38101  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 38102  				r.EncodeString(codecSelferC_UTF8100, string("Allocs"))
 38103  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 38104  				if x.Allocs == nil {
 38105  					r.EncodeNil()
 38106  				} else {
 38107  					yym5 := z.EncBinary()
 38108  					_ = yym5
 38109  					if false {
 38110  					} else {
 38111  						h.encSlicePtrtoAllocation(([]*Allocation)(x.Allocs), e)
 38112  					}
 38113  				}
 38114  			}
 38115  			if yyr2 || yy2arr2 {
 38116  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 38117  				yym7 := z.EncBinary()
 38118  				_ = yym7
 38119  				if false {
 38120  				} else {
 38121  					r.EncodeUint(uint64(x.Index))
 38122  				}
 38123  			} else {
 38124  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 38125  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 38126  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 38127  				yym8 := z.EncBinary()
 38128  				_ = yym8
 38129  				if false {
 38130  				} else {
 38131  					r.EncodeUint(uint64(x.Index))
 38132  				}
 38133  			}
 38134  			if yyr2 || yy2arr2 {
 38135  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 38136  				yym10 := z.EncBinary()
 38137  				_ = yym10
 38138  				if false {
 38139  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 38140  				} else {
 38141  					r.EncodeInt(int64(x.LastContact))
 38142  				}
 38143  			} else {
 38144  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 38145  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 38146  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 38147  				yym11 := z.EncBinary()
 38148  				_ = yym11
 38149  				if false {
 38150  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 38151  				} else {
 38152  					r.EncodeInt(int64(x.LastContact))
 38153  				}
 38154  			}
 38155  			if yyr2 || yy2arr2 {
 38156  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 38157  				yym13 := z.EncBinary()
 38158  				_ = yym13
 38159  				if false {
 38160  				} else {
 38161  					r.EncodeBool(bool(x.KnownLeader))
 38162  				}
 38163  			} else {
 38164  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 38165  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 38166  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 38167  				yym14 := z.EncBinary()
 38168  				_ = yym14
 38169  				if false {
 38170  				} else {
 38171  					r.EncodeBool(bool(x.KnownLeader))
 38172  				}
 38173  			}
 38174  			if yyr2 || yy2arr2 {
 38175  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 38176  			} else {
 38177  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 38178  			}
 38179  		}
 38180  	}
 38181  }
 38182  
 38183  func (x *AllocsGetResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 38184  	var h codecSelfer100
 38185  	z, r := codec1978.GenHelperDecoder(d)
 38186  	_, _, _ = h, z, r
 38187  	yym1 := z.DecBinary()
 38188  	_ = yym1
 38189  	if false {
 38190  	} else if z.HasExtensions() && z.DecExt(x) {
 38191  	} else {
 38192  		yyct2 := r.ContainerType()
 38193  		if yyct2 == codecSelferValueTypeMap100 {
 38194  			yyl2 := r.ReadMapStart()
 38195  			if yyl2 == 0 {
 38196  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 38197  			} else {
 38198  				x.codecDecodeSelfFromMap(yyl2, d)
 38199  			}
 38200  		} else if yyct2 == codecSelferValueTypeArray100 {
 38201  			yyl2 := r.ReadArrayStart()
 38202  			if yyl2 == 0 {
 38203  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38204  			} else {
 38205  				x.codecDecodeSelfFromArray(yyl2, d)
 38206  			}
 38207  		} else {
 38208  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 38209  		}
 38210  	}
 38211  }
 38212  
 38213  func (x *AllocsGetResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 38214  	var h codecSelfer100
 38215  	z, r := codec1978.GenHelperDecoder(d)
 38216  	_, _, _ = h, z, r
 38217  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 38218  	_ = yys3Slc
 38219  	var yyhl3 bool = l >= 0
 38220  	for yyj3 := 0; ; yyj3++ {
 38221  		if yyhl3 {
 38222  			if yyj3 >= l {
 38223  				break
 38224  			}
 38225  		} else {
 38226  			if r.CheckBreak() {
 38227  				break
 38228  			}
 38229  		}
 38230  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 38231  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 38232  		yys3 := string(yys3Slc)
 38233  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 38234  		switch yys3 {
 38235  		case "Allocs":
 38236  			if r.TryDecodeAsNil() {
 38237  				x.Allocs = nil
 38238  			} else {
 38239  				yyv4 := &x.Allocs
 38240  				yym5 := z.DecBinary()
 38241  				_ = yym5
 38242  				if false {
 38243  				} else {
 38244  					h.decSlicePtrtoAllocation((*[]*Allocation)(yyv4), d)
 38245  				}
 38246  			}
 38247  		case "Index":
 38248  			if r.TryDecodeAsNil() {
 38249  				x.Index = 0
 38250  			} else {
 38251  				yyv6 := &x.Index
 38252  				yym7 := z.DecBinary()
 38253  				_ = yym7
 38254  				if false {
 38255  				} else {
 38256  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 38257  				}
 38258  			}
 38259  		case "LastContact":
 38260  			if r.TryDecodeAsNil() {
 38261  				x.LastContact = 0
 38262  			} else {
 38263  				yyv8 := &x.LastContact
 38264  				yym9 := z.DecBinary()
 38265  				_ = yym9
 38266  				if false {
 38267  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 38268  				} else {
 38269  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 38270  				}
 38271  			}
 38272  		case "KnownLeader":
 38273  			if r.TryDecodeAsNil() {
 38274  				x.KnownLeader = false
 38275  			} else {
 38276  				yyv10 := &x.KnownLeader
 38277  				yym11 := z.DecBinary()
 38278  				_ = yym11
 38279  				if false {
 38280  				} else {
 38281  					*((*bool)(yyv10)) = r.DecodeBool()
 38282  				}
 38283  			}
 38284  		default:
 38285  			z.DecStructFieldNotFound(-1, yys3)
 38286  		} // end switch yys3
 38287  	} // end for yyj3
 38288  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 38289  }
 38290  
 38291  func (x *AllocsGetResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 38292  	var h codecSelfer100
 38293  	z, r := codec1978.GenHelperDecoder(d)
 38294  	_, _, _ = h, z, r
 38295  	var yyj12 int
 38296  	var yyb12 bool
 38297  	var yyhl12 bool = l >= 0
 38298  	yyj12++
 38299  	if yyhl12 {
 38300  		yyb12 = yyj12 > l
 38301  	} else {
 38302  		yyb12 = r.CheckBreak()
 38303  	}
 38304  	if yyb12 {
 38305  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38306  		return
 38307  	}
 38308  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 38309  	if r.TryDecodeAsNil() {
 38310  		x.Allocs = nil
 38311  	} else {
 38312  		yyv13 := &x.Allocs
 38313  		yym14 := z.DecBinary()
 38314  		_ = yym14
 38315  		if false {
 38316  		} else {
 38317  			h.decSlicePtrtoAllocation((*[]*Allocation)(yyv13), d)
 38318  		}
 38319  	}
 38320  	yyj12++
 38321  	if yyhl12 {
 38322  		yyb12 = yyj12 > l
 38323  	} else {
 38324  		yyb12 = r.CheckBreak()
 38325  	}
 38326  	if yyb12 {
 38327  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38328  		return
 38329  	}
 38330  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 38331  	if r.TryDecodeAsNil() {
 38332  		x.Index = 0
 38333  	} else {
 38334  		yyv15 := &x.Index
 38335  		yym16 := z.DecBinary()
 38336  		_ = yym16
 38337  		if false {
 38338  		} else {
 38339  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 38340  		}
 38341  	}
 38342  	yyj12++
 38343  	if yyhl12 {
 38344  		yyb12 = yyj12 > l
 38345  	} else {
 38346  		yyb12 = r.CheckBreak()
 38347  	}
 38348  	if yyb12 {
 38349  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38350  		return
 38351  	}
 38352  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 38353  	if r.TryDecodeAsNil() {
 38354  		x.LastContact = 0
 38355  	} else {
 38356  		yyv17 := &x.LastContact
 38357  		yym18 := z.DecBinary()
 38358  		_ = yym18
 38359  		if false {
 38360  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 38361  		} else {
 38362  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 38363  		}
 38364  	}
 38365  	yyj12++
 38366  	if yyhl12 {
 38367  		yyb12 = yyj12 > l
 38368  	} else {
 38369  		yyb12 = r.CheckBreak()
 38370  	}
 38371  	if yyb12 {
 38372  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38373  		return
 38374  	}
 38375  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 38376  	if r.TryDecodeAsNil() {
 38377  		x.KnownLeader = false
 38378  	} else {
 38379  		yyv19 := &x.KnownLeader
 38380  		yym20 := z.DecBinary()
 38381  		_ = yym20
 38382  		if false {
 38383  		} else {
 38384  			*((*bool)(yyv19)) = r.DecodeBool()
 38385  		}
 38386  	}
 38387  	for {
 38388  		yyj12++
 38389  		if yyhl12 {
 38390  			yyb12 = yyj12 > l
 38391  		} else {
 38392  			yyb12 = r.CheckBreak()
 38393  		}
 38394  		if yyb12 {
 38395  			break
 38396  		}
 38397  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 38398  		z.DecStructFieldNotFound(yyj12-1, "")
 38399  	}
 38400  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38401  }
 38402  
 38403  func (x *JobAllocationsResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 38404  	var h codecSelfer100
 38405  	z, r := codec1978.GenHelperEncoder(e)
 38406  	_, _, _ = h, z, r
 38407  	if x == nil {
 38408  		r.EncodeNil()
 38409  	} else {
 38410  		yym1 := z.EncBinary()
 38411  		_ = yym1
 38412  		if false {
 38413  		} else if z.HasExtensions() && z.EncExt(x) {
 38414  		} else {
 38415  			yysep2 := !z.EncBinary()
 38416  			yy2arr2 := z.EncBasicHandle().StructToArray
 38417  			var yyq2 [4]bool
 38418  			_, _, _ = yysep2, yyq2, yy2arr2
 38419  			const yyr2 bool = false
 38420  			var yynn2 int
 38421  			if yyr2 || yy2arr2 {
 38422  				r.EncodeArrayStart(4)
 38423  			} else {
 38424  				yynn2 = 4
 38425  				for _, b := range yyq2 {
 38426  					if b {
 38427  						yynn2++
 38428  					}
 38429  				}
 38430  				r.EncodeMapStart(yynn2)
 38431  				yynn2 = 0
 38432  			}
 38433  			if yyr2 || yy2arr2 {
 38434  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 38435  				if x.Allocations == nil {
 38436  					r.EncodeNil()
 38437  				} else {
 38438  					yym4 := z.EncBinary()
 38439  					_ = yym4
 38440  					if false {
 38441  					} else {
 38442  						h.encSlicePtrtoAllocListStub(([]*AllocListStub)(x.Allocations), e)
 38443  					}
 38444  				}
 38445  			} else {
 38446  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 38447  				r.EncodeString(codecSelferC_UTF8100, string("Allocations"))
 38448  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 38449  				if x.Allocations == nil {
 38450  					r.EncodeNil()
 38451  				} else {
 38452  					yym5 := z.EncBinary()
 38453  					_ = yym5
 38454  					if false {
 38455  					} else {
 38456  						h.encSlicePtrtoAllocListStub(([]*AllocListStub)(x.Allocations), e)
 38457  					}
 38458  				}
 38459  			}
 38460  			if yyr2 || yy2arr2 {
 38461  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 38462  				yym7 := z.EncBinary()
 38463  				_ = yym7
 38464  				if false {
 38465  				} else {
 38466  					r.EncodeUint(uint64(x.Index))
 38467  				}
 38468  			} else {
 38469  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 38470  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 38471  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 38472  				yym8 := z.EncBinary()
 38473  				_ = yym8
 38474  				if false {
 38475  				} else {
 38476  					r.EncodeUint(uint64(x.Index))
 38477  				}
 38478  			}
 38479  			if yyr2 || yy2arr2 {
 38480  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 38481  				yym10 := z.EncBinary()
 38482  				_ = yym10
 38483  				if false {
 38484  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 38485  				} else {
 38486  					r.EncodeInt(int64(x.LastContact))
 38487  				}
 38488  			} else {
 38489  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 38490  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 38491  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 38492  				yym11 := z.EncBinary()
 38493  				_ = yym11
 38494  				if false {
 38495  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 38496  				} else {
 38497  					r.EncodeInt(int64(x.LastContact))
 38498  				}
 38499  			}
 38500  			if yyr2 || yy2arr2 {
 38501  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 38502  				yym13 := z.EncBinary()
 38503  				_ = yym13
 38504  				if false {
 38505  				} else {
 38506  					r.EncodeBool(bool(x.KnownLeader))
 38507  				}
 38508  			} else {
 38509  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 38510  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 38511  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 38512  				yym14 := z.EncBinary()
 38513  				_ = yym14
 38514  				if false {
 38515  				} else {
 38516  					r.EncodeBool(bool(x.KnownLeader))
 38517  				}
 38518  			}
 38519  			if yyr2 || yy2arr2 {
 38520  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 38521  			} else {
 38522  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 38523  			}
 38524  		}
 38525  	}
 38526  }
 38527  
 38528  func (x *JobAllocationsResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 38529  	var h codecSelfer100
 38530  	z, r := codec1978.GenHelperDecoder(d)
 38531  	_, _, _ = h, z, r
 38532  	yym1 := z.DecBinary()
 38533  	_ = yym1
 38534  	if false {
 38535  	} else if z.HasExtensions() && z.DecExt(x) {
 38536  	} else {
 38537  		yyct2 := r.ContainerType()
 38538  		if yyct2 == codecSelferValueTypeMap100 {
 38539  			yyl2 := r.ReadMapStart()
 38540  			if yyl2 == 0 {
 38541  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 38542  			} else {
 38543  				x.codecDecodeSelfFromMap(yyl2, d)
 38544  			}
 38545  		} else if yyct2 == codecSelferValueTypeArray100 {
 38546  			yyl2 := r.ReadArrayStart()
 38547  			if yyl2 == 0 {
 38548  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38549  			} else {
 38550  				x.codecDecodeSelfFromArray(yyl2, d)
 38551  			}
 38552  		} else {
 38553  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 38554  		}
 38555  	}
 38556  }
 38557  
 38558  func (x *JobAllocationsResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 38559  	var h codecSelfer100
 38560  	z, r := codec1978.GenHelperDecoder(d)
 38561  	_, _, _ = h, z, r
 38562  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 38563  	_ = yys3Slc
 38564  	var yyhl3 bool = l >= 0
 38565  	for yyj3 := 0; ; yyj3++ {
 38566  		if yyhl3 {
 38567  			if yyj3 >= l {
 38568  				break
 38569  			}
 38570  		} else {
 38571  			if r.CheckBreak() {
 38572  				break
 38573  			}
 38574  		}
 38575  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 38576  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 38577  		yys3 := string(yys3Slc)
 38578  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 38579  		switch yys3 {
 38580  		case "Allocations":
 38581  			if r.TryDecodeAsNil() {
 38582  				x.Allocations = nil
 38583  			} else {
 38584  				yyv4 := &x.Allocations
 38585  				yym5 := z.DecBinary()
 38586  				_ = yym5
 38587  				if false {
 38588  				} else {
 38589  					h.decSlicePtrtoAllocListStub((*[]*AllocListStub)(yyv4), d)
 38590  				}
 38591  			}
 38592  		case "Index":
 38593  			if r.TryDecodeAsNil() {
 38594  				x.Index = 0
 38595  			} else {
 38596  				yyv6 := &x.Index
 38597  				yym7 := z.DecBinary()
 38598  				_ = yym7
 38599  				if false {
 38600  				} else {
 38601  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 38602  				}
 38603  			}
 38604  		case "LastContact":
 38605  			if r.TryDecodeAsNil() {
 38606  				x.LastContact = 0
 38607  			} else {
 38608  				yyv8 := &x.LastContact
 38609  				yym9 := z.DecBinary()
 38610  				_ = yym9
 38611  				if false {
 38612  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 38613  				} else {
 38614  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 38615  				}
 38616  			}
 38617  		case "KnownLeader":
 38618  			if r.TryDecodeAsNil() {
 38619  				x.KnownLeader = false
 38620  			} else {
 38621  				yyv10 := &x.KnownLeader
 38622  				yym11 := z.DecBinary()
 38623  				_ = yym11
 38624  				if false {
 38625  				} else {
 38626  					*((*bool)(yyv10)) = r.DecodeBool()
 38627  				}
 38628  			}
 38629  		default:
 38630  			z.DecStructFieldNotFound(-1, yys3)
 38631  		} // end switch yys3
 38632  	} // end for yyj3
 38633  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 38634  }
 38635  
 38636  func (x *JobAllocationsResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 38637  	var h codecSelfer100
 38638  	z, r := codec1978.GenHelperDecoder(d)
 38639  	_, _, _ = h, z, r
 38640  	var yyj12 int
 38641  	var yyb12 bool
 38642  	var yyhl12 bool = l >= 0
 38643  	yyj12++
 38644  	if yyhl12 {
 38645  		yyb12 = yyj12 > l
 38646  	} else {
 38647  		yyb12 = r.CheckBreak()
 38648  	}
 38649  	if yyb12 {
 38650  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38651  		return
 38652  	}
 38653  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 38654  	if r.TryDecodeAsNil() {
 38655  		x.Allocations = nil
 38656  	} else {
 38657  		yyv13 := &x.Allocations
 38658  		yym14 := z.DecBinary()
 38659  		_ = yym14
 38660  		if false {
 38661  		} else {
 38662  			h.decSlicePtrtoAllocListStub((*[]*AllocListStub)(yyv13), d)
 38663  		}
 38664  	}
 38665  	yyj12++
 38666  	if yyhl12 {
 38667  		yyb12 = yyj12 > l
 38668  	} else {
 38669  		yyb12 = r.CheckBreak()
 38670  	}
 38671  	if yyb12 {
 38672  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38673  		return
 38674  	}
 38675  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 38676  	if r.TryDecodeAsNil() {
 38677  		x.Index = 0
 38678  	} else {
 38679  		yyv15 := &x.Index
 38680  		yym16 := z.DecBinary()
 38681  		_ = yym16
 38682  		if false {
 38683  		} else {
 38684  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 38685  		}
 38686  	}
 38687  	yyj12++
 38688  	if yyhl12 {
 38689  		yyb12 = yyj12 > l
 38690  	} else {
 38691  		yyb12 = r.CheckBreak()
 38692  	}
 38693  	if yyb12 {
 38694  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38695  		return
 38696  	}
 38697  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 38698  	if r.TryDecodeAsNil() {
 38699  		x.LastContact = 0
 38700  	} else {
 38701  		yyv17 := &x.LastContact
 38702  		yym18 := z.DecBinary()
 38703  		_ = yym18
 38704  		if false {
 38705  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 38706  		} else {
 38707  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 38708  		}
 38709  	}
 38710  	yyj12++
 38711  	if yyhl12 {
 38712  		yyb12 = yyj12 > l
 38713  	} else {
 38714  		yyb12 = r.CheckBreak()
 38715  	}
 38716  	if yyb12 {
 38717  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38718  		return
 38719  	}
 38720  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 38721  	if r.TryDecodeAsNil() {
 38722  		x.KnownLeader = false
 38723  	} else {
 38724  		yyv19 := &x.KnownLeader
 38725  		yym20 := z.DecBinary()
 38726  		_ = yym20
 38727  		if false {
 38728  		} else {
 38729  			*((*bool)(yyv19)) = r.DecodeBool()
 38730  		}
 38731  	}
 38732  	for {
 38733  		yyj12++
 38734  		if yyhl12 {
 38735  			yyb12 = yyj12 > l
 38736  		} else {
 38737  			yyb12 = r.CheckBreak()
 38738  		}
 38739  		if yyb12 {
 38740  			break
 38741  		}
 38742  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 38743  		z.DecStructFieldNotFound(yyj12-1, "")
 38744  	}
 38745  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38746  }
 38747  
 38748  func (x *JobEvaluationsResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 38749  	var h codecSelfer100
 38750  	z, r := codec1978.GenHelperEncoder(e)
 38751  	_, _, _ = h, z, r
 38752  	if x == nil {
 38753  		r.EncodeNil()
 38754  	} else {
 38755  		yym1 := z.EncBinary()
 38756  		_ = yym1
 38757  		if false {
 38758  		} else if z.HasExtensions() && z.EncExt(x) {
 38759  		} else {
 38760  			yysep2 := !z.EncBinary()
 38761  			yy2arr2 := z.EncBasicHandle().StructToArray
 38762  			var yyq2 [4]bool
 38763  			_, _, _ = yysep2, yyq2, yy2arr2
 38764  			const yyr2 bool = false
 38765  			var yynn2 int
 38766  			if yyr2 || yy2arr2 {
 38767  				r.EncodeArrayStart(4)
 38768  			} else {
 38769  				yynn2 = 4
 38770  				for _, b := range yyq2 {
 38771  					if b {
 38772  						yynn2++
 38773  					}
 38774  				}
 38775  				r.EncodeMapStart(yynn2)
 38776  				yynn2 = 0
 38777  			}
 38778  			if yyr2 || yy2arr2 {
 38779  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 38780  				if x.Evaluations == nil {
 38781  					r.EncodeNil()
 38782  				} else {
 38783  					yym4 := z.EncBinary()
 38784  					_ = yym4
 38785  					if false {
 38786  					} else {
 38787  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.Evaluations), e)
 38788  					}
 38789  				}
 38790  			} else {
 38791  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 38792  				r.EncodeString(codecSelferC_UTF8100, string("Evaluations"))
 38793  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 38794  				if x.Evaluations == nil {
 38795  					r.EncodeNil()
 38796  				} else {
 38797  					yym5 := z.EncBinary()
 38798  					_ = yym5
 38799  					if false {
 38800  					} else {
 38801  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.Evaluations), e)
 38802  					}
 38803  				}
 38804  			}
 38805  			if yyr2 || yy2arr2 {
 38806  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 38807  				yym7 := z.EncBinary()
 38808  				_ = yym7
 38809  				if false {
 38810  				} else {
 38811  					r.EncodeUint(uint64(x.Index))
 38812  				}
 38813  			} else {
 38814  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 38815  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 38816  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 38817  				yym8 := z.EncBinary()
 38818  				_ = yym8
 38819  				if false {
 38820  				} else {
 38821  					r.EncodeUint(uint64(x.Index))
 38822  				}
 38823  			}
 38824  			if yyr2 || yy2arr2 {
 38825  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 38826  				yym10 := z.EncBinary()
 38827  				_ = yym10
 38828  				if false {
 38829  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 38830  				} else {
 38831  					r.EncodeInt(int64(x.LastContact))
 38832  				}
 38833  			} else {
 38834  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 38835  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 38836  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 38837  				yym11 := z.EncBinary()
 38838  				_ = yym11
 38839  				if false {
 38840  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 38841  				} else {
 38842  					r.EncodeInt(int64(x.LastContact))
 38843  				}
 38844  			}
 38845  			if yyr2 || yy2arr2 {
 38846  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 38847  				yym13 := z.EncBinary()
 38848  				_ = yym13
 38849  				if false {
 38850  				} else {
 38851  					r.EncodeBool(bool(x.KnownLeader))
 38852  				}
 38853  			} else {
 38854  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 38855  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 38856  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 38857  				yym14 := z.EncBinary()
 38858  				_ = yym14
 38859  				if false {
 38860  				} else {
 38861  					r.EncodeBool(bool(x.KnownLeader))
 38862  				}
 38863  			}
 38864  			if yyr2 || yy2arr2 {
 38865  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 38866  			} else {
 38867  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 38868  			}
 38869  		}
 38870  	}
 38871  }
 38872  
 38873  func (x *JobEvaluationsResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 38874  	var h codecSelfer100
 38875  	z, r := codec1978.GenHelperDecoder(d)
 38876  	_, _, _ = h, z, r
 38877  	yym1 := z.DecBinary()
 38878  	_ = yym1
 38879  	if false {
 38880  	} else if z.HasExtensions() && z.DecExt(x) {
 38881  	} else {
 38882  		yyct2 := r.ContainerType()
 38883  		if yyct2 == codecSelferValueTypeMap100 {
 38884  			yyl2 := r.ReadMapStart()
 38885  			if yyl2 == 0 {
 38886  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 38887  			} else {
 38888  				x.codecDecodeSelfFromMap(yyl2, d)
 38889  			}
 38890  		} else if yyct2 == codecSelferValueTypeArray100 {
 38891  			yyl2 := r.ReadArrayStart()
 38892  			if yyl2 == 0 {
 38893  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38894  			} else {
 38895  				x.codecDecodeSelfFromArray(yyl2, d)
 38896  			}
 38897  		} else {
 38898  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 38899  		}
 38900  	}
 38901  }
 38902  
 38903  func (x *JobEvaluationsResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 38904  	var h codecSelfer100
 38905  	z, r := codec1978.GenHelperDecoder(d)
 38906  	_, _, _ = h, z, r
 38907  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 38908  	_ = yys3Slc
 38909  	var yyhl3 bool = l >= 0
 38910  	for yyj3 := 0; ; yyj3++ {
 38911  		if yyhl3 {
 38912  			if yyj3 >= l {
 38913  				break
 38914  			}
 38915  		} else {
 38916  			if r.CheckBreak() {
 38917  				break
 38918  			}
 38919  		}
 38920  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 38921  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 38922  		yys3 := string(yys3Slc)
 38923  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 38924  		switch yys3 {
 38925  		case "Evaluations":
 38926  			if r.TryDecodeAsNil() {
 38927  				x.Evaluations = nil
 38928  			} else {
 38929  				yyv4 := &x.Evaluations
 38930  				yym5 := z.DecBinary()
 38931  				_ = yym5
 38932  				if false {
 38933  				} else {
 38934  					h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv4), d)
 38935  				}
 38936  			}
 38937  		case "Index":
 38938  			if r.TryDecodeAsNil() {
 38939  				x.Index = 0
 38940  			} else {
 38941  				yyv6 := &x.Index
 38942  				yym7 := z.DecBinary()
 38943  				_ = yym7
 38944  				if false {
 38945  				} else {
 38946  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 38947  				}
 38948  			}
 38949  		case "LastContact":
 38950  			if r.TryDecodeAsNil() {
 38951  				x.LastContact = 0
 38952  			} else {
 38953  				yyv8 := &x.LastContact
 38954  				yym9 := z.DecBinary()
 38955  				_ = yym9
 38956  				if false {
 38957  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 38958  				} else {
 38959  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 38960  				}
 38961  			}
 38962  		case "KnownLeader":
 38963  			if r.TryDecodeAsNil() {
 38964  				x.KnownLeader = false
 38965  			} else {
 38966  				yyv10 := &x.KnownLeader
 38967  				yym11 := z.DecBinary()
 38968  				_ = yym11
 38969  				if false {
 38970  				} else {
 38971  					*((*bool)(yyv10)) = r.DecodeBool()
 38972  				}
 38973  			}
 38974  		default:
 38975  			z.DecStructFieldNotFound(-1, yys3)
 38976  		} // end switch yys3
 38977  	} // end for yyj3
 38978  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 38979  }
 38980  
 38981  func (x *JobEvaluationsResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 38982  	var h codecSelfer100
 38983  	z, r := codec1978.GenHelperDecoder(d)
 38984  	_, _, _ = h, z, r
 38985  	var yyj12 int
 38986  	var yyb12 bool
 38987  	var yyhl12 bool = l >= 0
 38988  	yyj12++
 38989  	if yyhl12 {
 38990  		yyb12 = yyj12 > l
 38991  	} else {
 38992  		yyb12 = r.CheckBreak()
 38993  	}
 38994  	if yyb12 {
 38995  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 38996  		return
 38997  	}
 38998  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 38999  	if r.TryDecodeAsNil() {
 39000  		x.Evaluations = nil
 39001  	} else {
 39002  		yyv13 := &x.Evaluations
 39003  		yym14 := z.DecBinary()
 39004  		_ = yym14
 39005  		if false {
 39006  		} else {
 39007  			h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv13), d)
 39008  		}
 39009  	}
 39010  	yyj12++
 39011  	if yyhl12 {
 39012  		yyb12 = yyj12 > l
 39013  	} else {
 39014  		yyb12 = r.CheckBreak()
 39015  	}
 39016  	if yyb12 {
 39017  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39018  		return
 39019  	}
 39020  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39021  	if r.TryDecodeAsNil() {
 39022  		x.Index = 0
 39023  	} else {
 39024  		yyv15 := &x.Index
 39025  		yym16 := z.DecBinary()
 39026  		_ = yym16
 39027  		if false {
 39028  		} else {
 39029  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 39030  		}
 39031  	}
 39032  	yyj12++
 39033  	if yyhl12 {
 39034  		yyb12 = yyj12 > l
 39035  	} else {
 39036  		yyb12 = r.CheckBreak()
 39037  	}
 39038  	if yyb12 {
 39039  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39040  		return
 39041  	}
 39042  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39043  	if r.TryDecodeAsNil() {
 39044  		x.LastContact = 0
 39045  	} else {
 39046  		yyv17 := &x.LastContact
 39047  		yym18 := z.DecBinary()
 39048  		_ = yym18
 39049  		if false {
 39050  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 39051  		} else {
 39052  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 39053  		}
 39054  	}
 39055  	yyj12++
 39056  	if yyhl12 {
 39057  		yyb12 = yyj12 > l
 39058  	} else {
 39059  		yyb12 = r.CheckBreak()
 39060  	}
 39061  	if yyb12 {
 39062  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39063  		return
 39064  	}
 39065  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39066  	if r.TryDecodeAsNil() {
 39067  		x.KnownLeader = false
 39068  	} else {
 39069  		yyv19 := &x.KnownLeader
 39070  		yym20 := z.DecBinary()
 39071  		_ = yym20
 39072  		if false {
 39073  		} else {
 39074  			*((*bool)(yyv19)) = r.DecodeBool()
 39075  		}
 39076  	}
 39077  	for {
 39078  		yyj12++
 39079  		if yyhl12 {
 39080  			yyb12 = yyj12 > l
 39081  		} else {
 39082  			yyb12 = r.CheckBreak()
 39083  		}
 39084  		if yyb12 {
 39085  			break
 39086  		}
 39087  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39088  		z.DecStructFieldNotFound(yyj12-1, "")
 39089  	}
 39090  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39091  }
 39092  
 39093  func (x *SingleEvalResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 39094  	var h codecSelfer100
 39095  	z, r := codec1978.GenHelperEncoder(e)
 39096  	_, _, _ = h, z, r
 39097  	if x == nil {
 39098  		r.EncodeNil()
 39099  	} else {
 39100  		yym1 := z.EncBinary()
 39101  		_ = yym1
 39102  		if false {
 39103  		} else if z.HasExtensions() && z.EncExt(x) {
 39104  		} else {
 39105  			yysep2 := !z.EncBinary()
 39106  			yy2arr2 := z.EncBasicHandle().StructToArray
 39107  			var yyq2 [4]bool
 39108  			_, _, _ = yysep2, yyq2, yy2arr2
 39109  			const yyr2 bool = false
 39110  			var yynn2 int
 39111  			if yyr2 || yy2arr2 {
 39112  				r.EncodeArrayStart(4)
 39113  			} else {
 39114  				yynn2 = 4
 39115  				for _, b := range yyq2 {
 39116  					if b {
 39117  						yynn2++
 39118  					}
 39119  				}
 39120  				r.EncodeMapStart(yynn2)
 39121  				yynn2 = 0
 39122  			}
 39123  			if yyr2 || yy2arr2 {
 39124  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 39125  				if x.Eval == nil {
 39126  					r.EncodeNil()
 39127  				} else {
 39128  					x.Eval.CodecEncodeSelf(e)
 39129  				}
 39130  			} else {
 39131  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 39132  				r.EncodeString(codecSelferC_UTF8100, string("Eval"))
 39133  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 39134  				if x.Eval == nil {
 39135  					r.EncodeNil()
 39136  				} else {
 39137  					x.Eval.CodecEncodeSelf(e)
 39138  				}
 39139  			}
 39140  			if yyr2 || yy2arr2 {
 39141  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 39142  				yym7 := z.EncBinary()
 39143  				_ = yym7
 39144  				if false {
 39145  				} else {
 39146  					r.EncodeUint(uint64(x.Index))
 39147  				}
 39148  			} else {
 39149  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 39150  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 39151  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 39152  				yym8 := z.EncBinary()
 39153  				_ = yym8
 39154  				if false {
 39155  				} else {
 39156  					r.EncodeUint(uint64(x.Index))
 39157  				}
 39158  			}
 39159  			if yyr2 || yy2arr2 {
 39160  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 39161  				yym10 := z.EncBinary()
 39162  				_ = yym10
 39163  				if false {
 39164  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 39165  				} else {
 39166  					r.EncodeInt(int64(x.LastContact))
 39167  				}
 39168  			} else {
 39169  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 39170  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 39171  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 39172  				yym11 := z.EncBinary()
 39173  				_ = yym11
 39174  				if false {
 39175  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 39176  				} else {
 39177  					r.EncodeInt(int64(x.LastContact))
 39178  				}
 39179  			}
 39180  			if yyr2 || yy2arr2 {
 39181  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 39182  				yym13 := z.EncBinary()
 39183  				_ = yym13
 39184  				if false {
 39185  				} else {
 39186  					r.EncodeBool(bool(x.KnownLeader))
 39187  				}
 39188  			} else {
 39189  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 39190  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 39191  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 39192  				yym14 := z.EncBinary()
 39193  				_ = yym14
 39194  				if false {
 39195  				} else {
 39196  					r.EncodeBool(bool(x.KnownLeader))
 39197  				}
 39198  			}
 39199  			if yyr2 || yy2arr2 {
 39200  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 39201  			} else {
 39202  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 39203  			}
 39204  		}
 39205  	}
 39206  }
 39207  
 39208  func (x *SingleEvalResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 39209  	var h codecSelfer100
 39210  	z, r := codec1978.GenHelperDecoder(d)
 39211  	_, _, _ = h, z, r
 39212  	yym1 := z.DecBinary()
 39213  	_ = yym1
 39214  	if false {
 39215  	} else if z.HasExtensions() && z.DecExt(x) {
 39216  	} else {
 39217  		yyct2 := r.ContainerType()
 39218  		if yyct2 == codecSelferValueTypeMap100 {
 39219  			yyl2 := r.ReadMapStart()
 39220  			if yyl2 == 0 {
 39221  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 39222  			} else {
 39223  				x.codecDecodeSelfFromMap(yyl2, d)
 39224  			}
 39225  		} else if yyct2 == codecSelferValueTypeArray100 {
 39226  			yyl2 := r.ReadArrayStart()
 39227  			if yyl2 == 0 {
 39228  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39229  			} else {
 39230  				x.codecDecodeSelfFromArray(yyl2, d)
 39231  			}
 39232  		} else {
 39233  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 39234  		}
 39235  	}
 39236  }
 39237  
 39238  func (x *SingleEvalResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 39239  	var h codecSelfer100
 39240  	z, r := codec1978.GenHelperDecoder(d)
 39241  	_, _, _ = h, z, r
 39242  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 39243  	_ = yys3Slc
 39244  	var yyhl3 bool = l >= 0
 39245  	for yyj3 := 0; ; yyj3++ {
 39246  		if yyhl3 {
 39247  			if yyj3 >= l {
 39248  				break
 39249  			}
 39250  		} else {
 39251  			if r.CheckBreak() {
 39252  				break
 39253  			}
 39254  		}
 39255  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 39256  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 39257  		yys3 := string(yys3Slc)
 39258  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 39259  		switch yys3 {
 39260  		case "Eval":
 39261  			if r.TryDecodeAsNil() {
 39262  				if x.Eval != nil {
 39263  					x.Eval = nil
 39264  				}
 39265  			} else {
 39266  				if x.Eval == nil {
 39267  					x.Eval = new(Evaluation)
 39268  				}
 39269  				x.Eval.CodecDecodeSelf(d)
 39270  			}
 39271  		case "Index":
 39272  			if r.TryDecodeAsNil() {
 39273  				x.Index = 0
 39274  			} else {
 39275  				yyv5 := &x.Index
 39276  				yym6 := z.DecBinary()
 39277  				_ = yym6
 39278  				if false {
 39279  				} else {
 39280  					*((*uint64)(yyv5)) = uint64(r.DecodeUint(64))
 39281  				}
 39282  			}
 39283  		case "LastContact":
 39284  			if r.TryDecodeAsNil() {
 39285  				x.LastContact = 0
 39286  			} else {
 39287  				yyv7 := &x.LastContact
 39288  				yym8 := z.DecBinary()
 39289  				_ = yym8
 39290  				if false {
 39291  				} else if z.HasExtensions() && z.DecExt(yyv7) {
 39292  				} else {
 39293  					*((*int64)(yyv7)) = int64(r.DecodeInt(64))
 39294  				}
 39295  			}
 39296  		case "KnownLeader":
 39297  			if r.TryDecodeAsNil() {
 39298  				x.KnownLeader = false
 39299  			} else {
 39300  				yyv9 := &x.KnownLeader
 39301  				yym10 := z.DecBinary()
 39302  				_ = yym10
 39303  				if false {
 39304  				} else {
 39305  					*((*bool)(yyv9)) = r.DecodeBool()
 39306  				}
 39307  			}
 39308  		default:
 39309  			z.DecStructFieldNotFound(-1, yys3)
 39310  		} // end switch yys3
 39311  	} // end for yyj3
 39312  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 39313  }
 39314  
 39315  func (x *SingleEvalResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 39316  	var h codecSelfer100
 39317  	z, r := codec1978.GenHelperDecoder(d)
 39318  	_, _, _ = h, z, r
 39319  	var yyj11 int
 39320  	var yyb11 bool
 39321  	var yyhl11 bool = l >= 0
 39322  	yyj11++
 39323  	if yyhl11 {
 39324  		yyb11 = yyj11 > l
 39325  	} else {
 39326  		yyb11 = r.CheckBreak()
 39327  	}
 39328  	if yyb11 {
 39329  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39330  		return
 39331  	}
 39332  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39333  	if r.TryDecodeAsNil() {
 39334  		if x.Eval != nil {
 39335  			x.Eval = nil
 39336  		}
 39337  	} else {
 39338  		if x.Eval == nil {
 39339  			x.Eval = new(Evaluation)
 39340  		}
 39341  		x.Eval.CodecDecodeSelf(d)
 39342  	}
 39343  	yyj11++
 39344  	if yyhl11 {
 39345  		yyb11 = yyj11 > l
 39346  	} else {
 39347  		yyb11 = r.CheckBreak()
 39348  	}
 39349  	if yyb11 {
 39350  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39351  		return
 39352  	}
 39353  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39354  	if r.TryDecodeAsNil() {
 39355  		x.Index = 0
 39356  	} else {
 39357  		yyv13 := &x.Index
 39358  		yym14 := z.DecBinary()
 39359  		_ = yym14
 39360  		if false {
 39361  		} else {
 39362  			*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 39363  		}
 39364  	}
 39365  	yyj11++
 39366  	if yyhl11 {
 39367  		yyb11 = yyj11 > l
 39368  	} else {
 39369  		yyb11 = r.CheckBreak()
 39370  	}
 39371  	if yyb11 {
 39372  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39373  		return
 39374  	}
 39375  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39376  	if r.TryDecodeAsNil() {
 39377  		x.LastContact = 0
 39378  	} else {
 39379  		yyv15 := &x.LastContact
 39380  		yym16 := z.DecBinary()
 39381  		_ = yym16
 39382  		if false {
 39383  		} else if z.HasExtensions() && z.DecExt(yyv15) {
 39384  		} else {
 39385  			*((*int64)(yyv15)) = int64(r.DecodeInt(64))
 39386  		}
 39387  	}
 39388  	yyj11++
 39389  	if yyhl11 {
 39390  		yyb11 = yyj11 > l
 39391  	} else {
 39392  		yyb11 = r.CheckBreak()
 39393  	}
 39394  	if yyb11 {
 39395  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39396  		return
 39397  	}
 39398  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39399  	if r.TryDecodeAsNil() {
 39400  		x.KnownLeader = false
 39401  	} else {
 39402  		yyv17 := &x.KnownLeader
 39403  		yym18 := z.DecBinary()
 39404  		_ = yym18
 39405  		if false {
 39406  		} else {
 39407  			*((*bool)(yyv17)) = r.DecodeBool()
 39408  		}
 39409  	}
 39410  	for {
 39411  		yyj11++
 39412  		if yyhl11 {
 39413  			yyb11 = yyj11 > l
 39414  		} else {
 39415  			yyb11 = r.CheckBreak()
 39416  		}
 39417  		if yyb11 {
 39418  			break
 39419  		}
 39420  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39421  		z.DecStructFieldNotFound(yyj11-1, "")
 39422  	}
 39423  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39424  }
 39425  
 39426  func (x *EvalDequeueResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 39427  	var h codecSelfer100
 39428  	z, r := codec1978.GenHelperEncoder(e)
 39429  	_, _, _ = h, z, r
 39430  	if x == nil {
 39431  		r.EncodeNil()
 39432  	} else {
 39433  		yym1 := z.EncBinary()
 39434  		_ = yym1
 39435  		if false {
 39436  		} else if z.HasExtensions() && z.EncExt(x) {
 39437  		} else {
 39438  			yysep2 := !z.EncBinary()
 39439  			yy2arr2 := z.EncBasicHandle().StructToArray
 39440  			var yyq2 [6]bool
 39441  			_, _, _ = yysep2, yyq2, yy2arr2
 39442  			const yyr2 bool = false
 39443  			var yynn2 int
 39444  			if yyr2 || yy2arr2 {
 39445  				r.EncodeArrayStart(6)
 39446  			} else {
 39447  				yynn2 = 6
 39448  				for _, b := range yyq2 {
 39449  					if b {
 39450  						yynn2++
 39451  					}
 39452  				}
 39453  				r.EncodeMapStart(yynn2)
 39454  				yynn2 = 0
 39455  			}
 39456  			if yyr2 || yy2arr2 {
 39457  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 39458  				if x.Eval == nil {
 39459  					r.EncodeNil()
 39460  				} else {
 39461  					x.Eval.CodecEncodeSelf(e)
 39462  				}
 39463  			} else {
 39464  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 39465  				r.EncodeString(codecSelferC_UTF8100, string("Eval"))
 39466  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 39467  				if x.Eval == nil {
 39468  					r.EncodeNil()
 39469  				} else {
 39470  					x.Eval.CodecEncodeSelf(e)
 39471  				}
 39472  			}
 39473  			if yyr2 || yy2arr2 {
 39474  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 39475  				yym7 := z.EncBinary()
 39476  				_ = yym7
 39477  				if false {
 39478  				} else {
 39479  					r.EncodeString(codecSelferC_UTF8100, string(x.Token))
 39480  				}
 39481  			} else {
 39482  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 39483  				r.EncodeString(codecSelferC_UTF8100, string("Token"))
 39484  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 39485  				yym8 := z.EncBinary()
 39486  				_ = yym8
 39487  				if false {
 39488  				} else {
 39489  					r.EncodeString(codecSelferC_UTF8100, string(x.Token))
 39490  				}
 39491  			}
 39492  			if yyr2 || yy2arr2 {
 39493  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 39494  				yym10 := z.EncBinary()
 39495  				_ = yym10
 39496  				if false {
 39497  				} else {
 39498  					r.EncodeUint(uint64(x.WaitIndex))
 39499  				}
 39500  			} else {
 39501  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 39502  				r.EncodeString(codecSelferC_UTF8100, string("WaitIndex"))
 39503  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 39504  				yym11 := z.EncBinary()
 39505  				_ = yym11
 39506  				if false {
 39507  				} else {
 39508  					r.EncodeUint(uint64(x.WaitIndex))
 39509  				}
 39510  			}
 39511  			if yyr2 || yy2arr2 {
 39512  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 39513  				yym13 := z.EncBinary()
 39514  				_ = yym13
 39515  				if false {
 39516  				} else {
 39517  					r.EncodeUint(uint64(x.Index))
 39518  				}
 39519  			} else {
 39520  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 39521  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 39522  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 39523  				yym14 := z.EncBinary()
 39524  				_ = yym14
 39525  				if false {
 39526  				} else {
 39527  					r.EncodeUint(uint64(x.Index))
 39528  				}
 39529  			}
 39530  			if yyr2 || yy2arr2 {
 39531  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 39532  				yym16 := z.EncBinary()
 39533  				_ = yym16
 39534  				if false {
 39535  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 39536  				} else {
 39537  					r.EncodeInt(int64(x.LastContact))
 39538  				}
 39539  			} else {
 39540  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 39541  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 39542  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 39543  				yym17 := z.EncBinary()
 39544  				_ = yym17
 39545  				if false {
 39546  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 39547  				} else {
 39548  					r.EncodeInt(int64(x.LastContact))
 39549  				}
 39550  			}
 39551  			if yyr2 || yy2arr2 {
 39552  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 39553  				yym19 := z.EncBinary()
 39554  				_ = yym19
 39555  				if false {
 39556  				} else {
 39557  					r.EncodeBool(bool(x.KnownLeader))
 39558  				}
 39559  			} else {
 39560  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 39561  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 39562  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 39563  				yym20 := z.EncBinary()
 39564  				_ = yym20
 39565  				if false {
 39566  				} else {
 39567  					r.EncodeBool(bool(x.KnownLeader))
 39568  				}
 39569  			}
 39570  			if yyr2 || yy2arr2 {
 39571  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 39572  			} else {
 39573  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 39574  			}
 39575  		}
 39576  	}
 39577  }
 39578  
 39579  func (x *EvalDequeueResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 39580  	var h codecSelfer100
 39581  	z, r := codec1978.GenHelperDecoder(d)
 39582  	_, _, _ = h, z, r
 39583  	yym1 := z.DecBinary()
 39584  	_ = yym1
 39585  	if false {
 39586  	} else if z.HasExtensions() && z.DecExt(x) {
 39587  	} else {
 39588  		yyct2 := r.ContainerType()
 39589  		if yyct2 == codecSelferValueTypeMap100 {
 39590  			yyl2 := r.ReadMapStart()
 39591  			if yyl2 == 0 {
 39592  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 39593  			} else {
 39594  				x.codecDecodeSelfFromMap(yyl2, d)
 39595  			}
 39596  		} else if yyct2 == codecSelferValueTypeArray100 {
 39597  			yyl2 := r.ReadArrayStart()
 39598  			if yyl2 == 0 {
 39599  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39600  			} else {
 39601  				x.codecDecodeSelfFromArray(yyl2, d)
 39602  			}
 39603  		} else {
 39604  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 39605  		}
 39606  	}
 39607  }
 39608  
 39609  func (x *EvalDequeueResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 39610  	var h codecSelfer100
 39611  	z, r := codec1978.GenHelperDecoder(d)
 39612  	_, _, _ = h, z, r
 39613  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 39614  	_ = yys3Slc
 39615  	var yyhl3 bool = l >= 0
 39616  	for yyj3 := 0; ; yyj3++ {
 39617  		if yyhl3 {
 39618  			if yyj3 >= l {
 39619  				break
 39620  			}
 39621  		} else {
 39622  			if r.CheckBreak() {
 39623  				break
 39624  			}
 39625  		}
 39626  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 39627  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 39628  		yys3 := string(yys3Slc)
 39629  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 39630  		switch yys3 {
 39631  		case "Eval":
 39632  			if r.TryDecodeAsNil() {
 39633  				if x.Eval != nil {
 39634  					x.Eval = nil
 39635  				}
 39636  			} else {
 39637  				if x.Eval == nil {
 39638  					x.Eval = new(Evaluation)
 39639  				}
 39640  				x.Eval.CodecDecodeSelf(d)
 39641  			}
 39642  		case "Token":
 39643  			if r.TryDecodeAsNil() {
 39644  				x.Token = ""
 39645  			} else {
 39646  				yyv5 := &x.Token
 39647  				yym6 := z.DecBinary()
 39648  				_ = yym6
 39649  				if false {
 39650  				} else {
 39651  					*((*string)(yyv5)) = r.DecodeString()
 39652  				}
 39653  			}
 39654  		case "WaitIndex":
 39655  			if r.TryDecodeAsNil() {
 39656  				x.WaitIndex = 0
 39657  			} else {
 39658  				yyv7 := &x.WaitIndex
 39659  				yym8 := z.DecBinary()
 39660  				_ = yym8
 39661  				if false {
 39662  				} else {
 39663  					*((*uint64)(yyv7)) = uint64(r.DecodeUint(64))
 39664  				}
 39665  			}
 39666  		case "Index":
 39667  			if r.TryDecodeAsNil() {
 39668  				x.Index = 0
 39669  			} else {
 39670  				yyv9 := &x.Index
 39671  				yym10 := z.DecBinary()
 39672  				_ = yym10
 39673  				if false {
 39674  				} else {
 39675  					*((*uint64)(yyv9)) = uint64(r.DecodeUint(64))
 39676  				}
 39677  			}
 39678  		case "LastContact":
 39679  			if r.TryDecodeAsNil() {
 39680  				x.LastContact = 0
 39681  			} else {
 39682  				yyv11 := &x.LastContact
 39683  				yym12 := z.DecBinary()
 39684  				_ = yym12
 39685  				if false {
 39686  				} else if z.HasExtensions() && z.DecExt(yyv11) {
 39687  				} else {
 39688  					*((*int64)(yyv11)) = int64(r.DecodeInt(64))
 39689  				}
 39690  			}
 39691  		case "KnownLeader":
 39692  			if r.TryDecodeAsNil() {
 39693  				x.KnownLeader = false
 39694  			} else {
 39695  				yyv13 := &x.KnownLeader
 39696  				yym14 := z.DecBinary()
 39697  				_ = yym14
 39698  				if false {
 39699  				} else {
 39700  					*((*bool)(yyv13)) = r.DecodeBool()
 39701  				}
 39702  			}
 39703  		default:
 39704  			z.DecStructFieldNotFound(-1, yys3)
 39705  		} // end switch yys3
 39706  	} // end for yyj3
 39707  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 39708  }
 39709  
 39710  func (x *EvalDequeueResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 39711  	var h codecSelfer100
 39712  	z, r := codec1978.GenHelperDecoder(d)
 39713  	_, _, _ = h, z, r
 39714  	var yyj15 int
 39715  	var yyb15 bool
 39716  	var yyhl15 bool = l >= 0
 39717  	yyj15++
 39718  	if yyhl15 {
 39719  		yyb15 = yyj15 > l
 39720  	} else {
 39721  		yyb15 = r.CheckBreak()
 39722  	}
 39723  	if yyb15 {
 39724  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39725  		return
 39726  	}
 39727  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39728  	if r.TryDecodeAsNil() {
 39729  		if x.Eval != nil {
 39730  			x.Eval = nil
 39731  		}
 39732  	} else {
 39733  		if x.Eval == nil {
 39734  			x.Eval = new(Evaluation)
 39735  		}
 39736  		x.Eval.CodecDecodeSelf(d)
 39737  	}
 39738  	yyj15++
 39739  	if yyhl15 {
 39740  		yyb15 = yyj15 > l
 39741  	} else {
 39742  		yyb15 = r.CheckBreak()
 39743  	}
 39744  	if yyb15 {
 39745  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39746  		return
 39747  	}
 39748  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39749  	if r.TryDecodeAsNil() {
 39750  		x.Token = ""
 39751  	} else {
 39752  		yyv17 := &x.Token
 39753  		yym18 := z.DecBinary()
 39754  		_ = yym18
 39755  		if false {
 39756  		} else {
 39757  			*((*string)(yyv17)) = r.DecodeString()
 39758  		}
 39759  	}
 39760  	yyj15++
 39761  	if yyhl15 {
 39762  		yyb15 = yyj15 > l
 39763  	} else {
 39764  		yyb15 = r.CheckBreak()
 39765  	}
 39766  	if yyb15 {
 39767  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39768  		return
 39769  	}
 39770  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39771  	if r.TryDecodeAsNil() {
 39772  		x.WaitIndex = 0
 39773  	} else {
 39774  		yyv19 := &x.WaitIndex
 39775  		yym20 := z.DecBinary()
 39776  		_ = yym20
 39777  		if false {
 39778  		} else {
 39779  			*((*uint64)(yyv19)) = uint64(r.DecodeUint(64))
 39780  		}
 39781  	}
 39782  	yyj15++
 39783  	if yyhl15 {
 39784  		yyb15 = yyj15 > l
 39785  	} else {
 39786  		yyb15 = r.CheckBreak()
 39787  	}
 39788  	if yyb15 {
 39789  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39790  		return
 39791  	}
 39792  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39793  	if r.TryDecodeAsNil() {
 39794  		x.Index = 0
 39795  	} else {
 39796  		yyv21 := &x.Index
 39797  		yym22 := z.DecBinary()
 39798  		_ = yym22
 39799  		if false {
 39800  		} else {
 39801  			*((*uint64)(yyv21)) = uint64(r.DecodeUint(64))
 39802  		}
 39803  	}
 39804  	yyj15++
 39805  	if yyhl15 {
 39806  		yyb15 = yyj15 > l
 39807  	} else {
 39808  		yyb15 = r.CheckBreak()
 39809  	}
 39810  	if yyb15 {
 39811  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39812  		return
 39813  	}
 39814  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39815  	if r.TryDecodeAsNil() {
 39816  		x.LastContact = 0
 39817  	} else {
 39818  		yyv23 := &x.LastContact
 39819  		yym24 := z.DecBinary()
 39820  		_ = yym24
 39821  		if false {
 39822  		} else if z.HasExtensions() && z.DecExt(yyv23) {
 39823  		} else {
 39824  			*((*int64)(yyv23)) = int64(r.DecodeInt(64))
 39825  		}
 39826  	}
 39827  	yyj15++
 39828  	if yyhl15 {
 39829  		yyb15 = yyj15 > l
 39830  	} else {
 39831  		yyb15 = r.CheckBreak()
 39832  	}
 39833  	if yyb15 {
 39834  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39835  		return
 39836  	}
 39837  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39838  	if r.TryDecodeAsNil() {
 39839  		x.KnownLeader = false
 39840  	} else {
 39841  		yyv25 := &x.KnownLeader
 39842  		yym26 := z.DecBinary()
 39843  		_ = yym26
 39844  		if false {
 39845  		} else {
 39846  			*((*bool)(yyv25)) = r.DecodeBool()
 39847  		}
 39848  	}
 39849  	for {
 39850  		yyj15++
 39851  		if yyhl15 {
 39852  			yyb15 = yyj15 > l
 39853  		} else {
 39854  			yyb15 = r.CheckBreak()
 39855  		}
 39856  		if yyb15 {
 39857  			break
 39858  		}
 39859  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 39860  		z.DecStructFieldNotFound(yyj15-1, "")
 39861  	}
 39862  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39863  }
 39864  
 39865  func (x *PlanResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 39866  	var h codecSelfer100
 39867  	z, r := codec1978.GenHelperEncoder(e)
 39868  	_, _, _ = h, z, r
 39869  	if x == nil {
 39870  		r.EncodeNil()
 39871  	} else {
 39872  		yym1 := z.EncBinary()
 39873  		_ = yym1
 39874  		if false {
 39875  		} else if z.HasExtensions() && z.EncExt(x) {
 39876  		} else {
 39877  			yysep2 := !z.EncBinary()
 39878  			yy2arr2 := z.EncBasicHandle().StructToArray
 39879  			var yyq2 [2]bool
 39880  			_, _, _ = yysep2, yyq2, yy2arr2
 39881  			const yyr2 bool = false
 39882  			var yynn2 int
 39883  			if yyr2 || yy2arr2 {
 39884  				r.EncodeArrayStart(2)
 39885  			} else {
 39886  				yynn2 = 2
 39887  				for _, b := range yyq2 {
 39888  					if b {
 39889  						yynn2++
 39890  					}
 39891  				}
 39892  				r.EncodeMapStart(yynn2)
 39893  				yynn2 = 0
 39894  			}
 39895  			if yyr2 || yy2arr2 {
 39896  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 39897  				if x.Result == nil {
 39898  					r.EncodeNil()
 39899  				} else {
 39900  					x.Result.CodecEncodeSelf(e)
 39901  				}
 39902  			} else {
 39903  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 39904  				r.EncodeString(codecSelferC_UTF8100, string("Result"))
 39905  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 39906  				if x.Result == nil {
 39907  					r.EncodeNil()
 39908  				} else {
 39909  					x.Result.CodecEncodeSelf(e)
 39910  				}
 39911  			}
 39912  			if yyr2 || yy2arr2 {
 39913  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 39914  				yym7 := z.EncBinary()
 39915  				_ = yym7
 39916  				if false {
 39917  				} else {
 39918  					r.EncodeUint(uint64(x.Index))
 39919  				}
 39920  			} else {
 39921  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 39922  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 39923  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 39924  				yym8 := z.EncBinary()
 39925  				_ = yym8
 39926  				if false {
 39927  				} else {
 39928  					r.EncodeUint(uint64(x.Index))
 39929  				}
 39930  			}
 39931  			if yyr2 || yy2arr2 {
 39932  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 39933  			} else {
 39934  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 39935  			}
 39936  		}
 39937  	}
 39938  }
 39939  
 39940  func (x *PlanResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 39941  	var h codecSelfer100
 39942  	z, r := codec1978.GenHelperDecoder(d)
 39943  	_, _, _ = h, z, r
 39944  	yym1 := z.DecBinary()
 39945  	_ = yym1
 39946  	if false {
 39947  	} else if z.HasExtensions() && z.DecExt(x) {
 39948  	} else {
 39949  		yyct2 := r.ContainerType()
 39950  		if yyct2 == codecSelferValueTypeMap100 {
 39951  			yyl2 := r.ReadMapStart()
 39952  			if yyl2 == 0 {
 39953  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 39954  			} else {
 39955  				x.codecDecodeSelfFromMap(yyl2, d)
 39956  			}
 39957  		} else if yyct2 == codecSelferValueTypeArray100 {
 39958  			yyl2 := r.ReadArrayStart()
 39959  			if yyl2 == 0 {
 39960  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 39961  			} else {
 39962  				x.codecDecodeSelfFromArray(yyl2, d)
 39963  			}
 39964  		} else {
 39965  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 39966  		}
 39967  	}
 39968  }
 39969  
 39970  func (x *PlanResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 39971  	var h codecSelfer100
 39972  	z, r := codec1978.GenHelperDecoder(d)
 39973  	_, _, _ = h, z, r
 39974  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 39975  	_ = yys3Slc
 39976  	var yyhl3 bool = l >= 0
 39977  	for yyj3 := 0; ; yyj3++ {
 39978  		if yyhl3 {
 39979  			if yyj3 >= l {
 39980  				break
 39981  			}
 39982  		} else {
 39983  			if r.CheckBreak() {
 39984  				break
 39985  			}
 39986  		}
 39987  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 39988  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 39989  		yys3 := string(yys3Slc)
 39990  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 39991  		switch yys3 {
 39992  		case "Result":
 39993  			if r.TryDecodeAsNil() {
 39994  				if x.Result != nil {
 39995  					x.Result = nil
 39996  				}
 39997  			} else {
 39998  				if x.Result == nil {
 39999  					x.Result = new(PlanResult)
 40000  				}
 40001  				x.Result.CodecDecodeSelf(d)
 40002  			}
 40003  		case "Index":
 40004  			if r.TryDecodeAsNil() {
 40005  				x.Index = 0
 40006  			} else {
 40007  				yyv5 := &x.Index
 40008  				yym6 := z.DecBinary()
 40009  				_ = yym6
 40010  				if false {
 40011  				} else {
 40012  					*((*uint64)(yyv5)) = uint64(r.DecodeUint(64))
 40013  				}
 40014  			}
 40015  		default:
 40016  			z.DecStructFieldNotFound(-1, yys3)
 40017  		} // end switch yys3
 40018  	} // end for yyj3
 40019  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 40020  }
 40021  
 40022  func (x *PlanResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 40023  	var h codecSelfer100
 40024  	z, r := codec1978.GenHelperDecoder(d)
 40025  	_, _, _ = h, z, r
 40026  	var yyj7 int
 40027  	var yyb7 bool
 40028  	var yyhl7 bool = l >= 0
 40029  	yyj7++
 40030  	if yyhl7 {
 40031  		yyb7 = yyj7 > l
 40032  	} else {
 40033  		yyb7 = r.CheckBreak()
 40034  	}
 40035  	if yyb7 {
 40036  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40037  		return
 40038  	}
 40039  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 40040  	if r.TryDecodeAsNil() {
 40041  		if x.Result != nil {
 40042  			x.Result = nil
 40043  		}
 40044  	} else {
 40045  		if x.Result == nil {
 40046  			x.Result = new(PlanResult)
 40047  		}
 40048  		x.Result.CodecDecodeSelf(d)
 40049  	}
 40050  	yyj7++
 40051  	if yyhl7 {
 40052  		yyb7 = yyj7 > l
 40053  	} else {
 40054  		yyb7 = r.CheckBreak()
 40055  	}
 40056  	if yyb7 {
 40057  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40058  		return
 40059  	}
 40060  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 40061  	if r.TryDecodeAsNil() {
 40062  		x.Index = 0
 40063  	} else {
 40064  		yyv9 := &x.Index
 40065  		yym10 := z.DecBinary()
 40066  		_ = yym10
 40067  		if false {
 40068  		} else {
 40069  			*((*uint64)(yyv9)) = uint64(r.DecodeUint(64))
 40070  		}
 40071  	}
 40072  	for {
 40073  		yyj7++
 40074  		if yyhl7 {
 40075  			yyb7 = yyj7 > l
 40076  		} else {
 40077  			yyb7 = r.CheckBreak()
 40078  		}
 40079  		if yyb7 {
 40080  			break
 40081  		}
 40082  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 40083  		z.DecStructFieldNotFound(yyj7-1, "")
 40084  	}
 40085  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40086  }
 40087  
 40088  func (x *AllocListResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 40089  	var h codecSelfer100
 40090  	z, r := codec1978.GenHelperEncoder(e)
 40091  	_, _, _ = h, z, r
 40092  	if x == nil {
 40093  		r.EncodeNil()
 40094  	} else {
 40095  		yym1 := z.EncBinary()
 40096  		_ = yym1
 40097  		if false {
 40098  		} else if z.HasExtensions() && z.EncExt(x) {
 40099  		} else {
 40100  			yysep2 := !z.EncBinary()
 40101  			yy2arr2 := z.EncBasicHandle().StructToArray
 40102  			var yyq2 [4]bool
 40103  			_, _, _ = yysep2, yyq2, yy2arr2
 40104  			const yyr2 bool = false
 40105  			var yynn2 int
 40106  			if yyr2 || yy2arr2 {
 40107  				r.EncodeArrayStart(4)
 40108  			} else {
 40109  				yynn2 = 4
 40110  				for _, b := range yyq2 {
 40111  					if b {
 40112  						yynn2++
 40113  					}
 40114  				}
 40115  				r.EncodeMapStart(yynn2)
 40116  				yynn2 = 0
 40117  			}
 40118  			if yyr2 || yy2arr2 {
 40119  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 40120  				if x.Allocations == nil {
 40121  					r.EncodeNil()
 40122  				} else {
 40123  					yym4 := z.EncBinary()
 40124  					_ = yym4
 40125  					if false {
 40126  					} else {
 40127  						h.encSlicePtrtoAllocListStub(([]*AllocListStub)(x.Allocations), e)
 40128  					}
 40129  				}
 40130  			} else {
 40131  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 40132  				r.EncodeString(codecSelferC_UTF8100, string("Allocations"))
 40133  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 40134  				if x.Allocations == nil {
 40135  					r.EncodeNil()
 40136  				} else {
 40137  					yym5 := z.EncBinary()
 40138  					_ = yym5
 40139  					if false {
 40140  					} else {
 40141  						h.encSlicePtrtoAllocListStub(([]*AllocListStub)(x.Allocations), e)
 40142  					}
 40143  				}
 40144  			}
 40145  			if yyr2 || yy2arr2 {
 40146  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 40147  				yym7 := z.EncBinary()
 40148  				_ = yym7
 40149  				if false {
 40150  				} else {
 40151  					r.EncodeUint(uint64(x.Index))
 40152  				}
 40153  			} else {
 40154  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 40155  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 40156  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 40157  				yym8 := z.EncBinary()
 40158  				_ = yym8
 40159  				if false {
 40160  				} else {
 40161  					r.EncodeUint(uint64(x.Index))
 40162  				}
 40163  			}
 40164  			if yyr2 || yy2arr2 {
 40165  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 40166  				yym10 := z.EncBinary()
 40167  				_ = yym10
 40168  				if false {
 40169  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 40170  				} else {
 40171  					r.EncodeInt(int64(x.LastContact))
 40172  				}
 40173  			} else {
 40174  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 40175  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 40176  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 40177  				yym11 := z.EncBinary()
 40178  				_ = yym11
 40179  				if false {
 40180  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 40181  				} else {
 40182  					r.EncodeInt(int64(x.LastContact))
 40183  				}
 40184  			}
 40185  			if yyr2 || yy2arr2 {
 40186  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 40187  				yym13 := z.EncBinary()
 40188  				_ = yym13
 40189  				if false {
 40190  				} else {
 40191  					r.EncodeBool(bool(x.KnownLeader))
 40192  				}
 40193  			} else {
 40194  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 40195  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 40196  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 40197  				yym14 := z.EncBinary()
 40198  				_ = yym14
 40199  				if false {
 40200  				} else {
 40201  					r.EncodeBool(bool(x.KnownLeader))
 40202  				}
 40203  			}
 40204  			if yyr2 || yy2arr2 {
 40205  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 40206  			} else {
 40207  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 40208  			}
 40209  		}
 40210  	}
 40211  }
 40212  
 40213  func (x *AllocListResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 40214  	var h codecSelfer100
 40215  	z, r := codec1978.GenHelperDecoder(d)
 40216  	_, _, _ = h, z, r
 40217  	yym1 := z.DecBinary()
 40218  	_ = yym1
 40219  	if false {
 40220  	} else if z.HasExtensions() && z.DecExt(x) {
 40221  	} else {
 40222  		yyct2 := r.ContainerType()
 40223  		if yyct2 == codecSelferValueTypeMap100 {
 40224  			yyl2 := r.ReadMapStart()
 40225  			if yyl2 == 0 {
 40226  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 40227  			} else {
 40228  				x.codecDecodeSelfFromMap(yyl2, d)
 40229  			}
 40230  		} else if yyct2 == codecSelferValueTypeArray100 {
 40231  			yyl2 := r.ReadArrayStart()
 40232  			if yyl2 == 0 {
 40233  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40234  			} else {
 40235  				x.codecDecodeSelfFromArray(yyl2, d)
 40236  			}
 40237  		} else {
 40238  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 40239  		}
 40240  	}
 40241  }
 40242  
 40243  func (x *AllocListResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 40244  	var h codecSelfer100
 40245  	z, r := codec1978.GenHelperDecoder(d)
 40246  	_, _, _ = h, z, r
 40247  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 40248  	_ = yys3Slc
 40249  	var yyhl3 bool = l >= 0
 40250  	for yyj3 := 0; ; yyj3++ {
 40251  		if yyhl3 {
 40252  			if yyj3 >= l {
 40253  				break
 40254  			}
 40255  		} else {
 40256  			if r.CheckBreak() {
 40257  				break
 40258  			}
 40259  		}
 40260  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 40261  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 40262  		yys3 := string(yys3Slc)
 40263  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 40264  		switch yys3 {
 40265  		case "Allocations":
 40266  			if r.TryDecodeAsNil() {
 40267  				x.Allocations = nil
 40268  			} else {
 40269  				yyv4 := &x.Allocations
 40270  				yym5 := z.DecBinary()
 40271  				_ = yym5
 40272  				if false {
 40273  				} else {
 40274  					h.decSlicePtrtoAllocListStub((*[]*AllocListStub)(yyv4), d)
 40275  				}
 40276  			}
 40277  		case "Index":
 40278  			if r.TryDecodeAsNil() {
 40279  				x.Index = 0
 40280  			} else {
 40281  				yyv6 := &x.Index
 40282  				yym7 := z.DecBinary()
 40283  				_ = yym7
 40284  				if false {
 40285  				} else {
 40286  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 40287  				}
 40288  			}
 40289  		case "LastContact":
 40290  			if r.TryDecodeAsNil() {
 40291  				x.LastContact = 0
 40292  			} else {
 40293  				yyv8 := &x.LastContact
 40294  				yym9 := z.DecBinary()
 40295  				_ = yym9
 40296  				if false {
 40297  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 40298  				} else {
 40299  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 40300  				}
 40301  			}
 40302  		case "KnownLeader":
 40303  			if r.TryDecodeAsNil() {
 40304  				x.KnownLeader = false
 40305  			} else {
 40306  				yyv10 := &x.KnownLeader
 40307  				yym11 := z.DecBinary()
 40308  				_ = yym11
 40309  				if false {
 40310  				} else {
 40311  					*((*bool)(yyv10)) = r.DecodeBool()
 40312  				}
 40313  			}
 40314  		default:
 40315  			z.DecStructFieldNotFound(-1, yys3)
 40316  		} // end switch yys3
 40317  	} // end for yyj3
 40318  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 40319  }
 40320  
 40321  func (x *AllocListResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 40322  	var h codecSelfer100
 40323  	z, r := codec1978.GenHelperDecoder(d)
 40324  	_, _, _ = h, z, r
 40325  	var yyj12 int
 40326  	var yyb12 bool
 40327  	var yyhl12 bool = l >= 0
 40328  	yyj12++
 40329  	if yyhl12 {
 40330  		yyb12 = yyj12 > l
 40331  	} else {
 40332  		yyb12 = r.CheckBreak()
 40333  	}
 40334  	if yyb12 {
 40335  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40336  		return
 40337  	}
 40338  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 40339  	if r.TryDecodeAsNil() {
 40340  		x.Allocations = nil
 40341  	} else {
 40342  		yyv13 := &x.Allocations
 40343  		yym14 := z.DecBinary()
 40344  		_ = yym14
 40345  		if false {
 40346  		} else {
 40347  			h.decSlicePtrtoAllocListStub((*[]*AllocListStub)(yyv13), d)
 40348  		}
 40349  	}
 40350  	yyj12++
 40351  	if yyhl12 {
 40352  		yyb12 = yyj12 > l
 40353  	} else {
 40354  		yyb12 = r.CheckBreak()
 40355  	}
 40356  	if yyb12 {
 40357  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40358  		return
 40359  	}
 40360  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 40361  	if r.TryDecodeAsNil() {
 40362  		x.Index = 0
 40363  	} else {
 40364  		yyv15 := &x.Index
 40365  		yym16 := z.DecBinary()
 40366  		_ = yym16
 40367  		if false {
 40368  		} else {
 40369  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 40370  		}
 40371  	}
 40372  	yyj12++
 40373  	if yyhl12 {
 40374  		yyb12 = yyj12 > l
 40375  	} else {
 40376  		yyb12 = r.CheckBreak()
 40377  	}
 40378  	if yyb12 {
 40379  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40380  		return
 40381  	}
 40382  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 40383  	if r.TryDecodeAsNil() {
 40384  		x.LastContact = 0
 40385  	} else {
 40386  		yyv17 := &x.LastContact
 40387  		yym18 := z.DecBinary()
 40388  		_ = yym18
 40389  		if false {
 40390  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 40391  		} else {
 40392  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 40393  		}
 40394  	}
 40395  	yyj12++
 40396  	if yyhl12 {
 40397  		yyb12 = yyj12 > l
 40398  	} else {
 40399  		yyb12 = r.CheckBreak()
 40400  	}
 40401  	if yyb12 {
 40402  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40403  		return
 40404  	}
 40405  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 40406  	if r.TryDecodeAsNil() {
 40407  		x.KnownLeader = false
 40408  	} else {
 40409  		yyv19 := &x.KnownLeader
 40410  		yym20 := z.DecBinary()
 40411  		_ = yym20
 40412  		if false {
 40413  		} else {
 40414  			*((*bool)(yyv19)) = r.DecodeBool()
 40415  		}
 40416  	}
 40417  	for {
 40418  		yyj12++
 40419  		if yyhl12 {
 40420  			yyb12 = yyj12 > l
 40421  		} else {
 40422  			yyb12 = r.CheckBreak()
 40423  		}
 40424  		if yyb12 {
 40425  			break
 40426  		}
 40427  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 40428  		z.DecStructFieldNotFound(yyj12-1, "")
 40429  	}
 40430  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40431  }
 40432  
 40433  func (x *DeploymentListResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 40434  	var h codecSelfer100
 40435  	z, r := codec1978.GenHelperEncoder(e)
 40436  	_, _, _ = h, z, r
 40437  	if x == nil {
 40438  		r.EncodeNil()
 40439  	} else {
 40440  		yym1 := z.EncBinary()
 40441  		_ = yym1
 40442  		if false {
 40443  		} else if z.HasExtensions() && z.EncExt(x) {
 40444  		} else {
 40445  			yysep2 := !z.EncBinary()
 40446  			yy2arr2 := z.EncBasicHandle().StructToArray
 40447  			var yyq2 [4]bool
 40448  			_, _, _ = yysep2, yyq2, yy2arr2
 40449  			const yyr2 bool = false
 40450  			var yynn2 int
 40451  			if yyr2 || yy2arr2 {
 40452  				r.EncodeArrayStart(4)
 40453  			} else {
 40454  				yynn2 = 4
 40455  				for _, b := range yyq2 {
 40456  					if b {
 40457  						yynn2++
 40458  					}
 40459  				}
 40460  				r.EncodeMapStart(yynn2)
 40461  				yynn2 = 0
 40462  			}
 40463  			if yyr2 || yy2arr2 {
 40464  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 40465  				if x.Deployments == nil {
 40466  					r.EncodeNil()
 40467  				} else {
 40468  					yym4 := z.EncBinary()
 40469  					_ = yym4
 40470  					if false {
 40471  					} else {
 40472  						h.encSlicePtrtoDeployment(([]*Deployment)(x.Deployments), e)
 40473  					}
 40474  				}
 40475  			} else {
 40476  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 40477  				r.EncodeString(codecSelferC_UTF8100, string("Deployments"))
 40478  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 40479  				if x.Deployments == nil {
 40480  					r.EncodeNil()
 40481  				} else {
 40482  					yym5 := z.EncBinary()
 40483  					_ = yym5
 40484  					if false {
 40485  					} else {
 40486  						h.encSlicePtrtoDeployment(([]*Deployment)(x.Deployments), e)
 40487  					}
 40488  				}
 40489  			}
 40490  			if yyr2 || yy2arr2 {
 40491  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 40492  				yym7 := z.EncBinary()
 40493  				_ = yym7
 40494  				if false {
 40495  				} else {
 40496  					r.EncodeUint(uint64(x.Index))
 40497  				}
 40498  			} else {
 40499  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 40500  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 40501  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 40502  				yym8 := z.EncBinary()
 40503  				_ = yym8
 40504  				if false {
 40505  				} else {
 40506  					r.EncodeUint(uint64(x.Index))
 40507  				}
 40508  			}
 40509  			if yyr2 || yy2arr2 {
 40510  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 40511  				yym10 := z.EncBinary()
 40512  				_ = yym10
 40513  				if false {
 40514  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 40515  				} else {
 40516  					r.EncodeInt(int64(x.LastContact))
 40517  				}
 40518  			} else {
 40519  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 40520  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 40521  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 40522  				yym11 := z.EncBinary()
 40523  				_ = yym11
 40524  				if false {
 40525  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 40526  				} else {
 40527  					r.EncodeInt(int64(x.LastContact))
 40528  				}
 40529  			}
 40530  			if yyr2 || yy2arr2 {
 40531  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 40532  				yym13 := z.EncBinary()
 40533  				_ = yym13
 40534  				if false {
 40535  				} else {
 40536  					r.EncodeBool(bool(x.KnownLeader))
 40537  				}
 40538  			} else {
 40539  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 40540  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 40541  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 40542  				yym14 := z.EncBinary()
 40543  				_ = yym14
 40544  				if false {
 40545  				} else {
 40546  					r.EncodeBool(bool(x.KnownLeader))
 40547  				}
 40548  			}
 40549  			if yyr2 || yy2arr2 {
 40550  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 40551  			} else {
 40552  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 40553  			}
 40554  		}
 40555  	}
 40556  }
 40557  
 40558  func (x *DeploymentListResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 40559  	var h codecSelfer100
 40560  	z, r := codec1978.GenHelperDecoder(d)
 40561  	_, _, _ = h, z, r
 40562  	yym1 := z.DecBinary()
 40563  	_ = yym1
 40564  	if false {
 40565  	} else if z.HasExtensions() && z.DecExt(x) {
 40566  	} else {
 40567  		yyct2 := r.ContainerType()
 40568  		if yyct2 == codecSelferValueTypeMap100 {
 40569  			yyl2 := r.ReadMapStart()
 40570  			if yyl2 == 0 {
 40571  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 40572  			} else {
 40573  				x.codecDecodeSelfFromMap(yyl2, d)
 40574  			}
 40575  		} else if yyct2 == codecSelferValueTypeArray100 {
 40576  			yyl2 := r.ReadArrayStart()
 40577  			if yyl2 == 0 {
 40578  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40579  			} else {
 40580  				x.codecDecodeSelfFromArray(yyl2, d)
 40581  			}
 40582  		} else {
 40583  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 40584  		}
 40585  	}
 40586  }
 40587  
 40588  func (x *DeploymentListResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 40589  	var h codecSelfer100
 40590  	z, r := codec1978.GenHelperDecoder(d)
 40591  	_, _, _ = h, z, r
 40592  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 40593  	_ = yys3Slc
 40594  	var yyhl3 bool = l >= 0
 40595  	for yyj3 := 0; ; yyj3++ {
 40596  		if yyhl3 {
 40597  			if yyj3 >= l {
 40598  				break
 40599  			}
 40600  		} else {
 40601  			if r.CheckBreak() {
 40602  				break
 40603  			}
 40604  		}
 40605  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 40606  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 40607  		yys3 := string(yys3Slc)
 40608  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 40609  		switch yys3 {
 40610  		case "Deployments":
 40611  			if r.TryDecodeAsNil() {
 40612  				x.Deployments = nil
 40613  			} else {
 40614  				yyv4 := &x.Deployments
 40615  				yym5 := z.DecBinary()
 40616  				_ = yym5
 40617  				if false {
 40618  				} else {
 40619  					h.decSlicePtrtoDeployment((*[]*Deployment)(yyv4), d)
 40620  				}
 40621  			}
 40622  		case "Index":
 40623  			if r.TryDecodeAsNil() {
 40624  				x.Index = 0
 40625  			} else {
 40626  				yyv6 := &x.Index
 40627  				yym7 := z.DecBinary()
 40628  				_ = yym7
 40629  				if false {
 40630  				} else {
 40631  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 40632  				}
 40633  			}
 40634  		case "LastContact":
 40635  			if r.TryDecodeAsNil() {
 40636  				x.LastContact = 0
 40637  			} else {
 40638  				yyv8 := &x.LastContact
 40639  				yym9 := z.DecBinary()
 40640  				_ = yym9
 40641  				if false {
 40642  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 40643  				} else {
 40644  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 40645  				}
 40646  			}
 40647  		case "KnownLeader":
 40648  			if r.TryDecodeAsNil() {
 40649  				x.KnownLeader = false
 40650  			} else {
 40651  				yyv10 := &x.KnownLeader
 40652  				yym11 := z.DecBinary()
 40653  				_ = yym11
 40654  				if false {
 40655  				} else {
 40656  					*((*bool)(yyv10)) = r.DecodeBool()
 40657  				}
 40658  			}
 40659  		default:
 40660  			z.DecStructFieldNotFound(-1, yys3)
 40661  		} // end switch yys3
 40662  	} // end for yyj3
 40663  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 40664  }
 40665  
 40666  func (x *DeploymentListResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 40667  	var h codecSelfer100
 40668  	z, r := codec1978.GenHelperDecoder(d)
 40669  	_, _, _ = h, z, r
 40670  	var yyj12 int
 40671  	var yyb12 bool
 40672  	var yyhl12 bool = l >= 0
 40673  	yyj12++
 40674  	if yyhl12 {
 40675  		yyb12 = yyj12 > l
 40676  	} else {
 40677  		yyb12 = r.CheckBreak()
 40678  	}
 40679  	if yyb12 {
 40680  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40681  		return
 40682  	}
 40683  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 40684  	if r.TryDecodeAsNil() {
 40685  		x.Deployments = nil
 40686  	} else {
 40687  		yyv13 := &x.Deployments
 40688  		yym14 := z.DecBinary()
 40689  		_ = yym14
 40690  		if false {
 40691  		} else {
 40692  			h.decSlicePtrtoDeployment((*[]*Deployment)(yyv13), d)
 40693  		}
 40694  	}
 40695  	yyj12++
 40696  	if yyhl12 {
 40697  		yyb12 = yyj12 > l
 40698  	} else {
 40699  		yyb12 = r.CheckBreak()
 40700  	}
 40701  	if yyb12 {
 40702  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40703  		return
 40704  	}
 40705  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 40706  	if r.TryDecodeAsNil() {
 40707  		x.Index = 0
 40708  	} else {
 40709  		yyv15 := &x.Index
 40710  		yym16 := z.DecBinary()
 40711  		_ = yym16
 40712  		if false {
 40713  		} else {
 40714  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 40715  		}
 40716  	}
 40717  	yyj12++
 40718  	if yyhl12 {
 40719  		yyb12 = yyj12 > l
 40720  	} else {
 40721  		yyb12 = r.CheckBreak()
 40722  	}
 40723  	if yyb12 {
 40724  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40725  		return
 40726  	}
 40727  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 40728  	if r.TryDecodeAsNil() {
 40729  		x.LastContact = 0
 40730  	} else {
 40731  		yyv17 := &x.LastContact
 40732  		yym18 := z.DecBinary()
 40733  		_ = yym18
 40734  		if false {
 40735  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 40736  		} else {
 40737  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 40738  		}
 40739  	}
 40740  	yyj12++
 40741  	if yyhl12 {
 40742  		yyb12 = yyj12 > l
 40743  	} else {
 40744  		yyb12 = r.CheckBreak()
 40745  	}
 40746  	if yyb12 {
 40747  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40748  		return
 40749  	}
 40750  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 40751  	if r.TryDecodeAsNil() {
 40752  		x.KnownLeader = false
 40753  	} else {
 40754  		yyv19 := &x.KnownLeader
 40755  		yym20 := z.DecBinary()
 40756  		_ = yym20
 40757  		if false {
 40758  		} else {
 40759  			*((*bool)(yyv19)) = r.DecodeBool()
 40760  		}
 40761  	}
 40762  	for {
 40763  		yyj12++
 40764  		if yyhl12 {
 40765  			yyb12 = yyj12 > l
 40766  		} else {
 40767  			yyb12 = r.CheckBreak()
 40768  		}
 40769  		if yyb12 {
 40770  			break
 40771  		}
 40772  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 40773  		z.DecStructFieldNotFound(yyj12-1, "")
 40774  	}
 40775  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40776  }
 40777  
 40778  func (x *EvalListResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 40779  	var h codecSelfer100
 40780  	z, r := codec1978.GenHelperEncoder(e)
 40781  	_, _, _ = h, z, r
 40782  	if x == nil {
 40783  		r.EncodeNil()
 40784  	} else {
 40785  		yym1 := z.EncBinary()
 40786  		_ = yym1
 40787  		if false {
 40788  		} else if z.HasExtensions() && z.EncExt(x) {
 40789  		} else {
 40790  			yysep2 := !z.EncBinary()
 40791  			yy2arr2 := z.EncBasicHandle().StructToArray
 40792  			var yyq2 [4]bool
 40793  			_, _, _ = yysep2, yyq2, yy2arr2
 40794  			const yyr2 bool = false
 40795  			var yynn2 int
 40796  			if yyr2 || yy2arr2 {
 40797  				r.EncodeArrayStart(4)
 40798  			} else {
 40799  				yynn2 = 4
 40800  				for _, b := range yyq2 {
 40801  					if b {
 40802  						yynn2++
 40803  					}
 40804  				}
 40805  				r.EncodeMapStart(yynn2)
 40806  				yynn2 = 0
 40807  			}
 40808  			if yyr2 || yy2arr2 {
 40809  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 40810  				if x.Evaluations == nil {
 40811  					r.EncodeNil()
 40812  				} else {
 40813  					yym4 := z.EncBinary()
 40814  					_ = yym4
 40815  					if false {
 40816  					} else {
 40817  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.Evaluations), e)
 40818  					}
 40819  				}
 40820  			} else {
 40821  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 40822  				r.EncodeString(codecSelferC_UTF8100, string("Evaluations"))
 40823  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 40824  				if x.Evaluations == nil {
 40825  					r.EncodeNil()
 40826  				} else {
 40827  					yym5 := z.EncBinary()
 40828  					_ = yym5
 40829  					if false {
 40830  					} else {
 40831  						h.encSlicePtrtoEvaluation(([]*Evaluation)(x.Evaluations), e)
 40832  					}
 40833  				}
 40834  			}
 40835  			if yyr2 || yy2arr2 {
 40836  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 40837  				yym7 := z.EncBinary()
 40838  				_ = yym7
 40839  				if false {
 40840  				} else {
 40841  					r.EncodeUint(uint64(x.Index))
 40842  				}
 40843  			} else {
 40844  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 40845  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 40846  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 40847  				yym8 := z.EncBinary()
 40848  				_ = yym8
 40849  				if false {
 40850  				} else {
 40851  					r.EncodeUint(uint64(x.Index))
 40852  				}
 40853  			}
 40854  			if yyr2 || yy2arr2 {
 40855  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 40856  				yym10 := z.EncBinary()
 40857  				_ = yym10
 40858  				if false {
 40859  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 40860  				} else {
 40861  					r.EncodeInt(int64(x.LastContact))
 40862  				}
 40863  			} else {
 40864  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 40865  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 40866  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 40867  				yym11 := z.EncBinary()
 40868  				_ = yym11
 40869  				if false {
 40870  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 40871  				} else {
 40872  					r.EncodeInt(int64(x.LastContact))
 40873  				}
 40874  			}
 40875  			if yyr2 || yy2arr2 {
 40876  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 40877  				yym13 := z.EncBinary()
 40878  				_ = yym13
 40879  				if false {
 40880  				} else {
 40881  					r.EncodeBool(bool(x.KnownLeader))
 40882  				}
 40883  			} else {
 40884  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 40885  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 40886  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 40887  				yym14 := z.EncBinary()
 40888  				_ = yym14
 40889  				if false {
 40890  				} else {
 40891  					r.EncodeBool(bool(x.KnownLeader))
 40892  				}
 40893  			}
 40894  			if yyr2 || yy2arr2 {
 40895  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 40896  			} else {
 40897  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 40898  			}
 40899  		}
 40900  	}
 40901  }
 40902  
 40903  func (x *EvalListResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 40904  	var h codecSelfer100
 40905  	z, r := codec1978.GenHelperDecoder(d)
 40906  	_, _, _ = h, z, r
 40907  	yym1 := z.DecBinary()
 40908  	_ = yym1
 40909  	if false {
 40910  	} else if z.HasExtensions() && z.DecExt(x) {
 40911  	} else {
 40912  		yyct2 := r.ContainerType()
 40913  		if yyct2 == codecSelferValueTypeMap100 {
 40914  			yyl2 := r.ReadMapStart()
 40915  			if yyl2 == 0 {
 40916  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 40917  			} else {
 40918  				x.codecDecodeSelfFromMap(yyl2, d)
 40919  			}
 40920  		} else if yyct2 == codecSelferValueTypeArray100 {
 40921  			yyl2 := r.ReadArrayStart()
 40922  			if yyl2 == 0 {
 40923  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 40924  			} else {
 40925  				x.codecDecodeSelfFromArray(yyl2, d)
 40926  			}
 40927  		} else {
 40928  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 40929  		}
 40930  	}
 40931  }
 40932  
 40933  func (x *EvalListResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 40934  	var h codecSelfer100
 40935  	z, r := codec1978.GenHelperDecoder(d)
 40936  	_, _, _ = h, z, r
 40937  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 40938  	_ = yys3Slc
 40939  	var yyhl3 bool = l >= 0
 40940  	for yyj3 := 0; ; yyj3++ {
 40941  		if yyhl3 {
 40942  			if yyj3 >= l {
 40943  				break
 40944  			}
 40945  		} else {
 40946  			if r.CheckBreak() {
 40947  				break
 40948  			}
 40949  		}
 40950  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 40951  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 40952  		yys3 := string(yys3Slc)
 40953  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 40954  		switch yys3 {
 40955  		case "Evaluations":
 40956  			if r.TryDecodeAsNil() {
 40957  				x.Evaluations = nil
 40958  			} else {
 40959  				yyv4 := &x.Evaluations
 40960  				yym5 := z.DecBinary()
 40961  				_ = yym5
 40962  				if false {
 40963  				} else {
 40964  					h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv4), d)
 40965  				}
 40966  			}
 40967  		case "Index":
 40968  			if r.TryDecodeAsNil() {
 40969  				x.Index = 0
 40970  			} else {
 40971  				yyv6 := &x.Index
 40972  				yym7 := z.DecBinary()
 40973  				_ = yym7
 40974  				if false {
 40975  				} else {
 40976  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 40977  				}
 40978  			}
 40979  		case "LastContact":
 40980  			if r.TryDecodeAsNil() {
 40981  				x.LastContact = 0
 40982  			} else {
 40983  				yyv8 := &x.LastContact
 40984  				yym9 := z.DecBinary()
 40985  				_ = yym9
 40986  				if false {
 40987  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 40988  				} else {
 40989  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 40990  				}
 40991  			}
 40992  		case "KnownLeader":
 40993  			if r.TryDecodeAsNil() {
 40994  				x.KnownLeader = false
 40995  			} else {
 40996  				yyv10 := &x.KnownLeader
 40997  				yym11 := z.DecBinary()
 40998  				_ = yym11
 40999  				if false {
 41000  				} else {
 41001  					*((*bool)(yyv10)) = r.DecodeBool()
 41002  				}
 41003  			}
 41004  		default:
 41005  			z.DecStructFieldNotFound(-1, yys3)
 41006  		} // end switch yys3
 41007  	} // end for yyj3
 41008  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 41009  }
 41010  
 41011  func (x *EvalListResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 41012  	var h codecSelfer100
 41013  	z, r := codec1978.GenHelperDecoder(d)
 41014  	_, _, _ = h, z, r
 41015  	var yyj12 int
 41016  	var yyb12 bool
 41017  	var yyhl12 bool = l >= 0
 41018  	yyj12++
 41019  	if yyhl12 {
 41020  		yyb12 = yyj12 > l
 41021  	} else {
 41022  		yyb12 = r.CheckBreak()
 41023  	}
 41024  	if yyb12 {
 41025  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41026  		return
 41027  	}
 41028  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 41029  	if r.TryDecodeAsNil() {
 41030  		x.Evaluations = nil
 41031  	} else {
 41032  		yyv13 := &x.Evaluations
 41033  		yym14 := z.DecBinary()
 41034  		_ = yym14
 41035  		if false {
 41036  		} else {
 41037  			h.decSlicePtrtoEvaluation((*[]*Evaluation)(yyv13), d)
 41038  		}
 41039  	}
 41040  	yyj12++
 41041  	if yyhl12 {
 41042  		yyb12 = yyj12 > l
 41043  	} else {
 41044  		yyb12 = r.CheckBreak()
 41045  	}
 41046  	if yyb12 {
 41047  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41048  		return
 41049  	}
 41050  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 41051  	if r.TryDecodeAsNil() {
 41052  		x.Index = 0
 41053  	} else {
 41054  		yyv15 := &x.Index
 41055  		yym16 := z.DecBinary()
 41056  		_ = yym16
 41057  		if false {
 41058  		} else {
 41059  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 41060  		}
 41061  	}
 41062  	yyj12++
 41063  	if yyhl12 {
 41064  		yyb12 = yyj12 > l
 41065  	} else {
 41066  		yyb12 = r.CheckBreak()
 41067  	}
 41068  	if yyb12 {
 41069  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41070  		return
 41071  	}
 41072  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 41073  	if r.TryDecodeAsNil() {
 41074  		x.LastContact = 0
 41075  	} else {
 41076  		yyv17 := &x.LastContact
 41077  		yym18 := z.DecBinary()
 41078  		_ = yym18
 41079  		if false {
 41080  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 41081  		} else {
 41082  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 41083  		}
 41084  	}
 41085  	yyj12++
 41086  	if yyhl12 {
 41087  		yyb12 = yyj12 > l
 41088  	} else {
 41089  		yyb12 = r.CheckBreak()
 41090  	}
 41091  	if yyb12 {
 41092  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41093  		return
 41094  	}
 41095  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 41096  	if r.TryDecodeAsNil() {
 41097  		x.KnownLeader = false
 41098  	} else {
 41099  		yyv19 := &x.KnownLeader
 41100  		yym20 := z.DecBinary()
 41101  		_ = yym20
 41102  		if false {
 41103  		} else {
 41104  			*((*bool)(yyv19)) = r.DecodeBool()
 41105  		}
 41106  	}
 41107  	for {
 41108  		yyj12++
 41109  		if yyhl12 {
 41110  			yyb12 = yyj12 > l
 41111  		} else {
 41112  			yyb12 = r.CheckBreak()
 41113  		}
 41114  		if yyb12 {
 41115  			break
 41116  		}
 41117  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 41118  		z.DecStructFieldNotFound(yyj12-1, "")
 41119  	}
 41120  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41121  }
 41122  
 41123  func (x *EvalAllocationsResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 41124  	var h codecSelfer100
 41125  	z, r := codec1978.GenHelperEncoder(e)
 41126  	_, _, _ = h, z, r
 41127  	if x == nil {
 41128  		r.EncodeNil()
 41129  	} else {
 41130  		yym1 := z.EncBinary()
 41131  		_ = yym1
 41132  		if false {
 41133  		} else if z.HasExtensions() && z.EncExt(x) {
 41134  		} else {
 41135  			yysep2 := !z.EncBinary()
 41136  			yy2arr2 := z.EncBasicHandle().StructToArray
 41137  			var yyq2 [4]bool
 41138  			_, _, _ = yysep2, yyq2, yy2arr2
 41139  			const yyr2 bool = false
 41140  			var yynn2 int
 41141  			if yyr2 || yy2arr2 {
 41142  				r.EncodeArrayStart(4)
 41143  			} else {
 41144  				yynn2 = 4
 41145  				for _, b := range yyq2 {
 41146  					if b {
 41147  						yynn2++
 41148  					}
 41149  				}
 41150  				r.EncodeMapStart(yynn2)
 41151  				yynn2 = 0
 41152  			}
 41153  			if yyr2 || yy2arr2 {
 41154  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 41155  				if x.Allocations == nil {
 41156  					r.EncodeNil()
 41157  				} else {
 41158  					yym4 := z.EncBinary()
 41159  					_ = yym4
 41160  					if false {
 41161  					} else {
 41162  						h.encSlicePtrtoAllocListStub(([]*AllocListStub)(x.Allocations), e)
 41163  					}
 41164  				}
 41165  			} else {
 41166  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 41167  				r.EncodeString(codecSelferC_UTF8100, string("Allocations"))
 41168  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 41169  				if x.Allocations == nil {
 41170  					r.EncodeNil()
 41171  				} else {
 41172  					yym5 := z.EncBinary()
 41173  					_ = yym5
 41174  					if false {
 41175  					} else {
 41176  						h.encSlicePtrtoAllocListStub(([]*AllocListStub)(x.Allocations), e)
 41177  					}
 41178  				}
 41179  			}
 41180  			if yyr2 || yy2arr2 {
 41181  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 41182  				yym7 := z.EncBinary()
 41183  				_ = yym7
 41184  				if false {
 41185  				} else {
 41186  					r.EncodeUint(uint64(x.Index))
 41187  				}
 41188  			} else {
 41189  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 41190  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 41191  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 41192  				yym8 := z.EncBinary()
 41193  				_ = yym8
 41194  				if false {
 41195  				} else {
 41196  					r.EncodeUint(uint64(x.Index))
 41197  				}
 41198  			}
 41199  			if yyr2 || yy2arr2 {
 41200  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 41201  				yym10 := z.EncBinary()
 41202  				_ = yym10
 41203  				if false {
 41204  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 41205  				} else {
 41206  					r.EncodeInt(int64(x.LastContact))
 41207  				}
 41208  			} else {
 41209  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 41210  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 41211  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 41212  				yym11 := z.EncBinary()
 41213  				_ = yym11
 41214  				if false {
 41215  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 41216  				} else {
 41217  					r.EncodeInt(int64(x.LastContact))
 41218  				}
 41219  			}
 41220  			if yyr2 || yy2arr2 {
 41221  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 41222  				yym13 := z.EncBinary()
 41223  				_ = yym13
 41224  				if false {
 41225  				} else {
 41226  					r.EncodeBool(bool(x.KnownLeader))
 41227  				}
 41228  			} else {
 41229  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 41230  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 41231  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 41232  				yym14 := z.EncBinary()
 41233  				_ = yym14
 41234  				if false {
 41235  				} else {
 41236  					r.EncodeBool(bool(x.KnownLeader))
 41237  				}
 41238  			}
 41239  			if yyr2 || yy2arr2 {
 41240  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 41241  			} else {
 41242  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 41243  			}
 41244  		}
 41245  	}
 41246  }
 41247  
 41248  func (x *EvalAllocationsResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 41249  	var h codecSelfer100
 41250  	z, r := codec1978.GenHelperDecoder(d)
 41251  	_, _, _ = h, z, r
 41252  	yym1 := z.DecBinary()
 41253  	_ = yym1
 41254  	if false {
 41255  	} else if z.HasExtensions() && z.DecExt(x) {
 41256  	} else {
 41257  		yyct2 := r.ContainerType()
 41258  		if yyct2 == codecSelferValueTypeMap100 {
 41259  			yyl2 := r.ReadMapStart()
 41260  			if yyl2 == 0 {
 41261  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 41262  			} else {
 41263  				x.codecDecodeSelfFromMap(yyl2, d)
 41264  			}
 41265  		} else if yyct2 == codecSelferValueTypeArray100 {
 41266  			yyl2 := r.ReadArrayStart()
 41267  			if yyl2 == 0 {
 41268  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41269  			} else {
 41270  				x.codecDecodeSelfFromArray(yyl2, d)
 41271  			}
 41272  		} else {
 41273  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 41274  		}
 41275  	}
 41276  }
 41277  
 41278  func (x *EvalAllocationsResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 41279  	var h codecSelfer100
 41280  	z, r := codec1978.GenHelperDecoder(d)
 41281  	_, _, _ = h, z, r
 41282  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 41283  	_ = yys3Slc
 41284  	var yyhl3 bool = l >= 0
 41285  	for yyj3 := 0; ; yyj3++ {
 41286  		if yyhl3 {
 41287  			if yyj3 >= l {
 41288  				break
 41289  			}
 41290  		} else {
 41291  			if r.CheckBreak() {
 41292  				break
 41293  			}
 41294  		}
 41295  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 41296  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 41297  		yys3 := string(yys3Slc)
 41298  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 41299  		switch yys3 {
 41300  		case "Allocations":
 41301  			if r.TryDecodeAsNil() {
 41302  				x.Allocations = nil
 41303  			} else {
 41304  				yyv4 := &x.Allocations
 41305  				yym5 := z.DecBinary()
 41306  				_ = yym5
 41307  				if false {
 41308  				} else {
 41309  					h.decSlicePtrtoAllocListStub((*[]*AllocListStub)(yyv4), d)
 41310  				}
 41311  			}
 41312  		case "Index":
 41313  			if r.TryDecodeAsNil() {
 41314  				x.Index = 0
 41315  			} else {
 41316  				yyv6 := &x.Index
 41317  				yym7 := z.DecBinary()
 41318  				_ = yym7
 41319  				if false {
 41320  				} else {
 41321  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 41322  				}
 41323  			}
 41324  		case "LastContact":
 41325  			if r.TryDecodeAsNil() {
 41326  				x.LastContact = 0
 41327  			} else {
 41328  				yyv8 := &x.LastContact
 41329  				yym9 := z.DecBinary()
 41330  				_ = yym9
 41331  				if false {
 41332  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 41333  				} else {
 41334  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 41335  				}
 41336  			}
 41337  		case "KnownLeader":
 41338  			if r.TryDecodeAsNil() {
 41339  				x.KnownLeader = false
 41340  			} else {
 41341  				yyv10 := &x.KnownLeader
 41342  				yym11 := z.DecBinary()
 41343  				_ = yym11
 41344  				if false {
 41345  				} else {
 41346  					*((*bool)(yyv10)) = r.DecodeBool()
 41347  				}
 41348  			}
 41349  		default:
 41350  			z.DecStructFieldNotFound(-1, yys3)
 41351  		} // end switch yys3
 41352  	} // end for yyj3
 41353  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 41354  }
 41355  
 41356  func (x *EvalAllocationsResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 41357  	var h codecSelfer100
 41358  	z, r := codec1978.GenHelperDecoder(d)
 41359  	_, _, _ = h, z, r
 41360  	var yyj12 int
 41361  	var yyb12 bool
 41362  	var yyhl12 bool = l >= 0
 41363  	yyj12++
 41364  	if yyhl12 {
 41365  		yyb12 = yyj12 > l
 41366  	} else {
 41367  		yyb12 = r.CheckBreak()
 41368  	}
 41369  	if yyb12 {
 41370  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41371  		return
 41372  	}
 41373  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 41374  	if r.TryDecodeAsNil() {
 41375  		x.Allocations = nil
 41376  	} else {
 41377  		yyv13 := &x.Allocations
 41378  		yym14 := z.DecBinary()
 41379  		_ = yym14
 41380  		if false {
 41381  		} else {
 41382  			h.decSlicePtrtoAllocListStub((*[]*AllocListStub)(yyv13), d)
 41383  		}
 41384  	}
 41385  	yyj12++
 41386  	if yyhl12 {
 41387  		yyb12 = yyj12 > l
 41388  	} else {
 41389  		yyb12 = r.CheckBreak()
 41390  	}
 41391  	if yyb12 {
 41392  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41393  		return
 41394  	}
 41395  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 41396  	if r.TryDecodeAsNil() {
 41397  		x.Index = 0
 41398  	} else {
 41399  		yyv15 := &x.Index
 41400  		yym16 := z.DecBinary()
 41401  		_ = yym16
 41402  		if false {
 41403  		} else {
 41404  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 41405  		}
 41406  	}
 41407  	yyj12++
 41408  	if yyhl12 {
 41409  		yyb12 = yyj12 > l
 41410  	} else {
 41411  		yyb12 = r.CheckBreak()
 41412  	}
 41413  	if yyb12 {
 41414  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41415  		return
 41416  	}
 41417  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 41418  	if r.TryDecodeAsNil() {
 41419  		x.LastContact = 0
 41420  	} else {
 41421  		yyv17 := &x.LastContact
 41422  		yym18 := z.DecBinary()
 41423  		_ = yym18
 41424  		if false {
 41425  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 41426  		} else {
 41427  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 41428  		}
 41429  	}
 41430  	yyj12++
 41431  	if yyhl12 {
 41432  		yyb12 = yyj12 > l
 41433  	} else {
 41434  		yyb12 = r.CheckBreak()
 41435  	}
 41436  	if yyb12 {
 41437  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41438  		return
 41439  	}
 41440  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 41441  	if r.TryDecodeAsNil() {
 41442  		x.KnownLeader = false
 41443  	} else {
 41444  		yyv19 := &x.KnownLeader
 41445  		yym20 := z.DecBinary()
 41446  		_ = yym20
 41447  		if false {
 41448  		} else {
 41449  			*((*bool)(yyv19)) = r.DecodeBool()
 41450  		}
 41451  	}
 41452  	for {
 41453  		yyj12++
 41454  		if yyhl12 {
 41455  			yyb12 = yyj12 > l
 41456  		} else {
 41457  			yyb12 = r.CheckBreak()
 41458  		}
 41459  		if yyb12 {
 41460  			break
 41461  		}
 41462  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 41463  		z.DecStructFieldNotFound(yyj12-1, "")
 41464  	}
 41465  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41466  }
 41467  
 41468  func (x *PeriodicForceResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 41469  	var h codecSelfer100
 41470  	z, r := codec1978.GenHelperEncoder(e)
 41471  	_, _, _ = h, z, r
 41472  	if x == nil {
 41473  		r.EncodeNil()
 41474  	} else {
 41475  		yym1 := z.EncBinary()
 41476  		_ = yym1
 41477  		if false {
 41478  		} else if z.HasExtensions() && z.EncExt(x) {
 41479  		} else {
 41480  			yysep2 := !z.EncBinary()
 41481  			yy2arr2 := z.EncBasicHandle().StructToArray
 41482  			var yyq2 [3]bool
 41483  			_, _, _ = yysep2, yyq2, yy2arr2
 41484  			const yyr2 bool = false
 41485  			var yynn2 int
 41486  			if yyr2 || yy2arr2 {
 41487  				r.EncodeArrayStart(3)
 41488  			} else {
 41489  				yynn2 = 3
 41490  				for _, b := range yyq2 {
 41491  					if b {
 41492  						yynn2++
 41493  					}
 41494  				}
 41495  				r.EncodeMapStart(yynn2)
 41496  				yynn2 = 0
 41497  			}
 41498  			if yyr2 || yy2arr2 {
 41499  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 41500  				yym4 := z.EncBinary()
 41501  				_ = yym4
 41502  				if false {
 41503  				} else {
 41504  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 41505  				}
 41506  			} else {
 41507  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 41508  				r.EncodeString(codecSelferC_UTF8100, string("EvalID"))
 41509  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 41510  				yym5 := z.EncBinary()
 41511  				_ = yym5
 41512  				if false {
 41513  				} else {
 41514  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 41515  				}
 41516  			}
 41517  			if yyr2 || yy2arr2 {
 41518  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 41519  				yym7 := z.EncBinary()
 41520  				_ = yym7
 41521  				if false {
 41522  				} else {
 41523  					r.EncodeUint(uint64(x.EvalCreateIndex))
 41524  				}
 41525  			} else {
 41526  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 41527  				r.EncodeString(codecSelferC_UTF8100, string("EvalCreateIndex"))
 41528  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 41529  				yym8 := z.EncBinary()
 41530  				_ = yym8
 41531  				if false {
 41532  				} else {
 41533  					r.EncodeUint(uint64(x.EvalCreateIndex))
 41534  				}
 41535  			}
 41536  			if yyr2 || yy2arr2 {
 41537  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 41538  				yym10 := z.EncBinary()
 41539  				_ = yym10
 41540  				if false {
 41541  				} else {
 41542  					r.EncodeUint(uint64(x.Index))
 41543  				}
 41544  			} else {
 41545  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 41546  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 41547  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 41548  				yym11 := z.EncBinary()
 41549  				_ = yym11
 41550  				if false {
 41551  				} else {
 41552  					r.EncodeUint(uint64(x.Index))
 41553  				}
 41554  			}
 41555  			if yyr2 || yy2arr2 {
 41556  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 41557  			} else {
 41558  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 41559  			}
 41560  		}
 41561  	}
 41562  }
 41563  
 41564  func (x *PeriodicForceResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 41565  	var h codecSelfer100
 41566  	z, r := codec1978.GenHelperDecoder(d)
 41567  	_, _, _ = h, z, r
 41568  	yym1 := z.DecBinary()
 41569  	_ = yym1
 41570  	if false {
 41571  	} else if z.HasExtensions() && z.DecExt(x) {
 41572  	} else {
 41573  		yyct2 := r.ContainerType()
 41574  		if yyct2 == codecSelferValueTypeMap100 {
 41575  			yyl2 := r.ReadMapStart()
 41576  			if yyl2 == 0 {
 41577  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 41578  			} else {
 41579  				x.codecDecodeSelfFromMap(yyl2, d)
 41580  			}
 41581  		} else if yyct2 == codecSelferValueTypeArray100 {
 41582  			yyl2 := r.ReadArrayStart()
 41583  			if yyl2 == 0 {
 41584  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41585  			} else {
 41586  				x.codecDecodeSelfFromArray(yyl2, d)
 41587  			}
 41588  		} else {
 41589  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 41590  		}
 41591  	}
 41592  }
 41593  
 41594  func (x *PeriodicForceResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 41595  	var h codecSelfer100
 41596  	z, r := codec1978.GenHelperDecoder(d)
 41597  	_, _, _ = h, z, r
 41598  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 41599  	_ = yys3Slc
 41600  	var yyhl3 bool = l >= 0
 41601  	for yyj3 := 0; ; yyj3++ {
 41602  		if yyhl3 {
 41603  			if yyj3 >= l {
 41604  				break
 41605  			}
 41606  		} else {
 41607  			if r.CheckBreak() {
 41608  				break
 41609  			}
 41610  		}
 41611  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 41612  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 41613  		yys3 := string(yys3Slc)
 41614  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 41615  		switch yys3 {
 41616  		case "EvalID":
 41617  			if r.TryDecodeAsNil() {
 41618  				x.EvalID = ""
 41619  			} else {
 41620  				yyv4 := &x.EvalID
 41621  				yym5 := z.DecBinary()
 41622  				_ = yym5
 41623  				if false {
 41624  				} else {
 41625  					*((*string)(yyv4)) = r.DecodeString()
 41626  				}
 41627  			}
 41628  		case "EvalCreateIndex":
 41629  			if r.TryDecodeAsNil() {
 41630  				x.EvalCreateIndex = 0
 41631  			} else {
 41632  				yyv6 := &x.EvalCreateIndex
 41633  				yym7 := z.DecBinary()
 41634  				_ = yym7
 41635  				if false {
 41636  				} else {
 41637  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 41638  				}
 41639  			}
 41640  		case "Index":
 41641  			if r.TryDecodeAsNil() {
 41642  				x.Index = 0
 41643  			} else {
 41644  				yyv8 := &x.Index
 41645  				yym9 := z.DecBinary()
 41646  				_ = yym9
 41647  				if false {
 41648  				} else {
 41649  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 41650  				}
 41651  			}
 41652  		default:
 41653  			z.DecStructFieldNotFound(-1, yys3)
 41654  		} // end switch yys3
 41655  	} // end for yyj3
 41656  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 41657  }
 41658  
 41659  func (x *PeriodicForceResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 41660  	var h codecSelfer100
 41661  	z, r := codec1978.GenHelperDecoder(d)
 41662  	_, _, _ = h, z, r
 41663  	var yyj10 int
 41664  	var yyb10 bool
 41665  	var yyhl10 bool = l >= 0
 41666  	yyj10++
 41667  	if yyhl10 {
 41668  		yyb10 = yyj10 > l
 41669  	} else {
 41670  		yyb10 = r.CheckBreak()
 41671  	}
 41672  	if yyb10 {
 41673  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41674  		return
 41675  	}
 41676  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 41677  	if r.TryDecodeAsNil() {
 41678  		x.EvalID = ""
 41679  	} else {
 41680  		yyv11 := &x.EvalID
 41681  		yym12 := z.DecBinary()
 41682  		_ = yym12
 41683  		if false {
 41684  		} else {
 41685  			*((*string)(yyv11)) = r.DecodeString()
 41686  		}
 41687  	}
 41688  	yyj10++
 41689  	if yyhl10 {
 41690  		yyb10 = yyj10 > l
 41691  	} else {
 41692  		yyb10 = r.CheckBreak()
 41693  	}
 41694  	if yyb10 {
 41695  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41696  		return
 41697  	}
 41698  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 41699  	if r.TryDecodeAsNil() {
 41700  		x.EvalCreateIndex = 0
 41701  	} else {
 41702  		yyv13 := &x.EvalCreateIndex
 41703  		yym14 := z.DecBinary()
 41704  		_ = yym14
 41705  		if false {
 41706  		} else {
 41707  			*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 41708  		}
 41709  	}
 41710  	yyj10++
 41711  	if yyhl10 {
 41712  		yyb10 = yyj10 > l
 41713  	} else {
 41714  		yyb10 = r.CheckBreak()
 41715  	}
 41716  	if yyb10 {
 41717  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41718  		return
 41719  	}
 41720  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 41721  	if r.TryDecodeAsNil() {
 41722  		x.Index = 0
 41723  	} else {
 41724  		yyv15 := &x.Index
 41725  		yym16 := z.DecBinary()
 41726  		_ = yym16
 41727  		if false {
 41728  		} else {
 41729  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 41730  		}
 41731  	}
 41732  	for {
 41733  		yyj10++
 41734  		if yyhl10 {
 41735  			yyb10 = yyj10 > l
 41736  		} else {
 41737  			yyb10 = r.CheckBreak()
 41738  		}
 41739  		if yyb10 {
 41740  			break
 41741  		}
 41742  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 41743  		z.DecStructFieldNotFound(yyj10-1, "")
 41744  	}
 41745  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41746  }
 41747  
 41748  func (x *DeploymentUpdateResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 41749  	var h codecSelfer100
 41750  	z, r := codec1978.GenHelperEncoder(e)
 41751  	_, _, _ = h, z, r
 41752  	if x == nil {
 41753  		r.EncodeNil()
 41754  	} else {
 41755  		yym1 := z.EncBinary()
 41756  		_ = yym1
 41757  		if false {
 41758  		} else if z.HasExtensions() && z.EncExt(x) {
 41759  		} else {
 41760  			yysep2 := !z.EncBinary()
 41761  			yy2arr2 := z.EncBasicHandle().StructToArray
 41762  			var yyq2 [5]bool
 41763  			_, _, _ = yysep2, yyq2, yy2arr2
 41764  			const yyr2 bool = false
 41765  			var yynn2 int
 41766  			if yyr2 || yy2arr2 {
 41767  				r.EncodeArrayStart(5)
 41768  			} else {
 41769  				yynn2 = 5
 41770  				for _, b := range yyq2 {
 41771  					if b {
 41772  						yynn2++
 41773  					}
 41774  				}
 41775  				r.EncodeMapStart(yynn2)
 41776  				yynn2 = 0
 41777  			}
 41778  			if yyr2 || yy2arr2 {
 41779  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 41780  				yym4 := z.EncBinary()
 41781  				_ = yym4
 41782  				if false {
 41783  				} else {
 41784  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 41785  				}
 41786  			} else {
 41787  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 41788  				r.EncodeString(codecSelferC_UTF8100, string("EvalID"))
 41789  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 41790  				yym5 := z.EncBinary()
 41791  				_ = yym5
 41792  				if false {
 41793  				} else {
 41794  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 41795  				}
 41796  			}
 41797  			if yyr2 || yy2arr2 {
 41798  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 41799  				yym7 := z.EncBinary()
 41800  				_ = yym7
 41801  				if false {
 41802  				} else {
 41803  					r.EncodeUint(uint64(x.EvalCreateIndex))
 41804  				}
 41805  			} else {
 41806  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 41807  				r.EncodeString(codecSelferC_UTF8100, string("EvalCreateIndex"))
 41808  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 41809  				yym8 := z.EncBinary()
 41810  				_ = yym8
 41811  				if false {
 41812  				} else {
 41813  					r.EncodeUint(uint64(x.EvalCreateIndex))
 41814  				}
 41815  			}
 41816  			if yyr2 || yy2arr2 {
 41817  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 41818  				yym10 := z.EncBinary()
 41819  				_ = yym10
 41820  				if false {
 41821  				} else {
 41822  					r.EncodeUint(uint64(x.DeploymentModifyIndex))
 41823  				}
 41824  			} else {
 41825  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 41826  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentModifyIndex"))
 41827  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 41828  				yym11 := z.EncBinary()
 41829  				_ = yym11
 41830  				if false {
 41831  				} else {
 41832  					r.EncodeUint(uint64(x.DeploymentModifyIndex))
 41833  				}
 41834  			}
 41835  			if yyr2 || yy2arr2 {
 41836  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 41837  				if x.RevertedJobVersion == nil {
 41838  					r.EncodeNil()
 41839  				} else {
 41840  					yy13 := *x.RevertedJobVersion
 41841  					yym14 := z.EncBinary()
 41842  					_ = yym14
 41843  					if false {
 41844  					} else {
 41845  						r.EncodeUint(uint64(yy13))
 41846  					}
 41847  				}
 41848  			} else {
 41849  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 41850  				r.EncodeString(codecSelferC_UTF8100, string("RevertedJobVersion"))
 41851  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 41852  				if x.RevertedJobVersion == nil {
 41853  					r.EncodeNil()
 41854  				} else {
 41855  					yy15 := *x.RevertedJobVersion
 41856  					yym16 := z.EncBinary()
 41857  					_ = yym16
 41858  					if false {
 41859  					} else {
 41860  						r.EncodeUint(uint64(yy15))
 41861  					}
 41862  				}
 41863  			}
 41864  			if yyr2 || yy2arr2 {
 41865  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 41866  				yym18 := z.EncBinary()
 41867  				_ = yym18
 41868  				if false {
 41869  				} else {
 41870  					r.EncodeUint(uint64(x.Index))
 41871  				}
 41872  			} else {
 41873  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 41874  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 41875  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 41876  				yym19 := z.EncBinary()
 41877  				_ = yym19
 41878  				if false {
 41879  				} else {
 41880  					r.EncodeUint(uint64(x.Index))
 41881  				}
 41882  			}
 41883  			if yyr2 || yy2arr2 {
 41884  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 41885  			} else {
 41886  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 41887  			}
 41888  		}
 41889  	}
 41890  }
 41891  
 41892  func (x *DeploymentUpdateResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 41893  	var h codecSelfer100
 41894  	z, r := codec1978.GenHelperDecoder(d)
 41895  	_, _, _ = h, z, r
 41896  	yym1 := z.DecBinary()
 41897  	_ = yym1
 41898  	if false {
 41899  	} else if z.HasExtensions() && z.DecExt(x) {
 41900  	} else {
 41901  		yyct2 := r.ContainerType()
 41902  		if yyct2 == codecSelferValueTypeMap100 {
 41903  			yyl2 := r.ReadMapStart()
 41904  			if yyl2 == 0 {
 41905  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 41906  			} else {
 41907  				x.codecDecodeSelfFromMap(yyl2, d)
 41908  			}
 41909  		} else if yyct2 == codecSelferValueTypeArray100 {
 41910  			yyl2 := r.ReadArrayStart()
 41911  			if yyl2 == 0 {
 41912  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 41913  			} else {
 41914  				x.codecDecodeSelfFromArray(yyl2, d)
 41915  			}
 41916  		} else {
 41917  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 41918  		}
 41919  	}
 41920  }
 41921  
 41922  func (x *DeploymentUpdateResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 41923  	var h codecSelfer100
 41924  	z, r := codec1978.GenHelperDecoder(d)
 41925  	_, _, _ = h, z, r
 41926  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 41927  	_ = yys3Slc
 41928  	var yyhl3 bool = l >= 0
 41929  	for yyj3 := 0; ; yyj3++ {
 41930  		if yyhl3 {
 41931  			if yyj3 >= l {
 41932  				break
 41933  			}
 41934  		} else {
 41935  			if r.CheckBreak() {
 41936  				break
 41937  			}
 41938  		}
 41939  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 41940  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 41941  		yys3 := string(yys3Slc)
 41942  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 41943  		switch yys3 {
 41944  		case "EvalID":
 41945  			if r.TryDecodeAsNil() {
 41946  				x.EvalID = ""
 41947  			} else {
 41948  				yyv4 := &x.EvalID
 41949  				yym5 := z.DecBinary()
 41950  				_ = yym5
 41951  				if false {
 41952  				} else {
 41953  					*((*string)(yyv4)) = r.DecodeString()
 41954  				}
 41955  			}
 41956  		case "EvalCreateIndex":
 41957  			if r.TryDecodeAsNil() {
 41958  				x.EvalCreateIndex = 0
 41959  			} else {
 41960  				yyv6 := &x.EvalCreateIndex
 41961  				yym7 := z.DecBinary()
 41962  				_ = yym7
 41963  				if false {
 41964  				} else {
 41965  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 41966  				}
 41967  			}
 41968  		case "DeploymentModifyIndex":
 41969  			if r.TryDecodeAsNil() {
 41970  				x.DeploymentModifyIndex = 0
 41971  			} else {
 41972  				yyv8 := &x.DeploymentModifyIndex
 41973  				yym9 := z.DecBinary()
 41974  				_ = yym9
 41975  				if false {
 41976  				} else {
 41977  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 41978  				}
 41979  			}
 41980  		case "RevertedJobVersion":
 41981  			if r.TryDecodeAsNil() {
 41982  				if x.RevertedJobVersion != nil {
 41983  					x.RevertedJobVersion = nil
 41984  				}
 41985  			} else {
 41986  				if x.RevertedJobVersion == nil {
 41987  					x.RevertedJobVersion = new(uint64)
 41988  				}
 41989  				yym11 := z.DecBinary()
 41990  				_ = yym11
 41991  				if false {
 41992  				} else {
 41993  					*((*uint64)(x.RevertedJobVersion)) = uint64(r.DecodeUint(64))
 41994  				}
 41995  			}
 41996  		case "Index":
 41997  			if r.TryDecodeAsNil() {
 41998  				x.Index = 0
 41999  			} else {
 42000  				yyv12 := &x.Index
 42001  				yym13 := z.DecBinary()
 42002  				_ = yym13
 42003  				if false {
 42004  				} else {
 42005  					*((*uint64)(yyv12)) = uint64(r.DecodeUint(64))
 42006  				}
 42007  			}
 42008  		default:
 42009  			z.DecStructFieldNotFound(-1, yys3)
 42010  		} // end switch yys3
 42011  	} // end for yyj3
 42012  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 42013  }
 42014  
 42015  func (x *DeploymentUpdateResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 42016  	var h codecSelfer100
 42017  	z, r := codec1978.GenHelperDecoder(d)
 42018  	_, _, _ = h, z, r
 42019  	var yyj14 int
 42020  	var yyb14 bool
 42021  	var yyhl14 bool = l >= 0
 42022  	yyj14++
 42023  	if yyhl14 {
 42024  		yyb14 = yyj14 > l
 42025  	} else {
 42026  		yyb14 = r.CheckBreak()
 42027  	}
 42028  	if yyb14 {
 42029  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42030  		return
 42031  	}
 42032  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42033  	if r.TryDecodeAsNil() {
 42034  		x.EvalID = ""
 42035  	} else {
 42036  		yyv15 := &x.EvalID
 42037  		yym16 := z.DecBinary()
 42038  		_ = yym16
 42039  		if false {
 42040  		} else {
 42041  			*((*string)(yyv15)) = r.DecodeString()
 42042  		}
 42043  	}
 42044  	yyj14++
 42045  	if yyhl14 {
 42046  		yyb14 = yyj14 > l
 42047  	} else {
 42048  		yyb14 = r.CheckBreak()
 42049  	}
 42050  	if yyb14 {
 42051  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42052  		return
 42053  	}
 42054  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42055  	if r.TryDecodeAsNil() {
 42056  		x.EvalCreateIndex = 0
 42057  	} else {
 42058  		yyv17 := &x.EvalCreateIndex
 42059  		yym18 := z.DecBinary()
 42060  		_ = yym18
 42061  		if false {
 42062  		} else {
 42063  			*((*uint64)(yyv17)) = uint64(r.DecodeUint(64))
 42064  		}
 42065  	}
 42066  	yyj14++
 42067  	if yyhl14 {
 42068  		yyb14 = yyj14 > l
 42069  	} else {
 42070  		yyb14 = r.CheckBreak()
 42071  	}
 42072  	if yyb14 {
 42073  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42074  		return
 42075  	}
 42076  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42077  	if r.TryDecodeAsNil() {
 42078  		x.DeploymentModifyIndex = 0
 42079  	} else {
 42080  		yyv19 := &x.DeploymentModifyIndex
 42081  		yym20 := z.DecBinary()
 42082  		_ = yym20
 42083  		if false {
 42084  		} else {
 42085  			*((*uint64)(yyv19)) = uint64(r.DecodeUint(64))
 42086  		}
 42087  	}
 42088  	yyj14++
 42089  	if yyhl14 {
 42090  		yyb14 = yyj14 > l
 42091  	} else {
 42092  		yyb14 = r.CheckBreak()
 42093  	}
 42094  	if yyb14 {
 42095  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42096  		return
 42097  	}
 42098  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42099  	if r.TryDecodeAsNil() {
 42100  		if x.RevertedJobVersion != nil {
 42101  			x.RevertedJobVersion = nil
 42102  		}
 42103  	} else {
 42104  		if x.RevertedJobVersion == nil {
 42105  			x.RevertedJobVersion = new(uint64)
 42106  		}
 42107  		yym22 := z.DecBinary()
 42108  		_ = yym22
 42109  		if false {
 42110  		} else {
 42111  			*((*uint64)(x.RevertedJobVersion)) = uint64(r.DecodeUint(64))
 42112  		}
 42113  	}
 42114  	yyj14++
 42115  	if yyhl14 {
 42116  		yyb14 = yyj14 > l
 42117  	} else {
 42118  		yyb14 = r.CheckBreak()
 42119  	}
 42120  	if yyb14 {
 42121  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42122  		return
 42123  	}
 42124  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42125  	if r.TryDecodeAsNil() {
 42126  		x.Index = 0
 42127  	} else {
 42128  		yyv23 := &x.Index
 42129  		yym24 := z.DecBinary()
 42130  		_ = yym24
 42131  		if false {
 42132  		} else {
 42133  			*((*uint64)(yyv23)) = uint64(r.DecodeUint(64))
 42134  		}
 42135  	}
 42136  	for {
 42137  		yyj14++
 42138  		if yyhl14 {
 42139  			yyb14 = yyj14 > l
 42140  		} else {
 42141  			yyb14 = r.CheckBreak()
 42142  		}
 42143  		if yyb14 {
 42144  			break
 42145  		}
 42146  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42147  		z.DecStructFieldNotFound(yyj14-1, "")
 42148  	}
 42149  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42150  }
 42151  
 42152  func (x *NodeConnQueryResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 42153  	var h codecSelfer100
 42154  	z, r := codec1978.GenHelperEncoder(e)
 42155  	_, _, _ = h, z, r
 42156  	if x == nil {
 42157  		r.EncodeNil()
 42158  	} else {
 42159  		yym1 := z.EncBinary()
 42160  		_ = yym1
 42161  		if false {
 42162  		} else if z.HasExtensions() && z.EncExt(x) {
 42163  		} else {
 42164  			yysep2 := !z.EncBinary()
 42165  			yy2arr2 := z.EncBasicHandle().StructToArray
 42166  			var yyq2 [5]bool
 42167  			_, _, _ = yysep2, yyq2, yy2arr2
 42168  			const yyr2 bool = false
 42169  			var yynn2 int
 42170  			if yyr2 || yy2arr2 {
 42171  				r.EncodeArrayStart(5)
 42172  			} else {
 42173  				yynn2 = 5
 42174  				for _, b := range yyq2 {
 42175  					if b {
 42176  						yynn2++
 42177  					}
 42178  				}
 42179  				r.EncodeMapStart(yynn2)
 42180  				yynn2 = 0
 42181  			}
 42182  			if yyr2 || yy2arr2 {
 42183  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 42184  				yym4 := z.EncBinary()
 42185  				_ = yym4
 42186  				if false {
 42187  				} else {
 42188  					r.EncodeBool(bool(x.Connected))
 42189  				}
 42190  			} else {
 42191  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 42192  				r.EncodeString(codecSelferC_UTF8100, string("Connected"))
 42193  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 42194  				yym5 := z.EncBinary()
 42195  				_ = yym5
 42196  				if false {
 42197  				} else {
 42198  					r.EncodeBool(bool(x.Connected))
 42199  				}
 42200  			}
 42201  			if yyr2 || yy2arr2 {
 42202  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 42203  				yy7 := &x.Established
 42204  				yym8 := z.EncBinary()
 42205  				_ = yym8
 42206  				if false {
 42207  				} else if yym9 := z.TimeRtidIfBinc(); yym9 != 0 {
 42208  					r.EncodeBuiltin(yym9, yy7)
 42209  				} else if z.HasExtensions() && z.EncExt(yy7) {
 42210  				} else if yym8 {
 42211  					z.EncBinaryMarshal(yy7)
 42212  				} else if !yym8 && z.IsJSONHandle() {
 42213  					z.EncJSONMarshal(yy7)
 42214  				} else {
 42215  					z.EncFallback(yy7)
 42216  				}
 42217  			} else {
 42218  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 42219  				r.EncodeString(codecSelferC_UTF8100, string("Established"))
 42220  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 42221  				yy10 := &x.Established
 42222  				yym11 := z.EncBinary()
 42223  				_ = yym11
 42224  				if false {
 42225  				} else if yym12 := z.TimeRtidIfBinc(); yym12 != 0 {
 42226  					r.EncodeBuiltin(yym12, yy10)
 42227  				} else if z.HasExtensions() && z.EncExt(yy10) {
 42228  				} else if yym11 {
 42229  					z.EncBinaryMarshal(yy10)
 42230  				} else if !yym11 && z.IsJSONHandle() {
 42231  					z.EncJSONMarshal(yy10)
 42232  				} else {
 42233  					z.EncFallback(yy10)
 42234  				}
 42235  			}
 42236  			if yyr2 || yy2arr2 {
 42237  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 42238  				yym14 := z.EncBinary()
 42239  				_ = yym14
 42240  				if false {
 42241  				} else {
 42242  					r.EncodeUint(uint64(x.Index))
 42243  				}
 42244  			} else {
 42245  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 42246  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 42247  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 42248  				yym15 := z.EncBinary()
 42249  				_ = yym15
 42250  				if false {
 42251  				} else {
 42252  					r.EncodeUint(uint64(x.Index))
 42253  				}
 42254  			}
 42255  			if yyr2 || yy2arr2 {
 42256  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 42257  				yym17 := z.EncBinary()
 42258  				_ = yym17
 42259  				if false {
 42260  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 42261  				} else {
 42262  					r.EncodeInt(int64(x.LastContact))
 42263  				}
 42264  			} else {
 42265  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 42266  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 42267  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 42268  				yym18 := z.EncBinary()
 42269  				_ = yym18
 42270  				if false {
 42271  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 42272  				} else {
 42273  					r.EncodeInt(int64(x.LastContact))
 42274  				}
 42275  			}
 42276  			if yyr2 || yy2arr2 {
 42277  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 42278  				yym20 := z.EncBinary()
 42279  				_ = yym20
 42280  				if false {
 42281  				} else {
 42282  					r.EncodeBool(bool(x.KnownLeader))
 42283  				}
 42284  			} else {
 42285  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 42286  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 42287  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 42288  				yym21 := z.EncBinary()
 42289  				_ = yym21
 42290  				if false {
 42291  				} else {
 42292  					r.EncodeBool(bool(x.KnownLeader))
 42293  				}
 42294  			}
 42295  			if yyr2 || yy2arr2 {
 42296  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 42297  			} else {
 42298  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 42299  			}
 42300  		}
 42301  	}
 42302  }
 42303  
 42304  func (x *NodeConnQueryResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 42305  	var h codecSelfer100
 42306  	z, r := codec1978.GenHelperDecoder(d)
 42307  	_, _, _ = h, z, r
 42308  	yym1 := z.DecBinary()
 42309  	_ = yym1
 42310  	if false {
 42311  	} else if z.HasExtensions() && z.DecExt(x) {
 42312  	} else {
 42313  		yyct2 := r.ContainerType()
 42314  		if yyct2 == codecSelferValueTypeMap100 {
 42315  			yyl2 := r.ReadMapStart()
 42316  			if yyl2 == 0 {
 42317  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 42318  			} else {
 42319  				x.codecDecodeSelfFromMap(yyl2, d)
 42320  			}
 42321  		} else if yyct2 == codecSelferValueTypeArray100 {
 42322  			yyl2 := r.ReadArrayStart()
 42323  			if yyl2 == 0 {
 42324  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42325  			} else {
 42326  				x.codecDecodeSelfFromArray(yyl2, d)
 42327  			}
 42328  		} else {
 42329  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 42330  		}
 42331  	}
 42332  }
 42333  
 42334  func (x *NodeConnQueryResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 42335  	var h codecSelfer100
 42336  	z, r := codec1978.GenHelperDecoder(d)
 42337  	_, _, _ = h, z, r
 42338  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 42339  	_ = yys3Slc
 42340  	var yyhl3 bool = l >= 0
 42341  	for yyj3 := 0; ; yyj3++ {
 42342  		if yyhl3 {
 42343  			if yyj3 >= l {
 42344  				break
 42345  			}
 42346  		} else {
 42347  			if r.CheckBreak() {
 42348  				break
 42349  			}
 42350  		}
 42351  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 42352  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 42353  		yys3 := string(yys3Slc)
 42354  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 42355  		switch yys3 {
 42356  		case "Connected":
 42357  			if r.TryDecodeAsNil() {
 42358  				x.Connected = false
 42359  			} else {
 42360  				yyv4 := &x.Connected
 42361  				yym5 := z.DecBinary()
 42362  				_ = yym5
 42363  				if false {
 42364  				} else {
 42365  					*((*bool)(yyv4)) = r.DecodeBool()
 42366  				}
 42367  			}
 42368  		case "Established":
 42369  			if r.TryDecodeAsNil() {
 42370  				x.Established = time.Time{}
 42371  			} else {
 42372  				yyv6 := &x.Established
 42373  				yym7 := z.DecBinary()
 42374  				_ = yym7
 42375  				if false {
 42376  				} else if yym8 := z.TimeRtidIfBinc(); yym8 != 0 {
 42377  					r.DecodeBuiltin(yym8, yyv6)
 42378  				} else if z.HasExtensions() && z.DecExt(yyv6) {
 42379  				} else if yym7 {
 42380  					z.DecBinaryUnmarshal(yyv6)
 42381  				} else if !yym7 && z.IsJSONHandle() {
 42382  					z.DecJSONUnmarshal(yyv6)
 42383  				} else {
 42384  					z.DecFallback(yyv6, false)
 42385  				}
 42386  			}
 42387  		case "Index":
 42388  			if r.TryDecodeAsNil() {
 42389  				x.Index = 0
 42390  			} else {
 42391  				yyv9 := &x.Index
 42392  				yym10 := z.DecBinary()
 42393  				_ = yym10
 42394  				if false {
 42395  				} else {
 42396  					*((*uint64)(yyv9)) = uint64(r.DecodeUint(64))
 42397  				}
 42398  			}
 42399  		case "LastContact":
 42400  			if r.TryDecodeAsNil() {
 42401  				x.LastContact = 0
 42402  			} else {
 42403  				yyv11 := &x.LastContact
 42404  				yym12 := z.DecBinary()
 42405  				_ = yym12
 42406  				if false {
 42407  				} else if z.HasExtensions() && z.DecExt(yyv11) {
 42408  				} else {
 42409  					*((*int64)(yyv11)) = int64(r.DecodeInt(64))
 42410  				}
 42411  			}
 42412  		case "KnownLeader":
 42413  			if r.TryDecodeAsNil() {
 42414  				x.KnownLeader = false
 42415  			} else {
 42416  				yyv13 := &x.KnownLeader
 42417  				yym14 := z.DecBinary()
 42418  				_ = yym14
 42419  				if false {
 42420  				} else {
 42421  					*((*bool)(yyv13)) = r.DecodeBool()
 42422  				}
 42423  			}
 42424  		default:
 42425  			z.DecStructFieldNotFound(-1, yys3)
 42426  		} // end switch yys3
 42427  	} // end for yyj3
 42428  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 42429  }
 42430  
 42431  func (x *NodeConnQueryResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 42432  	var h codecSelfer100
 42433  	z, r := codec1978.GenHelperDecoder(d)
 42434  	_, _, _ = h, z, r
 42435  	var yyj15 int
 42436  	var yyb15 bool
 42437  	var yyhl15 bool = l >= 0
 42438  	yyj15++
 42439  	if yyhl15 {
 42440  		yyb15 = yyj15 > l
 42441  	} else {
 42442  		yyb15 = r.CheckBreak()
 42443  	}
 42444  	if yyb15 {
 42445  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42446  		return
 42447  	}
 42448  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42449  	if r.TryDecodeAsNil() {
 42450  		x.Connected = false
 42451  	} else {
 42452  		yyv16 := &x.Connected
 42453  		yym17 := z.DecBinary()
 42454  		_ = yym17
 42455  		if false {
 42456  		} else {
 42457  			*((*bool)(yyv16)) = r.DecodeBool()
 42458  		}
 42459  	}
 42460  	yyj15++
 42461  	if yyhl15 {
 42462  		yyb15 = yyj15 > l
 42463  	} else {
 42464  		yyb15 = r.CheckBreak()
 42465  	}
 42466  	if yyb15 {
 42467  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42468  		return
 42469  	}
 42470  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42471  	if r.TryDecodeAsNil() {
 42472  		x.Established = time.Time{}
 42473  	} else {
 42474  		yyv18 := &x.Established
 42475  		yym19 := z.DecBinary()
 42476  		_ = yym19
 42477  		if false {
 42478  		} else if yym20 := z.TimeRtidIfBinc(); yym20 != 0 {
 42479  			r.DecodeBuiltin(yym20, yyv18)
 42480  		} else if z.HasExtensions() && z.DecExt(yyv18) {
 42481  		} else if yym19 {
 42482  			z.DecBinaryUnmarshal(yyv18)
 42483  		} else if !yym19 && z.IsJSONHandle() {
 42484  			z.DecJSONUnmarshal(yyv18)
 42485  		} else {
 42486  			z.DecFallback(yyv18, false)
 42487  		}
 42488  	}
 42489  	yyj15++
 42490  	if yyhl15 {
 42491  		yyb15 = yyj15 > l
 42492  	} else {
 42493  		yyb15 = r.CheckBreak()
 42494  	}
 42495  	if yyb15 {
 42496  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42497  		return
 42498  	}
 42499  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42500  	if r.TryDecodeAsNil() {
 42501  		x.Index = 0
 42502  	} else {
 42503  		yyv21 := &x.Index
 42504  		yym22 := z.DecBinary()
 42505  		_ = yym22
 42506  		if false {
 42507  		} else {
 42508  			*((*uint64)(yyv21)) = uint64(r.DecodeUint(64))
 42509  		}
 42510  	}
 42511  	yyj15++
 42512  	if yyhl15 {
 42513  		yyb15 = yyj15 > l
 42514  	} else {
 42515  		yyb15 = r.CheckBreak()
 42516  	}
 42517  	if yyb15 {
 42518  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42519  		return
 42520  	}
 42521  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42522  	if r.TryDecodeAsNil() {
 42523  		x.LastContact = 0
 42524  	} else {
 42525  		yyv23 := &x.LastContact
 42526  		yym24 := z.DecBinary()
 42527  		_ = yym24
 42528  		if false {
 42529  		} else if z.HasExtensions() && z.DecExt(yyv23) {
 42530  		} else {
 42531  			*((*int64)(yyv23)) = int64(r.DecodeInt(64))
 42532  		}
 42533  	}
 42534  	yyj15++
 42535  	if yyhl15 {
 42536  		yyb15 = yyj15 > l
 42537  	} else {
 42538  		yyb15 = r.CheckBreak()
 42539  	}
 42540  	if yyb15 {
 42541  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42542  		return
 42543  	}
 42544  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42545  	if r.TryDecodeAsNil() {
 42546  		x.KnownLeader = false
 42547  	} else {
 42548  		yyv25 := &x.KnownLeader
 42549  		yym26 := z.DecBinary()
 42550  		_ = yym26
 42551  		if false {
 42552  		} else {
 42553  			*((*bool)(yyv25)) = r.DecodeBool()
 42554  		}
 42555  	}
 42556  	for {
 42557  		yyj15++
 42558  		if yyhl15 {
 42559  			yyb15 = yyj15 > l
 42560  		} else {
 42561  			yyb15 = r.CheckBreak()
 42562  		}
 42563  		if yyb15 {
 42564  			break
 42565  		}
 42566  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42567  		z.DecStructFieldNotFound(yyj15-1, "")
 42568  	}
 42569  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42570  }
 42571  
 42572  func (x *EmitNodeEventsRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 42573  	var h codecSelfer100
 42574  	z, r := codec1978.GenHelperEncoder(e)
 42575  	_, _, _ = h, z, r
 42576  	if x == nil {
 42577  		r.EncodeNil()
 42578  	} else {
 42579  		yym1 := z.EncBinary()
 42580  		_ = yym1
 42581  		if false {
 42582  		} else if z.HasExtensions() && z.EncExt(x) {
 42583  		} else {
 42584  			yysep2 := !z.EncBinary()
 42585  			yy2arr2 := z.EncBasicHandle().StructToArray
 42586  			var yyq2 [5]bool
 42587  			_, _, _ = yysep2, yyq2, yy2arr2
 42588  			const yyr2 bool = false
 42589  			var yynn2 int
 42590  			if yyr2 || yy2arr2 {
 42591  				r.EncodeArrayStart(5)
 42592  			} else {
 42593  				yynn2 = 5
 42594  				for _, b := range yyq2 {
 42595  					if b {
 42596  						yynn2++
 42597  					}
 42598  				}
 42599  				r.EncodeMapStart(yynn2)
 42600  				yynn2 = 0
 42601  			}
 42602  			if yyr2 || yy2arr2 {
 42603  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 42604  				if x.NodeEvents == nil {
 42605  					r.EncodeNil()
 42606  				} else {
 42607  					yym4 := z.EncBinary()
 42608  					_ = yym4
 42609  					if false {
 42610  					} else {
 42611  						h.encMapstringSlicePtrtoNodeEvent((map[string][]*NodeEvent)(x.NodeEvents), e)
 42612  					}
 42613  				}
 42614  			} else {
 42615  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 42616  				r.EncodeString(codecSelferC_UTF8100, string("NodeEvents"))
 42617  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 42618  				if x.NodeEvents == nil {
 42619  					r.EncodeNil()
 42620  				} else {
 42621  					yym5 := z.EncBinary()
 42622  					_ = yym5
 42623  					if false {
 42624  					} else {
 42625  						h.encMapstringSlicePtrtoNodeEvent((map[string][]*NodeEvent)(x.NodeEvents), e)
 42626  					}
 42627  				}
 42628  			}
 42629  			if yyr2 || yy2arr2 {
 42630  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 42631  				yym7 := z.EncBinary()
 42632  				_ = yym7
 42633  				if false {
 42634  				} else {
 42635  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 42636  				}
 42637  			} else {
 42638  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 42639  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 42640  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 42641  				yym8 := z.EncBinary()
 42642  				_ = yym8
 42643  				if false {
 42644  				} else {
 42645  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 42646  				}
 42647  			}
 42648  			if yyr2 || yy2arr2 {
 42649  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 42650  				yym10 := z.EncBinary()
 42651  				_ = yym10
 42652  				if false {
 42653  				} else {
 42654  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 42655  				}
 42656  			} else {
 42657  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 42658  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 42659  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 42660  				yym11 := z.EncBinary()
 42661  				_ = yym11
 42662  				if false {
 42663  				} else {
 42664  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 42665  				}
 42666  			}
 42667  			if yyr2 || yy2arr2 {
 42668  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 42669  				yym13 := z.EncBinary()
 42670  				_ = yym13
 42671  				if false {
 42672  				} else {
 42673  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 42674  				}
 42675  			} else {
 42676  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 42677  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 42678  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 42679  				yym14 := z.EncBinary()
 42680  				_ = yym14
 42681  				if false {
 42682  				} else {
 42683  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 42684  				}
 42685  			}
 42686  			if yyr2 || yy2arr2 {
 42687  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 42688  				yym16 := z.EncBinary()
 42689  				_ = yym16
 42690  				if false {
 42691  				} else {
 42692  					r.EncodeBool(bool(x.Forwarded))
 42693  				}
 42694  			} else {
 42695  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 42696  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 42697  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 42698  				yym17 := z.EncBinary()
 42699  				_ = yym17
 42700  				if false {
 42701  				} else {
 42702  					r.EncodeBool(bool(x.Forwarded))
 42703  				}
 42704  			}
 42705  			if yyr2 || yy2arr2 {
 42706  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 42707  			} else {
 42708  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 42709  			}
 42710  		}
 42711  	}
 42712  }
 42713  
 42714  func (x *EmitNodeEventsRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 42715  	var h codecSelfer100
 42716  	z, r := codec1978.GenHelperDecoder(d)
 42717  	_, _, _ = h, z, r
 42718  	yym1 := z.DecBinary()
 42719  	_ = yym1
 42720  	if false {
 42721  	} else if z.HasExtensions() && z.DecExt(x) {
 42722  	} else {
 42723  		yyct2 := r.ContainerType()
 42724  		if yyct2 == codecSelferValueTypeMap100 {
 42725  			yyl2 := r.ReadMapStart()
 42726  			if yyl2 == 0 {
 42727  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 42728  			} else {
 42729  				x.codecDecodeSelfFromMap(yyl2, d)
 42730  			}
 42731  		} else if yyct2 == codecSelferValueTypeArray100 {
 42732  			yyl2 := r.ReadArrayStart()
 42733  			if yyl2 == 0 {
 42734  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42735  			} else {
 42736  				x.codecDecodeSelfFromArray(yyl2, d)
 42737  			}
 42738  		} else {
 42739  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 42740  		}
 42741  	}
 42742  }
 42743  
 42744  func (x *EmitNodeEventsRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 42745  	var h codecSelfer100
 42746  	z, r := codec1978.GenHelperDecoder(d)
 42747  	_, _, _ = h, z, r
 42748  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 42749  	_ = yys3Slc
 42750  	var yyhl3 bool = l >= 0
 42751  	for yyj3 := 0; ; yyj3++ {
 42752  		if yyhl3 {
 42753  			if yyj3 >= l {
 42754  				break
 42755  			}
 42756  		} else {
 42757  			if r.CheckBreak() {
 42758  				break
 42759  			}
 42760  		}
 42761  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 42762  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 42763  		yys3 := string(yys3Slc)
 42764  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 42765  		switch yys3 {
 42766  		case "NodeEvents":
 42767  			if r.TryDecodeAsNil() {
 42768  				x.NodeEvents = nil
 42769  			} else {
 42770  				yyv4 := &x.NodeEvents
 42771  				yym5 := z.DecBinary()
 42772  				_ = yym5
 42773  				if false {
 42774  				} else {
 42775  					h.decMapstringSlicePtrtoNodeEvent((*map[string][]*NodeEvent)(yyv4), d)
 42776  				}
 42777  			}
 42778  		case "Region":
 42779  			if r.TryDecodeAsNil() {
 42780  				x.Region = ""
 42781  			} else {
 42782  				yyv6 := &x.Region
 42783  				yym7 := z.DecBinary()
 42784  				_ = yym7
 42785  				if false {
 42786  				} else {
 42787  					*((*string)(yyv6)) = r.DecodeString()
 42788  				}
 42789  			}
 42790  		case "Namespace":
 42791  			if r.TryDecodeAsNil() {
 42792  				x.Namespace = ""
 42793  			} else {
 42794  				yyv8 := &x.Namespace
 42795  				yym9 := z.DecBinary()
 42796  				_ = yym9
 42797  				if false {
 42798  				} else {
 42799  					*((*string)(yyv8)) = r.DecodeString()
 42800  				}
 42801  			}
 42802  		case "AuthToken":
 42803  			if r.TryDecodeAsNil() {
 42804  				x.AuthToken = ""
 42805  			} else {
 42806  				yyv10 := &x.AuthToken
 42807  				yym11 := z.DecBinary()
 42808  				_ = yym11
 42809  				if false {
 42810  				} else {
 42811  					*((*string)(yyv10)) = r.DecodeString()
 42812  				}
 42813  			}
 42814  		case "Forwarded":
 42815  			if r.TryDecodeAsNil() {
 42816  				x.Forwarded = false
 42817  			} else {
 42818  				yyv12 := &x.Forwarded
 42819  				yym13 := z.DecBinary()
 42820  				_ = yym13
 42821  				if false {
 42822  				} else {
 42823  					*((*bool)(yyv12)) = r.DecodeBool()
 42824  				}
 42825  			}
 42826  		default:
 42827  			z.DecStructFieldNotFound(-1, yys3)
 42828  		} // end switch yys3
 42829  	} // end for yyj3
 42830  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 42831  }
 42832  
 42833  func (x *EmitNodeEventsRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 42834  	var h codecSelfer100
 42835  	z, r := codec1978.GenHelperDecoder(d)
 42836  	_, _, _ = h, z, r
 42837  	var yyj14 int
 42838  	var yyb14 bool
 42839  	var yyhl14 bool = l >= 0
 42840  	yyj14++
 42841  	if yyhl14 {
 42842  		yyb14 = yyj14 > l
 42843  	} else {
 42844  		yyb14 = r.CheckBreak()
 42845  	}
 42846  	if yyb14 {
 42847  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42848  		return
 42849  	}
 42850  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42851  	if r.TryDecodeAsNil() {
 42852  		x.NodeEvents = nil
 42853  	} else {
 42854  		yyv15 := &x.NodeEvents
 42855  		yym16 := z.DecBinary()
 42856  		_ = yym16
 42857  		if false {
 42858  		} else {
 42859  			h.decMapstringSlicePtrtoNodeEvent((*map[string][]*NodeEvent)(yyv15), d)
 42860  		}
 42861  	}
 42862  	yyj14++
 42863  	if yyhl14 {
 42864  		yyb14 = yyj14 > l
 42865  	} else {
 42866  		yyb14 = r.CheckBreak()
 42867  	}
 42868  	if yyb14 {
 42869  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42870  		return
 42871  	}
 42872  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42873  	if r.TryDecodeAsNil() {
 42874  		x.Region = ""
 42875  	} else {
 42876  		yyv17 := &x.Region
 42877  		yym18 := z.DecBinary()
 42878  		_ = yym18
 42879  		if false {
 42880  		} else {
 42881  			*((*string)(yyv17)) = r.DecodeString()
 42882  		}
 42883  	}
 42884  	yyj14++
 42885  	if yyhl14 {
 42886  		yyb14 = yyj14 > l
 42887  	} else {
 42888  		yyb14 = r.CheckBreak()
 42889  	}
 42890  	if yyb14 {
 42891  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42892  		return
 42893  	}
 42894  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42895  	if r.TryDecodeAsNil() {
 42896  		x.Namespace = ""
 42897  	} else {
 42898  		yyv19 := &x.Namespace
 42899  		yym20 := z.DecBinary()
 42900  		_ = yym20
 42901  		if false {
 42902  		} else {
 42903  			*((*string)(yyv19)) = r.DecodeString()
 42904  		}
 42905  	}
 42906  	yyj14++
 42907  	if yyhl14 {
 42908  		yyb14 = yyj14 > l
 42909  	} else {
 42910  		yyb14 = r.CheckBreak()
 42911  	}
 42912  	if yyb14 {
 42913  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42914  		return
 42915  	}
 42916  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42917  	if r.TryDecodeAsNil() {
 42918  		x.AuthToken = ""
 42919  	} else {
 42920  		yyv21 := &x.AuthToken
 42921  		yym22 := z.DecBinary()
 42922  		_ = yym22
 42923  		if false {
 42924  		} else {
 42925  			*((*string)(yyv21)) = r.DecodeString()
 42926  		}
 42927  	}
 42928  	yyj14++
 42929  	if yyhl14 {
 42930  		yyb14 = yyj14 > l
 42931  	} else {
 42932  		yyb14 = r.CheckBreak()
 42933  	}
 42934  	if yyb14 {
 42935  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42936  		return
 42937  	}
 42938  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42939  	if r.TryDecodeAsNil() {
 42940  		x.Forwarded = false
 42941  	} else {
 42942  		yyv23 := &x.Forwarded
 42943  		yym24 := z.DecBinary()
 42944  		_ = yym24
 42945  		if false {
 42946  		} else {
 42947  			*((*bool)(yyv23)) = r.DecodeBool()
 42948  		}
 42949  	}
 42950  	for {
 42951  		yyj14++
 42952  		if yyhl14 {
 42953  			yyb14 = yyj14 > l
 42954  		} else {
 42955  			yyb14 = r.CheckBreak()
 42956  		}
 42957  		if yyb14 {
 42958  			break
 42959  		}
 42960  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 42961  		z.DecStructFieldNotFound(yyj14-1, "")
 42962  	}
 42963  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 42964  }
 42965  
 42966  func (x *EmitNodeEventsResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 42967  	var h codecSelfer100
 42968  	z, r := codec1978.GenHelperEncoder(e)
 42969  	_, _, _ = h, z, r
 42970  	if x == nil {
 42971  		r.EncodeNil()
 42972  	} else {
 42973  		yym1 := z.EncBinary()
 42974  		_ = yym1
 42975  		if false {
 42976  		} else if z.HasExtensions() && z.EncExt(x) {
 42977  		} else {
 42978  			yysep2 := !z.EncBinary()
 42979  			yy2arr2 := z.EncBasicHandle().StructToArray
 42980  			var yyq2 [1]bool
 42981  			_, _, _ = yysep2, yyq2, yy2arr2
 42982  			const yyr2 bool = false
 42983  			var yynn2 int
 42984  			if yyr2 || yy2arr2 {
 42985  				r.EncodeArrayStart(1)
 42986  			} else {
 42987  				yynn2 = 1
 42988  				for _, b := range yyq2 {
 42989  					if b {
 42990  						yynn2++
 42991  					}
 42992  				}
 42993  				r.EncodeMapStart(yynn2)
 42994  				yynn2 = 0
 42995  			}
 42996  			if yyr2 || yy2arr2 {
 42997  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 42998  				yym4 := z.EncBinary()
 42999  				_ = yym4
 43000  				if false {
 43001  				} else {
 43002  					r.EncodeUint(uint64(x.Index))
 43003  				}
 43004  			} else {
 43005  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 43006  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 43007  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 43008  				yym5 := z.EncBinary()
 43009  				_ = yym5
 43010  				if false {
 43011  				} else {
 43012  					r.EncodeUint(uint64(x.Index))
 43013  				}
 43014  			}
 43015  			if yyr2 || yy2arr2 {
 43016  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 43017  			} else {
 43018  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 43019  			}
 43020  		}
 43021  	}
 43022  }
 43023  
 43024  func (x *EmitNodeEventsResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 43025  	var h codecSelfer100
 43026  	z, r := codec1978.GenHelperDecoder(d)
 43027  	_, _, _ = h, z, r
 43028  	yym1 := z.DecBinary()
 43029  	_ = yym1
 43030  	if false {
 43031  	} else if z.HasExtensions() && z.DecExt(x) {
 43032  	} else {
 43033  		yyct2 := r.ContainerType()
 43034  		if yyct2 == codecSelferValueTypeMap100 {
 43035  			yyl2 := r.ReadMapStart()
 43036  			if yyl2 == 0 {
 43037  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 43038  			} else {
 43039  				x.codecDecodeSelfFromMap(yyl2, d)
 43040  			}
 43041  		} else if yyct2 == codecSelferValueTypeArray100 {
 43042  			yyl2 := r.ReadArrayStart()
 43043  			if yyl2 == 0 {
 43044  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 43045  			} else {
 43046  				x.codecDecodeSelfFromArray(yyl2, d)
 43047  			}
 43048  		} else {
 43049  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 43050  		}
 43051  	}
 43052  }
 43053  
 43054  func (x *EmitNodeEventsResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 43055  	var h codecSelfer100
 43056  	z, r := codec1978.GenHelperDecoder(d)
 43057  	_, _, _ = h, z, r
 43058  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 43059  	_ = yys3Slc
 43060  	var yyhl3 bool = l >= 0
 43061  	for yyj3 := 0; ; yyj3++ {
 43062  		if yyhl3 {
 43063  			if yyj3 >= l {
 43064  				break
 43065  			}
 43066  		} else {
 43067  			if r.CheckBreak() {
 43068  				break
 43069  			}
 43070  		}
 43071  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 43072  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 43073  		yys3 := string(yys3Slc)
 43074  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 43075  		switch yys3 {
 43076  		case "Index":
 43077  			if r.TryDecodeAsNil() {
 43078  				x.Index = 0
 43079  			} else {
 43080  				yyv4 := &x.Index
 43081  				yym5 := z.DecBinary()
 43082  				_ = yym5
 43083  				if false {
 43084  				} else {
 43085  					*((*uint64)(yyv4)) = uint64(r.DecodeUint(64))
 43086  				}
 43087  			}
 43088  		default:
 43089  			z.DecStructFieldNotFound(-1, yys3)
 43090  		} // end switch yys3
 43091  	} // end for yyj3
 43092  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 43093  }
 43094  
 43095  func (x *EmitNodeEventsResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 43096  	var h codecSelfer100
 43097  	z, r := codec1978.GenHelperDecoder(d)
 43098  	_, _, _ = h, z, r
 43099  	var yyj6 int
 43100  	var yyb6 bool
 43101  	var yyhl6 bool = l >= 0
 43102  	yyj6++
 43103  	if yyhl6 {
 43104  		yyb6 = yyj6 > l
 43105  	} else {
 43106  		yyb6 = r.CheckBreak()
 43107  	}
 43108  	if yyb6 {
 43109  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 43110  		return
 43111  	}
 43112  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 43113  	if r.TryDecodeAsNil() {
 43114  		x.Index = 0
 43115  	} else {
 43116  		yyv7 := &x.Index
 43117  		yym8 := z.DecBinary()
 43118  		_ = yym8
 43119  		if false {
 43120  		} else {
 43121  			*((*uint64)(yyv7)) = uint64(r.DecodeUint(64))
 43122  		}
 43123  	}
 43124  	for {
 43125  		yyj6++
 43126  		if yyhl6 {
 43127  			yyb6 = yyj6 > l
 43128  		} else {
 43129  			yyb6 = r.CheckBreak()
 43130  		}
 43131  		if yyb6 {
 43132  			break
 43133  		}
 43134  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 43135  		z.DecStructFieldNotFound(yyj6-1, "")
 43136  	}
 43137  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 43138  }
 43139  
 43140  func (x *NodeEvent) CodecEncodeSelf(e *codec1978.Encoder) {
 43141  	var h codecSelfer100
 43142  	z, r := codec1978.GenHelperEncoder(e)
 43143  	_, _, _ = h, z, r
 43144  	if x == nil {
 43145  		r.EncodeNil()
 43146  	} else {
 43147  		yym1 := z.EncBinary()
 43148  		_ = yym1
 43149  		if false {
 43150  		} else if z.HasExtensions() && z.EncExt(x) {
 43151  		} else {
 43152  			yysep2 := !z.EncBinary()
 43153  			yy2arr2 := z.EncBasicHandle().StructToArray
 43154  			var yyq2 [5]bool
 43155  			_, _, _ = yysep2, yyq2, yy2arr2
 43156  			const yyr2 bool = false
 43157  			var yynn2 int
 43158  			if yyr2 || yy2arr2 {
 43159  				r.EncodeArrayStart(5)
 43160  			} else {
 43161  				yynn2 = 5
 43162  				for _, b := range yyq2 {
 43163  					if b {
 43164  						yynn2++
 43165  					}
 43166  				}
 43167  				r.EncodeMapStart(yynn2)
 43168  				yynn2 = 0
 43169  			}
 43170  			if yyr2 || yy2arr2 {
 43171  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 43172  				yym4 := z.EncBinary()
 43173  				_ = yym4
 43174  				if false {
 43175  				} else {
 43176  					r.EncodeString(codecSelferC_UTF8100, string(x.Message))
 43177  				}
 43178  			} else {
 43179  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 43180  				r.EncodeString(codecSelferC_UTF8100, string("Message"))
 43181  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 43182  				yym5 := z.EncBinary()
 43183  				_ = yym5
 43184  				if false {
 43185  				} else {
 43186  					r.EncodeString(codecSelferC_UTF8100, string(x.Message))
 43187  				}
 43188  			}
 43189  			if yyr2 || yy2arr2 {
 43190  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 43191  				yym7 := z.EncBinary()
 43192  				_ = yym7
 43193  				if false {
 43194  				} else {
 43195  					r.EncodeString(codecSelferC_UTF8100, string(x.Subsystem))
 43196  				}
 43197  			} else {
 43198  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 43199  				r.EncodeString(codecSelferC_UTF8100, string("Subsystem"))
 43200  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 43201  				yym8 := z.EncBinary()
 43202  				_ = yym8
 43203  				if false {
 43204  				} else {
 43205  					r.EncodeString(codecSelferC_UTF8100, string(x.Subsystem))
 43206  				}
 43207  			}
 43208  			if yyr2 || yy2arr2 {
 43209  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 43210  				if x.Details == nil {
 43211  					r.EncodeNil()
 43212  				} else {
 43213  					yym10 := z.EncBinary()
 43214  					_ = yym10
 43215  					if false {
 43216  					} else {
 43217  						z.F.EncMapStringStringV(x.Details, false, e)
 43218  					}
 43219  				}
 43220  			} else {
 43221  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 43222  				r.EncodeString(codecSelferC_UTF8100, string("Details"))
 43223  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 43224  				if x.Details == nil {
 43225  					r.EncodeNil()
 43226  				} else {
 43227  					yym11 := z.EncBinary()
 43228  					_ = yym11
 43229  					if false {
 43230  					} else {
 43231  						z.F.EncMapStringStringV(x.Details, false, e)
 43232  					}
 43233  				}
 43234  			}
 43235  			if yyr2 || yy2arr2 {
 43236  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 43237  				yy13 := &x.Timestamp
 43238  				yym14 := z.EncBinary()
 43239  				_ = yym14
 43240  				if false {
 43241  				} else if yym15 := z.TimeRtidIfBinc(); yym15 != 0 {
 43242  					r.EncodeBuiltin(yym15, yy13)
 43243  				} else if z.HasExtensions() && z.EncExt(yy13) {
 43244  				} else if yym14 {
 43245  					z.EncBinaryMarshal(yy13)
 43246  				} else if !yym14 && z.IsJSONHandle() {
 43247  					z.EncJSONMarshal(yy13)
 43248  				} else {
 43249  					z.EncFallback(yy13)
 43250  				}
 43251  			} else {
 43252  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 43253  				r.EncodeString(codecSelferC_UTF8100, string("Timestamp"))
 43254  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 43255  				yy16 := &x.Timestamp
 43256  				yym17 := z.EncBinary()
 43257  				_ = yym17
 43258  				if false {
 43259  				} else if yym18 := z.TimeRtidIfBinc(); yym18 != 0 {
 43260  					r.EncodeBuiltin(yym18, yy16)
 43261  				} else if z.HasExtensions() && z.EncExt(yy16) {
 43262  				} else if yym17 {
 43263  					z.EncBinaryMarshal(yy16)
 43264  				} else if !yym17 && z.IsJSONHandle() {
 43265  					z.EncJSONMarshal(yy16)
 43266  				} else {
 43267  					z.EncFallback(yy16)
 43268  				}
 43269  			}
 43270  			if yyr2 || yy2arr2 {
 43271  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 43272  				yym20 := z.EncBinary()
 43273  				_ = yym20
 43274  				if false {
 43275  				} else {
 43276  					r.EncodeUint(uint64(x.CreateIndex))
 43277  				}
 43278  			} else {
 43279  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 43280  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 43281  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 43282  				yym21 := z.EncBinary()
 43283  				_ = yym21
 43284  				if false {
 43285  				} else {
 43286  					r.EncodeUint(uint64(x.CreateIndex))
 43287  				}
 43288  			}
 43289  			if yyr2 || yy2arr2 {
 43290  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 43291  			} else {
 43292  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 43293  			}
 43294  		}
 43295  	}
 43296  }
 43297  
 43298  func (x *NodeEvent) CodecDecodeSelf(d *codec1978.Decoder) {
 43299  	var h codecSelfer100
 43300  	z, r := codec1978.GenHelperDecoder(d)
 43301  	_, _, _ = h, z, r
 43302  	yym1 := z.DecBinary()
 43303  	_ = yym1
 43304  	if false {
 43305  	} else if z.HasExtensions() && z.DecExt(x) {
 43306  	} else {
 43307  		yyct2 := r.ContainerType()
 43308  		if yyct2 == codecSelferValueTypeMap100 {
 43309  			yyl2 := r.ReadMapStart()
 43310  			if yyl2 == 0 {
 43311  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 43312  			} else {
 43313  				x.codecDecodeSelfFromMap(yyl2, d)
 43314  			}
 43315  		} else if yyct2 == codecSelferValueTypeArray100 {
 43316  			yyl2 := r.ReadArrayStart()
 43317  			if yyl2 == 0 {
 43318  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 43319  			} else {
 43320  				x.codecDecodeSelfFromArray(yyl2, d)
 43321  			}
 43322  		} else {
 43323  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 43324  		}
 43325  	}
 43326  }
 43327  
 43328  func (x *NodeEvent) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 43329  	var h codecSelfer100
 43330  	z, r := codec1978.GenHelperDecoder(d)
 43331  	_, _, _ = h, z, r
 43332  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 43333  	_ = yys3Slc
 43334  	var yyhl3 bool = l >= 0
 43335  	for yyj3 := 0; ; yyj3++ {
 43336  		if yyhl3 {
 43337  			if yyj3 >= l {
 43338  				break
 43339  			}
 43340  		} else {
 43341  			if r.CheckBreak() {
 43342  				break
 43343  			}
 43344  		}
 43345  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 43346  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 43347  		yys3 := string(yys3Slc)
 43348  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 43349  		switch yys3 {
 43350  		case "Message":
 43351  			if r.TryDecodeAsNil() {
 43352  				x.Message = ""
 43353  			} else {
 43354  				yyv4 := &x.Message
 43355  				yym5 := z.DecBinary()
 43356  				_ = yym5
 43357  				if false {
 43358  				} else {
 43359  					*((*string)(yyv4)) = r.DecodeString()
 43360  				}
 43361  			}
 43362  		case "Subsystem":
 43363  			if r.TryDecodeAsNil() {
 43364  				x.Subsystem = ""
 43365  			} else {
 43366  				yyv6 := &x.Subsystem
 43367  				yym7 := z.DecBinary()
 43368  				_ = yym7
 43369  				if false {
 43370  				} else {
 43371  					*((*string)(yyv6)) = r.DecodeString()
 43372  				}
 43373  			}
 43374  		case "Details":
 43375  			if r.TryDecodeAsNil() {
 43376  				x.Details = nil
 43377  			} else {
 43378  				yyv8 := &x.Details
 43379  				yym9 := z.DecBinary()
 43380  				_ = yym9
 43381  				if false {
 43382  				} else {
 43383  					z.F.DecMapStringStringX(yyv8, false, d)
 43384  				}
 43385  			}
 43386  		case "Timestamp":
 43387  			if r.TryDecodeAsNil() {
 43388  				x.Timestamp = time.Time{}
 43389  			} else {
 43390  				yyv10 := &x.Timestamp
 43391  				yym11 := z.DecBinary()
 43392  				_ = yym11
 43393  				if false {
 43394  				} else if yym12 := z.TimeRtidIfBinc(); yym12 != 0 {
 43395  					r.DecodeBuiltin(yym12, yyv10)
 43396  				} else if z.HasExtensions() && z.DecExt(yyv10) {
 43397  				} else if yym11 {
 43398  					z.DecBinaryUnmarshal(yyv10)
 43399  				} else if !yym11 && z.IsJSONHandle() {
 43400  					z.DecJSONUnmarshal(yyv10)
 43401  				} else {
 43402  					z.DecFallback(yyv10, false)
 43403  				}
 43404  			}
 43405  		case "CreateIndex":
 43406  			if r.TryDecodeAsNil() {
 43407  				x.CreateIndex = 0
 43408  			} else {
 43409  				yyv13 := &x.CreateIndex
 43410  				yym14 := z.DecBinary()
 43411  				_ = yym14
 43412  				if false {
 43413  				} else {
 43414  					*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 43415  				}
 43416  			}
 43417  		default:
 43418  			z.DecStructFieldNotFound(-1, yys3)
 43419  		} // end switch yys3
 43420  	} // end for yyj3
 43421  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 43422  }
 43423  
 43424  func (x *NodeEvent) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 43425  	var h codecSelfer100
 43426  	z, r := codec1978.GenHelperDecoder(d)
 43427  	_, _, _ = h, z, r
 43428  	var yyj15 int
 43429  	var yyb15 bool
 43430  	var yyhl15 bool = l >= 0
 43431  	yyj15++
 43432  	if yyhl15 {
 43433  		yyb15 = yyj15 > l
 43434  	} else {
 43435  		yyb15 = r.CheckBreak()
 43436  	}
 43437  	if yyb15 {
 43438  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 43439  		return
 43440  	}
 43441  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 43442  	if r.TryDecodeAsNil() {
 43443  		x.Message = ""
 43444  	} else {
 43445  		yyv16 := &x.Message
 43446  		yym17 := z.DecBinary()
 43447  		_ = yym17
 43448  		if false {
 43449  		} else {
 43450  			*((*string)(yyv16)) = r.DecodeString()
 43451  		}
 43452  	}
 43453  	yyj15++
 43454  	if yyhl15 {
 43455  		yyb15 = yyj15 > l
 43456  	} else {
 43457  		yyb15 = r.CheckBreak()
 43458  	}
 43459  	if yyb15 {
 43460  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 43461  		return
 43462  	}
 43463  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 43464  	if r.TryDecodeAsNil() {
 43465  		x.Subsystem = ""
 43466  	} else {
 43467  		yyv18 := &x.Subsystem
 43468  		yym19 := z.DecBinary()
 43469  		_ = yym19
 43470  		if false {
 43471  		} else {
 43472  			*((*string)(yyv18)) = r.DecodeString()
 43473  		}
 43474  	}
 43475  	yyj15++
 43476  	if yyhl15 {
 43477  		yyb15 = yyj15 > l
 43478  	} else {
 43479  		yyb15 = r.CheckBreak()
 43480  	}
 43481  	if yyb15 {
 43482  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 43483  		return
 43484  	}
 43485  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 43486  	if r.TryDecodeAsNil() {
 43487  		x.Details = nil
 43488  	} else {
 43489  		yyv20 := &x.Details
 43490  		yym21 := z.DecBinary()
 43491  		_ = yym21
 43492  		if false {
 43493  		} else {
 43494  			z.F.DecMapStringStringX(yyv20, false, d)
 43495  		}
 43496  	}
 43497  	yyj15++
 43498  	if yyhl15 {
 43499  		yyb15 = yyj15 > l
 43500  	} else {
 43501  		yyb15 = r.CheckBreak()
 43502  	}
 43503  	if yyb15 {
 43504  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 43505  		return
 43506  	}
 43507  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 43508  	if r.TryDecodeAsNil() {
 43509  		x.Timestamp = time.Time{}
 43510  	} else {
 43511  		yyv22 := &x.Timestamp
 43512  		yym23 := z.DecBinary()
 43513  		_ = yym23
 43514  		if false {
 43515  		} else if yym24 := z.TimeRtidIfBinc(); yym24 != 0 {
 43516  			r.DecodeBuiltin(yym24, yyv22)
 43517  		} else if z.HasExtensions() && z.DecExt(yyv22) {
 43518  		} else if yym23 {
 43519  			z.DecBinaryUnmarshal(yyv22)
 43520  		} else if !yym23 && z.IsJSONHandle() {
 43521  			z.DecJSONUnmarshal(yyv22)
 43522  		} else {
 43523  			z.DecFallback(yyv22, false)
 43524  		}
 43525  	}
 43526  	yyj15++
 43527  	if yyhl15 {
 43528  		yyb15 = yyj15 > l
 43529  	} else {
 43530  		yyb15 = r.CheckBreak()
 43531  	}
 43532  	if yyb15 {
 43533  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 43534  		return
 43535  	}
 43536  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 43537  	if r.TryDecodeAsNil() {
 43538  		x.CreateIndex = 0
 43539  	} else {
 43540  		yyv25 := &x.CreateIndex
 43541  		yym26 := z.DecBinary()
 43542  		_ = yym26
 43543  		if false {
 43544  		} else {
 43545  			*((*uint64)(yyv25)) = uint64(r.DecodeUint(64))
 43546  		}
 43547  	}
 43548  	for {
 43549  		yyj15++
 43550  		if yyhl15 {
 43551  			yyb15 = yyj15 > l
 43552  		} else {
 43553  			yyb15 = r.CheckBreak()
 43554  		}
 43555  		if yyb15 {
 43556  			break
 43557  		}
 43558  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 43559  		z.DecStructFieldNotFound(yyj15-1, "")
 43560  	}
 43561  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 43562  }
 43563  
 43564  func (x *DrainSpec) CodecEncodeSelf(e *codec1978.Encoder) {
 43565  	var h codecSelfer100
 43566  	z, r := codec1978.GenHelperEncoder(e)
 43567  	_, _, _ = h, z, r
 43568  	if x == nil {
 43569  		r.EncodeNil()
 43570  	} else {
 43571  		yym1 := z.EncBinary()
 43572  		_ = yym1
 43573  		if false {
 43574  		} else if z.HasExtensions() && z.EncExt(x) {
 43575  		} else {
 43576  			yysep2 := !z.EncBinary()
 43577  			yy2arr2 := z.EncBasicHandle().StructToArray
 43578  			var yyq2 [2]bool
 43579  			_, _, _ = yysep2, yyq2, yy2arr2
 43580  			const yyr2 bool = false
 43581  			var yynn2 int
 43582  			if yyr2 || yy2arr2 {
 43583  				r.EncodeArrayStart(2)
 43584  			} else {
 43585  				yynn2 = 2
 43586  				for _, b := range yyq2 {
 43587  					if b {
 43588  						yynn2++
 43589  					}
 43590  				}
 43591  				r.EncodeMapStart(yynn2)
 43592  				yynn2 = 0
 43593  			}
 43594  			if yyr2 || yy2arr2 {
 43595  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 43596  				yym4 := z.EncBinary()
 43597  				_ = yym4
 43598  				if false {
 43599  				} else if z.HasExtensions() && z.EncExt(x.Deadline) {
 43600  				} else {
 43601  					r.EncodeInt(int64(x.Deadline))
 43602  				}
 43603  			} else {
 43604  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 43605  				r.EncodeString(codecSelferC_UTF8100, string("Deadline"))
 43606  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 43607  				yym5 := z.EncBinary()
 43608  				_ = yym5
 43609  				if false {
 43610  				} else if z.HasExtensions() && z.EncExt(x.Deadline) {
 43611  				} else {
 43612  					r.EncodeInt(int64(x.Deadline))
 43613  				}
 43614  			}
 43615  			if yyr2 || yy2arr2 {
 43616  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 43617  				yym7 := z.EncBinary()
 43618  				_ = yym7
 43619  				if false {
 43620  				} else {
 43621  					r.EncodeBool(bool(x.IgnoreSystemJobs))
 43622  				}
 43623  			} else {
 43624  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 43625  				r.EncodeString(codecSelferC_UTF8100, string("IgnoreSystemJobs"))
 43626  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 43627  				yym8 := z.EncBinary()
 43628  				_ = yym8
 43629  				if false {
 43630  				} else {
 43631  					r.EncodeBool(bool(x.IgnoreSystemJobs))
 43632  				}
 43633  			}
 43634  			if yyr2 || yy2arr2 {
 43635  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 43636  			} else {
 43637  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 43638  			}
 43639  		}
 43640  	}
 43641  }
 43642  
 43643  func (x *DrainSpec) CodecDecodeSelf(d *codec1978.Decoder) {
 43644  	var h codecSelfer100
 43645  	z, r := codec1978.GenHelperDecoder(d)
 43646  	_, _, _ = h, z, r
 43647  	yym1 := z.DecBinary()
 43648  	_ = yym1
 43649  	if false {
 43650  	} else if z.HasExtensions() && z.DecExt(x) {
 43651  	} else {
 43652  		yyct2 := r.ContainerType()
 43653  		if yyct2 == codecSelferValueTypeMap100 {
 43654  			yyl2 := r.ReadMapStart()
 43655  			if yyl2 == 0 {
 43656  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 43657  			} else {
 43658  				x.codecDecodeSelfFromMap(yyl2, d)
 43659  			}
 43660  		} else if yyct2 == codecSelferValueTypeArray100 {
 43661  			yyl2 := r.ReadArrayStart()
 43662  			if yyl2 == 0 {
 43663  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 43664  			} else {
 43665  				x.codecDecodeSelfFromArray(yyl2, d)
 43666  			}
 43667  		} else {
 43668  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 43669  		}
 43670  	}
 43671  }
 43672  
 43673  func (x *DrainSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 43674  	var h codecSelfer100
 43675  	z, r := codec1978.GenHelperDecoder(d)
 43676  	_, _, _ = h, z, r
 43677  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 43678  	_ = yys3Slc
 43679  	var yyhl3 bool = l >= 0
 43680  	for yyj3 := 0; ; yyj3++ {
 43681  		if yyhl3 {
 43682  			if yyj3 >= l {
 43683  				break
 43684  			}
 43685  		} else {
 43686  			if r.CheckBreak() {
 43687  				break
 43688  			}
 43689  		}
 43690  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 43691  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 43692  		yys3 := string(yys3Slc)
 43693  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 43694  		switch yys3 {
 43695  		case "Deadline":
 43696  			if r.TryDecodeAsNil() {
 43697  				x.Deadline = 0
 43698  			} else {
 43699  				yyv4 := &x.Deadline
 43700  				yym5 := z.DecBinary()
 43701  				_ = yym5
 43702  				if false {
 43703  				} else if z.HasExtensions() && z.DecExt(yyv4) {
 43704  				} else {
 43705  					*((*int64)(yyv4)) = int64(r.DecodeInt(64))
 43706  				}
 43707  			}
 43708  		case "IgnoreSystemJobs":
 43709  			if r.TryDecodeAsNil() {
 43710  				x.IgnoreSystemJobs = false
 43711  			} else {
 43712  				yyv6 := &x.IgnoreSystemJobs
 43713  				yym7 := z.DecBinary()
 43714  				_ = yym7
 43715  				if false {
 43716  				} else {
 43717  					*((*bool)(yyv6)) = r.DecodeBool()
 43718  				}
 43719  			}
 43720  		default:
 43721  			z.DecStructFieldNotFound(-1, yys3)
 43722  		} // end switch yys3
 43723  	} // end for yyj3
 43724  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 43725  }
 43726  
 43727  func (x *DrainSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 43728  	var h codecSelfer100
 43729  	z, r := codec1978.GenHelperDecoder(d)
 43730  	_, _, _ = h, z, r
 43731  	var yyj8 int
 43732  	var yyb8 bool
 43733  	var yyhl8 bool = l >= 0
 43734  	yyj8++
 43735  	if yyhl8 {
 43736  		yyb8 = yyj8 > l
 43737  	} else {
 43738  		yyb8 = r.CheckBreak()
 43739  	}
 43740  	if yyb8 {
 43741  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 43742  		return
 43743  	}
 43744  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 43745  	if r.TryDecodeAsNil() {
 43746  		x.Deadline = 0
 43747  	} else {
 43748  		yyv9 := &x.Deadline
 43749  		yym10 := z.DecBinary()
 43750  		_ = yym10
 43751  		if false {
 43752  		} else if z.HasExtensions() && z.DecExt(yyv9) {
 43753  		} else {
 43754  			*((*int64)(yyv9)) = int64(r.DecodeInt(64))
 43755  		}
 43756  	}
 43757  	yyj8++
 43758  	if yyhl8 {
 43759  		yyb8 = yyj8 > l
 43760  	} else {
 43761  		yyb8 = r.CheckBreak()
 43762  	}
 43763  	if yyb8 {
 43764  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 43765  		return
 43766  	}
 43767  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 43768  	if r.TryDecodeAsNil() {
 43769  		x.IgnoreSystemJobs = false
 43770  	} else {
 43771  		yyv11 := &x.IgnoreSystemJobs
 43772  		yym12 := z.DecBinary()
 43773  		_ = yym12
 43774  		if false {
 43775  		} else {
 43776  			*((*bool)(yyv11)) = r.DecodeBool()
 43777  		}
 43778  	}
 43779  	for {
 43780  		yyj8++
 43781  		if yyhl8 {
 43782  			yyb8 = yyj8 > l
 43783  		} else {
 43784  			yyb8 = r.CheckBreak()
 43785  		}
 43786  		if yyb8 {
 43787  			break
 43788  		}
 43789  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 43790  		z.DecStructFieldNotFound(yyj8-1, "")
 43791  	}
 43792  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 43793  }
 43794  
 43795  func (x *DrainStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
 43796  	var h codecSelfer100
 43797  	z, r := codec1978.GenHelperEncoder(e)
 43798  	_, _, _ = h, z, r
 43799  	if x == nil {
 43800  		r.EncodeNil()
 43801  	} else {
 43802  		yym1 := z.EncBinary()
 43803  		_ = yym1
 43804  		if false {
 43805  		} else if z.HasExtensions() && z.EncExt(x) {
 43806  		} else {
 43807  			yysep2 := !z.EncBinary()
 43808  			yy2arr2 := z.EncBasicHandle().StructToArray
 43809  			var yyq2 [3]bool
 43810  			_, _, _ = yysep2, yyq2, yy2arr2
 43811  			const yyr2 bool = false
 43812  			var yynn2 int
 43813  			if yyr2 || yy2arr2 {
 43814  				r.EncodeArrayStart(3)
 43815  			} else {
 43816  				yynn2 = 3
 43817  				for _, b := range yyq2 {
 43818  					if b {
 43819  						yynn2++
 43820  					}
 43821  				}
 43822  				r.EncodeMapStart(yynn2)
 43823  				yynn2 = 0
 43824  			}
 43825  			if yyr2 || yy2arr2 {
 43826  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 43827  				yym4 := z.EncBinary()
 43828  				_ = yym4
 43829  				if false {
 43830  				} else if z.HasExtensions() && z.EncExt(x.Deadline) {
 43831  				} else {
 43832  					r.EncodeInt(int64(x.Deadline))
 43833  				}
 43834  			} else {
 43835  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 43836  				r.EncodeString(codecSelferC_UTF8100, string("Deadline"))
 43837  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 43838  				yym5 := z.EncBinary()
 43839  				_ = yym5
 43840  				if false {
 43841  				} else if z.HasExtensions() && z.EncExt(x.Deadline) {
 43842  				} else {
 43843  					r.EncodeInt(int64(x.Deadline))
 43844  				}
 43845  			}
 43846  			if yyr2 || yy2arr2 {
 43847  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 43848  				yym7 := z.EncBinary()
 43849  				_ = yym7
 43850  				if false {
 43851  				} else {
 43852  					r.EncodeBool(bool(x.IgnoreSystemJobs))
 43853  				}
 43854  			} else {
 43855  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 43856  				r.EncodeString(codecSelferC_UTF8100, string("IgnoreSystemJobs"))
 43857  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 43858  				yym8 := z.EncBinary()
 43859  				_ = yym8
 43860  				if false {
 43861  				} else {
 43862  					r.EncodeBool(bool(x.IgnoreSystemJobs))
 43863  				}
 43864  			}
 43865  			if yyr2 || yy2arr2 {
 43866  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 43867  				yy10 := &x.ForceDeadline
 43868  				yym11 := z.EncBinary()
 43869  				_ = yym11
 43870  				if false {
 43871  				} else if yym12 := z.TimeRtidIfBinc(); yym12 != 0 {
 43872  					r.EncodeBuiltin(yym12, yy10)
 43873  				} else if z.HasExtensions() && z.EncExt(yy10) {
 43874  				} else if yym11 {
 43875  					z.EncBinaryMarshal(yy10)
 43876  				} else if !yym11 && z.IsJSONHandle() {
 43877  					z.EncJSONMarshal(yy10)
 43878  				} else {
 43879  					z.EncFallback(yy10)
 43880  				}
 43881  			} else {
 43882  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 43883  				r.EncodeString(codecSelferC_UTF8100, string("ForceDeadline"))
 43884  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 43885  				yy13 := &x.ForceDeadline
 43886  				yym14 := z.EncBinary()
 43887  				_ = yym14
 43888  				if false {
 43889  				} else if yym15 := z.TimeRtidIfBinc(); yym15 != 0 {
 43890  					r.EncodeBuiltin(yym15, yy13)
 43891  				} else if z.HasExtensions() && z.EncExt(yy13) {
 43892  				} else if yym14 {
 43893  					z.EncBinaryMarshal(yy13)
 43894  				} else if !yym14 && z.IsJSONHandle() {
 43895  					z.EncJSONMarshal(yy13)
 43896  				} else {
 43897  					z.EncFallback(yy13)
 43898  				}
 43899  			}
 43900  			if yyr2 || yy2arr2 {
 43901  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 43902  			} else {
 43903  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 43904  			}
 43905  		}
 43906  	}
 43907  }
 43908  
 43909  func (x *DrainStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
 43910  	var h codecSelfer100
 43911  	z, r := codec1978.GenHelperDecoder(d)
 43912  	_, _, _ = h, z, r
 43913  	yym1 := z.DecBinary()
 43914  	_ = yym1
 43915  	if false {
 43916  	} else if z.HasExtensions() && z.DecExt(x) {
 43917  	} else {
 43918  		yyct2 := r.ContainerType()
 43919  		if yyct2 == codecSelferValueTypeMap100 {
 43920  			yyl2 := r.ReadMapStart()
 43921  			if yyl2 == 0 {
 43922  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 43923  			} else {
 43924  				x.codecDecodeSelfFromMap(yyl2, d)
 43925  			}
 43926  		} else if yyct2 == codecSelferValueTypeArray100 {
 43927  			yyl2 := r.ReadArrayStart()
 43928  			if yyl2 == 0 {
 43929  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 43930  			} else {
 43931  				x.codecDecodeSelfFromArray(yyl2, d)
 43932  			}
 43933  		} else {
 43934  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 43935  		}
 43936  	}
 43937  }
 43938  
 43939  func (x *DrainStrategy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 43940  	var h codecSelfer100
 43941  	z, r := codec1978.GenHelperDecoder(d)
 43942  	_, _, _ = h, z, r
 43943  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 43944  	_ = yys3Slc
 43945  	var yyhl3 bool = l >= 0
 43946  	for yyj3 := 0; ; yyj3++ {
 43947  		if yyhl3 {
 43948  			if yyj3 >= l {
 43949  				break
 43950  			}
 43951  		} else {
 43952  			if r.CheckBreak() {
 43953  				break
 43954  			}
 43955  		}
 43956  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 43957  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 43958  		yys3 := string(yys3Slc)
 43959  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 43960  		switch yys3 {
 43961  		case "Deadline":
 43962  			if r.TryDecodeAsNil() {
 43963  				x.Deadline = 0
 43964  			} else {
 43965  				yyv4 := &x.Deadline
 43966  				yym5 := z.DecBinary()
 43967  				_ = yym5
 43968  				if false {
 43969  				} else if z.HasExtensions() && z.DecExt(yyv4) {
 43970  				} else {
 43971  					*((*int64)(yyv4)) = int64(r.DecodeInt(64))
 43972  				}
 43973  			}
 43974  		case "IgnoreSystemJobs":
 43975  			if r.TryDecodeAsNil() {
 43976  				x.IgnoreSystemJobs = false
 43977  			} else {
 43978  				yyv6 := &x.IgnoreSystemJobs
 43979  				yym7 := z.DecBinary()
 43980  				_ = yym7
 43981  				if false {
 43982  				} else {
 43983  					*((*bool)(yyv6)) = r.DecodeBool()
 43984  				}
 43985  			}
 43986  		case "ForceDeadline":
 43987  			if r.TryDecodeAsNil() {
 43988  				x.ForceDeadline = time.Time{}
 43989  			} else {
 43990  				yyv8 := &x.ForceDeadline
 43991  				yym9 := z.DecBinary()
 43992  				_ = yym9
 43993  				if false {
 43994  				} else if yym10 := z.TimeRtidIfBinc(); yym10 != 0 {
 43995  					r.DecodeBuiltin(yym10, yyv8)
 43996  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 43997  				} else if yym9 {
 43998  					z.DecBinaryUnmarshal(yyv8)
 43999  				} else if !yym9 && z.IsJSONHandle() {
 44000  					z.DecJSONUnmarshal(yyv8)
 44001  				} else {
 44002  					z.DecFallback(yyv8, false)
 44003  				}
 44004  			}
 44005  		default:
 44006  			z.DecStructFieldNotFound(-1, yys3)
 44007  		} // end switch yys3
 44008  	} // end for yyj3
 44009  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 44010  }
 44011  
 44012  func (x *DrainStrategy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 44013  	var h codecSelfer100
 44014  	z, r := codec1978.GenHelperDecoder(d)
 44015  	_, _, _ = h, z, r
 44016  	var yyj11 int
 44017  	var yyb11 bool
 44018  	var yyhl11 bool = l >= 0
 44019  	yyj11++
 44020  	if yyhl11 {
 44021  		yyb11 = yyj11 > l
 44022  	} else {
 44023  		yyb11 = r.CheckBreak()
 44024  	}
 44025  	if yyb11 {
 44026  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 44027  		return
 44028  	}
 44029  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 44030  	if r.TryDecodeAsNil() {
 44031  		x.Deadline = 0
 44032  	} else {
 44033  		yyv12 := &x.Deadline
 44034  		yym13 := z.DecBinary()
 44035  		_ = yym13
 44036  		if false {
 44037  		} else if z.HasExtensions() && z.DecExt(yyv12) {
 44038  		} else {
 44039  			*((*int64)(yyv12)) = int64(r.DecodeInt(64))
 44040  		}
 44041  	}
 44042  	yyj11++
 44043  	if yyhl11 {
 44044  		yyb11 = yyj11 > l
 44045  	} else {
 44046  		yyb11 = r.CheckBreak()
 44047  	}
 44048  	if yyb11 {
 44049  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 44050  		return
 44051  	}
 44052  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 44053  	if r.TryDecodeAsNil() {
 44054  		x.IgnoreSystemJobs = false
 44055  	} else {
 44056  		yyv14 := &x.IgnoreSystemJobs
 44057  		yym15 := z.DecBinary()
 44058  		_ = yym15
 44059  		if false {
 44060  		} else {
 44061  			*((*bool)(yyv14)) = r.DecodeBool()
 44062  		}
 44063  	}
 44064  	yyj11++
 44065  	if yyhl11 {
 44066  		yyb11 = yyj11 > l
 44067  	} else {
 44068  		yyb11 = r.CheckBreak()
 44069  	}
 44070  	if yyb11 {
 44071  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 44072  		return
 44073  	}
 44074  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 44075  	if r.TryDecodeAsNil() {
 44076  		x.ForceDeadline = time.Time{}
 44077  	} else {
 44078  		yyv16 := &x.ForceDeadline
 44079  		yym17 := z.DecBinary()
 44080  		_ = yym17
 44081  		if false {
 44082  		} else if yym18 := z.TimeRtidIfBinc(); yym18 != 0 {
 44083  			r.DecodeBuiltin(yym18, yyv16)
 44084  		} else if z.HasExtensions() && z.DecExt(yyv16) {
 44085  		} else if yym17 {
 44086  			z.DecBinaryUnmarshal(yyv16)
 44087  		} else if !yym17 && z.IsJSONHandle() {
 44088  			z.DecJSONUnmarshal(yyv16)
 44089  		} else {
 44090  			z.DecFallback(yyv16, false)
 44091  		}
 44092  	}
 44093  	for {
 44094  		yyj11++
 44095  		if yyhl11 {
 44096  			yyb11 = yyj11 > l
 44097  		} else {
 44098  			yyb11 = r.CheckBreak()
 44099  		}
 44100  		if yyb11 {
 44101  			break
 44102  		}
 44103  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 44104  		z.DecStructFieldNotFound(yyj11-1, "")
 44105  	}
 44106  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 44107  }
 44108  
 44109  func (x *Node) CodecEncodeSelf(e *codec1978.Encoder) {
 44110  	var h codecSelfer100
 44111  	z, r := codec1978.GenHelperEncoder(e)
 44112  	_, _, _ = h, z, r
 44113  	if x == nil {
 44114  		r.EncodeNil()
 44115  	} else {
 44116  		yym1 := z.EncBinary()
 44117  		_ = yym1
 44118  		if false {
 44119  		} else if z.HasExtensions() && z.EncExt(x) {
 44120  		} else {
 44121  			yysep2 := !z.EncBinary()
 44122  			yy2arr2 := z.EncBasicHandle().StructToArray
 44123  			var yyq2 [23]bool
 44124  			_, _, _ = yysep2, yyq2, yy2arr2
 44125  			const yyr2 bool = false
 44126  			var yynn2 int
 44127  			if yyr2 || yy2arr2 {
 44128  				r.EncodeArrayStart(23)
 44129  			} else {
 44130  				yynn2 = 23
 44131  				for _, b := range yyq2 {
 44132  					if b {
 44133  						yynn2++
 44134  					}
 44135  				}
 44136  				r.EncodeMapStart(yynn2)
 44137  				yynn2 = 0
 44138  			}
 44139  			if yyr2 || yy2arr2 {
 44140  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44141  				yym4 := z.EncBinary()
 44142  				_ = yym4
 44143  				if false {
 44144  				} else {
 44145  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 44146  				}
 44147  			} else {
 44148  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44149  				r.EncodeString(codecSelferC_UTF8100, string("ID"))
 44150  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44151  				yym5 := z.EncBinary()
 44152  				_ = yym5
 44153  				if false {
 44154  				} else {
 44155  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 44156  				}
 44157  			}
 44158  			if yyr2 || yy2arr2 {
 44159  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44160  				yym7 := z.EncBinary()
 44161  				_ = yym7
 44162  				if false {
 44163  				} else {
 44164  					r.EncodeString(codecSelferC_UTF8100, string(x.SecretID))
 44165  				}
 44166  			} else {
 44167  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44168  				r.EncodeString(codecSelferC_UTF8100, string("SecretID"))
 44169  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44170  				yym8 := z.EncBinary()
 44171  				_ = yym8
 44172  				if false {
 44173  				} else {
 44174  					r.EncodeString(codecSelferC_UTF8100, string(x.SecretID))
 44175  				}
 44176  			}
 44177  			if yyr2 || yy2arr2 {
 44178  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44179  				yym10 := z.EncBinary()
 44180  				_ = yym10
 44181  				if false {
 44182  				} else {
 44183  					r.EncodeString(codecSelferC_UTF8100, string(x.Datacenter))
 44184  				}
 44185  			} else {
 44186  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44187  				r.EncodeString(codecSelferC_UTF8100, string("Datacenter"))
 44188  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44189  				yym11 := z.EncBinary()
 44190  				_ = yym11
 44191  				if false {
 44192  				} else {
 44193  					r.EncodeString(codecSelferC_UTF8100, string(x.Datacenter))
 44194  				}
 44195  			}
 44196  			if yyr2 || yy2arr2 {
 44197  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44198  				yym13 := z.EncBinary()
 44199  				_ = yym13
 44200  				if false {
 44201  				} else {
 44202  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 44203  				}
 44204  			} else {
 44205  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44206  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 44207  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44208  				yym14 := z.EncBinary()
 44209  				_ = yym14
 44210  				if false {
 44211  				} else {
 44212  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 44213  				}
 44214  			}
 44215  			if yyr2 || yy2arr2 {
 44216  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44217  				yym16 := z.EncBinary()
 44218  				_ = yym16
 44219  				if false {
 44220  				} else {
 44221  					r.EncodeString(codecSelferC_UTF8100, string(x.HTTPAddr))
 44222  				}
 44223  			} else {
 44224  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44225  				r.EncodeString(codecSelferC_UTF8100, string("HTTPAddr"))
 44226  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44227  				yym17 := z.EncBinary()
 44228  				_ = yym17
 44229  				if false {
 44230  				} else {
 44231  					r.EncodeString(codecSelferC_UTF8100, string(x.HTTPAddr))
 44232  				}
 44233  			}
 44234  			if yyr2 || yy2arr2 {
 44235  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44236  				yym19 := z.EncBinary()
 44237  				_ = yym19
 44238  				if false {
 44239  				} else {
 44240  					r.EncodeBool(bool(x.TLSEnabled))
 44241  				}
 44242  			} else {
 44243  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44244  				r.EncodeString(codecSelferC_UTF8100, string("TLSEnabled"))
 44245  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44246  				yym20 := z.EncBinary()
 44247  				_ = yym20
 44248  				if false {
 44249  				} else {
 44250  					r.EncodeBool(bool(x.TLSEnabled))
 44251  				}
 44252  			}
 44253  			if yyr2 || yy2arr2 {
 44254  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44255  				if x.Attributes == nil {
 44256  					r.EncodeNil()
 44257  				} else {
 44258  					yym22 := z.EncBinary()
 44259  					_ = yym22
 44260  					if false {
 44261  					} else {
 44262  						z.F.EncMapStringStringV(x.Attributes, false, e)
 44263  					}
 44264  				}
 44265  			} else {
 44266  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44267  				r.EncodeString(codecSelferC_UTF8100, string("Attributes"))
 44268  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44269  				if x.Attributes == nil {
 44270  					r.EncodeNil()
 44271  				} else {
 44272  					yym23 := z.EncBinary()
 44273  					_ = yym23
 44274  					if false {
 44275  					} else {
 44276  						z.F.EncMapStringStringV(x.Attributes, false, e)
 44277  					}
 44278  				}
 44279  			}
 44280  			if yyr2 || yy2arr2 {
 44281  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44282  				if x.Resources == nil {
 44283  					r.EncodeNil()
 44284  				} else {
 44285  					x.Resources.CodecEncodeSelf(e)
 44286  				}
 44287  			} else {
 44288  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44289  				r.EncodeString(codecSelferC_UTF8100, string("Resources"))
 44290  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44291  				if x.Resources == nil {
 44292  					r.EncodeNil()
 44293  				} else {
 44294  					x.Resources.CodecEncodeSelf(e)
 44295  				}
 44296  			}
 44297  			if yyr2 || yy2arr2 {
 44298  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44299  				if x.Reserved == nil {
 44300  					r.EncodeNil()
 44301  				} else {
 44302  					x.Reserved.CodecEncodeSelf(e)
 44303  				}
 44304  			} else {
 44305  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44306  				r.EncodeString(codecSelferC_UTF8100, string("Reserved"))
 44307  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44308  				if x.Reserved == nil {
 44309  					r.EncodeNil()
 44310  				} else {
 44311  					x.Reserved.CodecEncodeSelf(e)
 44312  				}
 44313  			}
 44314  			if yyr2 || yy2arr2 {
 44315  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44316  				if x.Links == nil {
 44317  					r.EncodeNil()
 44318  				} else {
 44319  					yym31 := z.EncBinary()
 44320  					_ = yym31
 44321  					if false {
 44322  					} else {
 44323  						z.F.EncMapStringStringV(x.Links, false, e)
 44324  					}
 44325  				}
 44326  			} else {
 44327  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44328  				r.EncodeString(codecSelferC_UTF8100, string("Links"))
 44329  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44330  				if x.Links == nil {
 44331  					r.EncodeNil()
 44332  				} else {
 44333  					yym32 := z.EncBinary()
 44334  					_ = yym32
 44335  					if false {
 44336  					} else {
 44337  						z.F.EncMapStringStringV(x.Links, false, e)
 44338  					}
 44339  				}
 44340  			}
 44341  			if yyr2 || yy2arr2 {
 44342  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44343  				if x.Meta == nil {
 44344  					r.EncodeNil()
 44345  				} else {
 44346  					yym34 := z.EncBinary()
 44347  					_ = yym34
 44348  					if false {
 44349  					} else {
 44350  						z.F.EncMapStringStringV(x.Meta, false, e)
 44351  					}
 44352  				}
 44353  			} else {
 44354  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44355  				r.EncodeString(codecSelferC_UTF8100, string("Meta"))
 44356  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44357  				if x.Meta == nil {
 44358  					r.EncodeNil()
 44359  				} else {
 44360  					yym35 := z.EncBinary()
 44361  					_ = yym35
 44362  					if false {
 44363  					} else {
 44364  						z.F.EncMapStringStringV(x.Meta, false, e)
 44365  					}
 44366  				}
 44367  			}
 44368  			if yyr2 || yy2arr2 {
 44369  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44370  				yym37 := z.EncBinary()
 44371  				_ = yym37
 44372  				if false {
 44373  				} else {
 44374  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeClass))
 44375  				}
 44376  			} else {
 44377  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44378  				r.EncodeString(codecSelferC_UTF8100, string("NodeClass"))
 44379  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44380  				yym38 := z.EncBinary()
 44381  				_ = yym38
 44382  				if false {
 44383  				} else {
 44384  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeClass))
 44385  				}
 44386  			}
 44387  			if yyr2 || yy2arr2 {
 44388  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44389  				yym40 := z.EncBinary()
 44390  				_ = yym40
 44391  				if false {
 44392  				} else {
 44393  					r.EncodeString(codecSelferC_UTF8100, string(x.ComputedClass))
 44394  				}
 44395  			} else {
 44396  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44397  				r.EncodeString(codecSelferC_UTF8100, string("ComputedClass"))
 44398  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44399  				yym41 := z.EncBinary()
 44400  				_ = yym41
 44401  				if false {
 44402  				} else {
 44403  					r.EncodeString(codecSelferC_UTF8100, string(x.ComputedClass))
 44404  				}
 44405  			}
 44406  			if yyr2 || yy2arr2 {
 44407  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44408  				yym43 := z.EncBinary()
 44409  				_ = yym43
 44410  				if false {
 44411  				} else {
 44412  					r.EncodeBool(bool(x.Drain))
 44413  				}
 44414  			} else {
 44415  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44416  				r.EncodeString(codecSelferC_UTF8100, string("Drain"))
 44417  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44418  				yym44 := z.EncBinary()
 44419  				_ = yym44
 44420  				if false {
 44421  				} else {
 44422  					r.EncodeBool(bool(x.Drain))
 44423  				}
 44424  			}
 44425  			if yyr2 || yy2arr2 {
 44426  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44427  				if x.DrainStrategy == nil {
 44428  					r.EncodeNil()
 44429  				} else {
 44430  					x.DrainStrategy.CodecEncodeSelf(e)
 44431  				}
 44432  			} else {
 44433  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44434  				r.EncodeString(codecSelferC_UTF8100, string("DrainStrategy"))
 44435  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44436  				if x.DrainStrategy == nil {
 44437  					r.EncodeNil()
 44438  				} else {
 44439  					x.DrainStrategy.CodecEncodeSelf(e)
 44440  				}
 44441  			}
 44442  			if yyr2 || yy2arr2 {
 44443  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44444  				yym49 := z.EncBinary()
 44445  				_ = yym49
 44446  				if false {
 44447  				} else {
 44448  					r.EncodeString(codecSelferC_UTF8100, string(x.SchedulingEligibility))
 44449  				}
 44450  			} else {
 44451  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44452  				r.EncodeString(codecSelferC_UTF8100, string("SchedulingEligibility"))
 44453  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44454  				yym50 := z.EncBinary()
 44455  				_ = yym50
 44456  				if false {
 44457  				} else {
 44458  					r.EncodeString(codecSelferC_UTF8100, string(x.SchedulingEligibility))
 44459  				}
 44460  			}
 44461  			if yyr2 || yy2arr2 {
 44462  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44463  				yym52 := z.EncBinary()
 44464  				_ = yym52
 44465  				if false {
 44466  				} else {
 44467  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 44468  				}
 44469  			} else {
 44470  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44471  				r.EncodeString(codecSelferC_UTF8100, string("Status"))
 44472  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44473  				yym53 := z.EncBinary()
 44474  				_ = yym53
 44475  				if false {
 44476  				} else {
 44477  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 44478  				}
 44479  			}
 44480  			if yyr2 || yy2arr2 {
 44481  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44482  				yym55 := z.EncBinary()
 44483  				_ = yym55
 44484  				if false {
 44485  				} else {
 44486  					r.EncodeString(codecSelferC_UTF8100, string(x.StatusDescription))
 44487  				}
 44488  			} else {
 44489  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44490  				r.EncodeString(codecSelferC_UTF8100, string("StatusDescription"))
 44491  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44492  				yym56 := z.EncBinary()
 44493  				_ = yym56
 44494  				if false {
 44495  				} else {
 44496  					r.EncodeString(codecSelferC_UTF8100, string(x.StatusDescription))
 44497  				}
 44498  			}
 44499  			if yyr2 || yy2arr2 {
 44500  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44501  				yym58 := z.EncBinary()
 44502  				_ = yym58
 44503  				if false {
 44504  				} else {
 44505  					r.EncodeInt(int64(x.StatusUpdatedAt))
 44506  				}
 44507  			} else {
 44508  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44509  				r.EncodeString(codecSelferC_UTF8100, string("StatusUpdatedAt"))
 44510  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44511  				yym59 := z.EncBinary()
 44512  				_ = yym59
 44513  				if false {
 44514  				} else {
 44515  					r.EncodeInt(int64(x.StatusUpdatedAt))
 44516  				}
 44517  			}
 44518  			if yyr2 || yy2arr2 {
 44519  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44520  				if x.Events == nil {
 44521  					r.EncodeNil()
 44522  				} else {
 44523  					yym61 := z.EncBinary()
 44524  					_ = yym61
 44525  					if false {
 44526  					} else {
 44527  						h.encSlicePtrtoNodeEvent(([]*NodeEvent)(x.Events), e)
 44528  					}
 44529  				}
 44530  			} else {
 44531  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44532  				r.EncodeString(codecSelferC_UTF8100, string("Events"))
 44533  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44534  				if x.Events == nil {
 44535  					r.EncodeNil()
 44536  				} else {
 44537  					yym62 := z.EncBinary()
 44538  					_ = yym62
 44539  					if false {
 44540  					} else {
 44541  						h.encSlicePtrtoNodeEvent(([]*NodeEvent)(x.Events), e)
 44542  					}
 44543  				}
 44544  			}
 44545  			if yyr2 || yy2arr2 {
 44546  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44547  				if x.Drivers == nil {
 44548  					r.EncodeNil()
 44549  				} else {
 44550  					yym64 := z.EncBinary()
 44551  					_ = yym64
 44552  					if false {
 44553  					} else {
 44554  						h.encMapstringPtrtoDriverInfo((map[string]*DriverInfo)(x.Drivers), e)
 44555  					}
 44556  				}
 44557  			} else {
 44558  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44559  				r.EncodeString(codecSelferC_UTF8100, string("Drivers"))
 44560  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44561  				if x.Drivers == nil {
 44562  					r.EncodeNil()
 44563  				} else {
 44564  					yym65 := z.EncBinary()
 44565  					_ = yym65
 44566  					if false {
 44567  					} else {
 44568  						h.encMapstringPtrtoDriverInfo((map[string]*DriverInfo)(x.Drivers), e)
 44569  					}
 44570  				}
 44571  			}
 44572  			if yyr2 || yy2arr2 {
 44573  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44574  				yym67 := z.EncBinary()
 44575  				_ = yym67
 44576  				if false {
 44577  				} else {
 44578  					r.EncodeUint(uint64(x.CreateIndex))
 44579  				}
 44580  			} else {
 44581  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44582  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 44583  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44584  				yym68 := z.EncBinary()
 44585  				_ = yym68
 44586  				if false {
 44587  				} else {
 44588  					r.EncodeUint(uint64(x.CreateIndex))
 44589  				}
 44590  			}
 44591  			if yyr2 || yy2arr2 {
 44592  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 44593  				yym70 := z.EncBinary()
 44594  				_ = yym70
 44595  				if false {
 44596  				} else {
 44597  					r.EncodeUint(uint64(x.ModifyIndex))
 44598  				}
 44599  			} else {
 44600  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 44601  				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
 44602  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 44603  				yym71 := z.EncBinary()
 44604  				_ = yym71
 44605  				if false {
 44606  				} else {
 44607  					r.EncodeUint(uint64(x.ModifyIndex))
 44608  				}
 44609  			}
 44610  			if yyr2 || yy2arr2 {
 44611  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 44612  			} else {
 44613  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 44614  			}
 44615  		}
 44616  	}
 44617  }
 44618  
 44619  func (x *Node) CodecDecodeSelf(d *codec1978.Decoder) {
 44620  	var h codecSelfer100
 44621  	z, r := codec1978.GenHelperDecoder(d)
 44622  	_, _, _ = h, z, r
 44623  	yym1 := z.DecBinary()
 44624  	_ = yym1
 44625  	if false {
 44626  	} else if z.HasExtensions() && z.DecExt(x) {
 44627  	} else {
 44628  		yyct2 := r.ContainerType()
 44629  		if yyct2 == codecSelferValueTypeMap100 {
 44630  			yyl2 := r.ReadMapStart()
 44631  			if yyl2 == 0 {
 44632  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 44633  			} else {
 44634  				x.codecDecodeSelfFromMap(yyl2, d)
 44635  			}
 44636  		} else if yyct2 == codecSelferValueTypeArray100 {
 44637  			yyl2 := r.ReadArrayStart()
 44638  			if yyl2 == 0 {
 44639  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 44640  			} else {
 44641  				x.codecDecodeSelfFromArray(yyl2, d)
 44642  			}
 44643  		} else {
 44644  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 44645  		}
 44646  	}
 44647  }
 44648  
 44649  func (x *Node) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 44650  	var h codecSelfer100
 44651  	z, r := codec1978.GenHelperDecoder(d)
 44652  	_, _, _ = h, z, r
 44653  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 44654  	_ = yys3Slc
 44655  	var yyhl3 bool = l >= 0
 44656  	for yyj3 := 0; ; yyj3++ {
 44657  		if yyhl3 {
 44658  			if yyj3 >= l {
 44659  				break
 44660  			}
 44661  		} else {
 44662  			if r.CheckBreak() {
 44663  				break
 44664  			}
 44665  		}
 44666  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 44667  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 44668  		yys3 := string(yys3Slc)
 44669  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 44670  		switch yys3 {
 44671  		case "ID":
 44672  			if r.TryDecodeAsNil() {
 44673  				x.ID = ""
 44674  			} else {
 44675  				yyv4 := &x.ID
 44676  				yym5 := z.DecBinary()
 44677  				_ = yym5
 44678  				if false {
 44679  				} else {
 44680  					*((*string)(yyv4)) = r.DecodeString()
 44681  				}
 44682  			}
 44683  		case "SecretID":
 44684  			if r.TryDecodeAsNil() {
 44685  				x.SecretID = ""
 44686  			} else {
 44687  				yyv6 := &x.SecretID
 44688  				yym7 := z.DecBinary()
 44689  				_ = yym7
 44690  				if false {
 44691  				} else {
 44692  					*((*string)(yyv6)) = r.DecodeString()
 44693  				}
 44694  			}
 44695  		case "Datacenter":
 44696  			if r.TryDecodeAsNil() {
 44697  				x.Datacenter = ""
 44698  			} else {
 44699  				yyv8 := &x.Datacenter
 44700  				yym9 := z.DecBinary()
 44701  				_ = yym9
 44702  				if false {
 44703  				} else {
 44704  					*((*string)(yyv8)) = r.DecodeString()
 44705  				}
 44706  			}
 44707  		case "Name":
 44708  			if r.TryDecodeAsNil() {
 44709  				x.Name = ""
 44710  			} else {
 44711  				yyv10 := &x.Name
 44712  				yym11 := z.DecBinary()
 44713  				_ = yym11
 44714  				if false {
 44715  				} else {
 44716  					*((*string)(yyv10)) = r.DecodeString()
 44717  				}
 44718  			}
 44719  		case "HTTPAddr":
 44720  			if r.TryDecodeAsNil() {
 44721  				x.HTTPAddr = ""
 44722  			} else {
 44723  				yyv12 := &x.HTTPAddr
 44724  				yym13 := z.DecBinary()
 44725  				_ = yym13
 44726  				if false {
 44727  				} else {
 44728  					*((*string)(yyv12)) = r.DecodeString()
 44729  				}
 44730  			}
 44731  		case "TLSEnabled":
 44732  			if r.TryDecodeAsNil() {
 44733  				x.TLSEnabled = false
 44734  			} else {
 44735  				yyv14 := &x.TLSEnabled
 44736  				yym15 := z.DecBinary()
 44737  				_ = yym15
 44738  				if false {
 44739  				} else {
 44740  					*((*bool)(yyv14)) = r.DecodeBool()
 44741  				}
 44742  			}
 44743  		case "Attributes":
 44744  			if r.TryDecodeAsNil() {
 44745  				x.Attributes = nil
 44746  			} else {
 44747  				yyv16 := &x.Attributes
 44748  				yym17 := z.DecBinary()
 44749  				_ = yym17
 44750  				if false {
 44751  				} else {
 44752  					z.F.DecMapStringStringX(yyv16, false, d)
 44753  				}
 44754  			}
 44755  		case "Resources":
 44756  			if r.TryDecodeAsNil() {
 44757  				if x.Resources != nil {
 44758  					x.Resources = nil
 44759  				}
 44760  			} else {
 44761  				if x.Resources == nil {
 44762  					x.Resources = new(Resources)
 44763  				}
 44764  				x.Resources.CodecDecodeSelf(d)
 44765  			}
 44766  		case "Reserved":
 44767  			if r.TryDecodeAsNil() {
 44768  				if x.Reserved != nil {
 44769  					x.Reserved = nil
 44770  				}
 44771  			} else {
 44772  				if x.Reserved == nil {
 44773  					x.Reserved = new(Resources)
 44774  				}
 44775  				x.Reserved.CodecDecodeSelf(d)
 44776  			}
 44777  		case "Links":
 44778  			if r.TryDecodeAsNil() {
 44779  				x.Links = nil
 44780  			} else {
 44781  				yyv20 := &x.Links
 44782  				yym21 := z.DecBinary()
 44783  				_ = yym21
 44784  				if false {
 44785  				} else {
 44786  					z.F.DecMapStringStringX(yyv20, false, d)
 44787  				}
 44788  			}
 44789  		case "Meta":
 44790  			if r.TryDecodeAsNil() {
 44791  				x.Meta = nil
 44792  			} else {
 44793  				yyv22 := &x.Meta
 44794  				yym23 := z.DecBinary()
 44795  				_ = yym23
 44796  				if false {
 44797  				} else {
 44798  					z.F.DecMapStringStringX(yyv22, false, d)
 44799  				}
 44800  			}
 44801  		case "NodeClass":
 44802  			if r.TryDecodeAsNil() {
 44803  				x.NodeClass = ""
 44804  			} else {
 44805  				yyv24 := &x.NodeClass
 44806  				yym25 := z.DecBinary()
 44807  				_ = yym25
 44808  				if false {
 44809  				} else {
 44810  					*((*string)(yyv24)) = r.DecodeString()
 44811  				}
 44812  			}
 44813  		case "ComputedClass":
 44814  			if r.TryDecodeAsNil() {
 44815  				x.ComputedClass = ""
 44816  			} else {
 44817  				yyv26 := &x.ComputedClass
 44818  				yym27 := z.DecBinary()
 44819  				_ = yym27
 44820  				if false {
 44821  				} else {
 44822  					*((*string)(yyv26)) = r.DecodeString()
 44823  				}
 44824  			}
 44825  		case "Drain":
 44826  			if r.TryDecodeAsNil() {
 44827  				x.Drain = false
 44828  			} else {
 44829  				yyv28 := &x.Drain
 44830  				yym29 := z.DecBinary()
 44831  				_ = yym29
 44832  				if false {
 44833  				} else {
 44834  					*((*bool)(yyv28)) = r.DecodeBool()
 44835  				}
 44836  			}
 44837  		case "DrainStrategy":
 44838  			if r.TryDecodeAsNil() {
 44839  				if x.DrainStrategy != nil {
 44840  					x.DrainStrategy = nil
 44841  				}
 44842  			} else {
 44843  				if x.DrainStrategy == nil {
 44844  					x.DrainStrategy = new(DrainStrategy)
 44845  				}
 44846  				x.DrainStrategy.CodecDecodeSelf(d)
 44847  			}
 44848  		case "SchedulingEligibility":
 44849  			if r.TryDecodeAsNil() {
 44850  				x.SchedulingEligibility = ""
 44851  			} else {
 44852  				yyv31 := &x.SchedulingEligibility
 44853  				yym32 := z.DecBinary()
 44854  				_ = yym32
 44855  				if false {
 44856  				} else {
 44857  					*((*string)(yyv31)) = r.DecodeString()
 44858  				}
 44859  			}
 44860  		case "Status":
 44861  			if r.TryDecodeAsNil() {
 44862  				x.Status = ""
 44863  			} else {
 44864  				yyv33 := &x.Status
 44865  				yym34 := z.DecBinary()
 44866  				_ = yym34
 44867  				if false {
 44868  				} else {
 44869  					*((*string)(yyv33)) = r.DecodeString()
 44870  				}
 44871  			}
 44872  		case "StatusDescription":
 44873  			if r.TryDecodeAsNil() {
 44874  				x.StatusDescription = ""
 44875  			} else {
 44876  				yyv35 := &x.StatusDescription
 44877  				yym36 := z.DecBinary()
 44878  				_ = yym36
 44879  				if false {
 44880  				} else {
 44881  					*((*string)(yyv35)) = r.DecodeString()
 44882  				}
 44883  			}
 44884  		case "StatusUpdatedAt":
 44885  			if r.TryDecodeAsNil() {
 44886  				x.StatusUpdatedAt = 0
 44887  			} else {
 44888  				yyv37 := &x.StatusUpdatedAt
 44889  				yym38 := z.DecBinary()
 44890  				_ = yym38
 44891  				if false {
 44892  				} else {
 44893  					*((*int64)(yyv37)) = int64(r.DecodeInt(64))
 44894  				}
 44895  			}
 44896  		case "Events":
 44897  			if r.TryDecodeAsNil() {
 44898  				x.Events = nil
 44899  			} else {
 44900  				yyv39 := &x.Events
 44901  				yym40 := z.DecBinary()
 44902  				_ = yym40
 44903  				if false {
 44904  				} else {
 44905  					h.decSlicePtrtoNodeEvent((*[]*NodeEvent)(yyv39), d)
 44906  				}
 44907  			}
 44908  		case "Drivers":
 44909  			if r.TryDecodeAsNil() {
 44910  				x.Drivers = nil
 44911  			} else {
 44912  				yyv41 := &x.Drivers
 44913  				yym42 := z.DecBinary()
 44914  				_ = yym42
 44915  				if false {
 44916  				} else {
 44917  					h.decMapstringPtrtoDriverInfo((*map[string]*DriverInfo)(yyv41), d)
 44918  				}
 44919  			}
 44920  		case "CreateIndex":
 44921  			if r.TryDecodeAsNil() {
 44922  				x.CreateIndex = 0
 44923  			} else {
 44924  				yyv43 := &x.CreateIndex
 44925  				yym44 := z.DecBinary()
 44926  				_ = yym44
 44927  				if false {
 44928  				} else {
 44929  					*((*uint64)(yyv43)) = uint64(r.DecodeUint(64))
 44930  				}
 44931  			}
 44932  		case "ModifyIndex":
 44933  			if r.TryDecodeAsNil() {
 44934  				x.ModifyIndex = 0
 44935  			} else {
 44936  				yyv45 := &x.ModifyIndex
 44937  				yym46 := z.DecBinary()
 44938  				_ = yym46
 44939  				if false {
 44940  				} else {
 44941  					*((*uint64)(yyv45)) = uint64(r.DecodeUint(64))
 44942  				}
 44943  			}
 44944  		default:
 44945  			z.DecStructFieldNotFound(-1, yys3)
 44946  		} // end switch yys3
 44947  	} // end for yyj3
 44948  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 44949  }
 44950  
 44951  func (x *Node) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 44952  	var h codecSelfer100
 44953  	z, r := codec1978.GenHelperDecoder(d)
 44954  	_, _, _ = h, z, r
 44955  	var yyj47 int
 44956  	var yyb47 bool
 44957  	var yyhl47 bool = l >= 0
 44958  	yyj47++
 44959  	if yyhl47 {
 44960  		yyb47 = yyj47 > l
 44961  	} else {
 44962  		yyb47 = r.CheckBreak()
 44963  	}
 44964  	if yyb47 {
 44965  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 44966  		return
 44967  	}
 44968  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 44969  	if r.TryDecodeAsNil() {
 44970  		x.ID = ""
 44971  	} else {
 44972  		yyv48 := &x.ID
 44973  		yym49 := z.DecBinary()
 44974  		_ = yym49
 44975  		if false {
 44976  		} else {
 44977  			*((*string)(yyv48)) = r.DecodeString()
 44978  		}
 44979  	}
 44980  	yyj47++
 44981  	if yyhl47 {
 44982  		yyb47 = yyj47 > l
 44983  	} else {
 44984  		yyb47 = r.CheckBreak()
 44985  	}
 44986  	if yyb47 {
 44987  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 44988  		return
 44989  	}
 44990  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 44991  	if r.TryDecodeAsNil() {
 44992  		x.SecretID = ""
 44993  	} else {
 44994  		yyv50 := &x.SecretID
 44995  		yym51 := z.DecBinary()
 44996  		_ = yym51
 44997  		if false {
 44998  		} else {
 44999  			*((*string)(yyv50)) = r.DecodeString()
 45000  		}
 45001  	}
 45002  	yyj47++
 45003  	if yyhl47 {
 45004  		yyb47 = yyj47 > l
 45005  	} else {
 45006  		yyb47 = r.CheckBreak()
 45007  	}
 45008  	if yyb47 {
 45009  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45010  		return
 45011  	}
 45012  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45013  	if r.TryDecodeAsNil() {
 45014  		x.Datacenter = ""
 45015  	} else {
 45016  		yyv52 := &x.Datacenter
 45017  		yym53 := z.DecBinary()
 45018  		_ = yym53
 45019  		if false {
 45020  		} else {
 45021  			*((*string)(yyv52)) = r.DecodeString()
 45022  		}
 45023  	}
 45024  	yyj47++
 45025  	if yyhl47 {
 45026  		yyb47 = yyj47 > l
 45027  	} else {
 45028  		yyb47 = r.CheckBreak()
 45029  	}
 45030  	if yyb47 {
 45031  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45032  		return
 45033  	}
 45034  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45035  	if r.TryDecodeAsNil() {
 45036  		x.Name = ""
 45037  	} else {
 45038  		yyv54 := &x.Name
 45039  		yym55 := z.DecBinary()
 45040  		_ = yym55
 45041  		if false {
 45042  		} else {
 45043  			*((*string)(yyv54)) = r.DecodeString()
 45044  		}
 45045  	}
 45046  	yyj47++
 45047  	if yyhl47 {
 45048  		yyb47 = yyj47 > l
 45049  	} else {
 45050  		yyb47 = r.CheckBreak()
 45051  	}
 45052  	if yyb47 {
 45053  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45054  		return
 45055  	}
 45056  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45057  	if r.TryDecodeAsNil() {
 45058  		x.HTTPAddr = ""
 45059  	} else {
 45060  		yyv56 := &x.HTTPAddr
 45061  		yym57 := z.DecBinary()
 45062  		_ = yym57
 45063  		if false {
 45064  		} else {
 45065  			*((*string)(yyv56)) = r.DecodeString()
 45066  		}
 45067  	}
 45068  	yyj47++
 45069  	if yyhl47 {
 45070  		yyb47 = yyj47 > l
 45071  	} else {
 45072  		yyb47 = r.CheckBreak()
 45073  	}
 45074  	if yyb47 {
 45075  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45076  		return
 45077  	}
 45078  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45079  	if r.TryDecodeAsNil() {
 45080  		x.TLSEnabled = false
 45081  	} else {
 45082  		yyv58 := &x.TLSEnabled
 45083  		yym59 := z.DecBinary()
 45084  		_ = yym59
 45085  		if false {
 45086  		} else {
 45087  			*((*bool)(yyv58)) = r.DecodeBool()
 45088  		}
 45089  	}
 45090  	yyj47++
 45091  	if yyhl47 {
 45092  		yyb47 = yyj47 > l
 45093  	} else {
 45094  		yyb47 = r.CheckBreak()
 45095  	}
 45096  	if yyb47 {
 45097  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45098  		return
 45099  	}
 45100  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45101  	if r.TryDecodeAsNil() {
 45102  		x.Attributes = nil
 45103  	} else {
 45104  		yyv60 := &x.Attributes
 45105  		yym61 := z.DecBinary()
 45106  		_ = yym61
 45107  		if false {
 45108  		} else {
 45109  			z.F.DecMapStringStringX(yyv60, false, d)
 45110  		}
 45111  	}
 45112  	yyj47++
 45113  	if yyhl47 {
 45114  		yyb47 = yyj47 > l
 45115  	} else {
 45116  		yyb47 = r.CheckBreak()
 45117  	}
 45118  	if yyb47 {
 45119  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45120  		return
 45121  	}
 45122  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45123  	if r.TryDecodeAsNil() {
 45124  		if x.Resources != nil {
 45125  			x.Resources = nil
 45126  		}
 45127  	} else {
 45128  		if x.Resources == nil {
 45129  			x.Resources = new(Resources)
 45130  		}
 45131  		x.Resources.CodecDecodeSelf(d)
 45132  	}
 45133  	yyj47++
 45134  	if yyhl47 {
 45135  		yyb47 = yyj47 > l
 45136  	} else {
 45137  		yyb47 = r.CheckBreak()
 45138  	}
 45139  	if yyb47 {
 45140  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45141  		return
 45142  	}
 45143  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45144  	if r.TryDecodeAsNil() {
 45145  		if x.Reserved != nil {
 45146  			x.Reserved = nil
 45147  		}
 45148  	} else {
 45149  		if x.Reserved == nil {
 45150  			x.Reserved = new(Resources)
 45151  		}
 45152  		x.Reserved.CodecDecodeSelf(d)
 45153  	}
 45154  	yyj47++
 45155  	if yyhl47 {
 45156  		yyb47 = yyj47 > l
 45157  	} else {
 45158  		yyb47 = r.CheckBreak()
 45159  	}
 45160  	if yyb47 {
 45161  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45162  		return
 45163  	}
 45164  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45165  	if r.TryDecodeAsNil() {
 45166  		x.Links = nil
 45167  	} else {
 45168  		yyv64 := &x.Links
 45169  		yym65 := z.DecBinary()
 45170  		_ = yym65
 45171  		if false {
 45172  		} else {
 45173  			z.F.DecMapStringStringX(yyv64, false, d)
 45174  		}
 45175  	}
 45176  	yyj47++
 45177  	if yyhl47 {
 45178  		yyb47 = yyj47 > l
 45179  	} else {
 45180  		yyb47 = r.CheckBreak()
 45181  	}
 45182  	if yyb47 {
 45183  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45184  		return
 45185  	}
 45186  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45187  	if r.TryDecodeAsNil() {
 45188  		x.Meta = nil
 45189  	} else {
 45190  		yyv66 := &x.Meta
 45191  		yym67 := z.DecBinary()
 45192  		_ = yym67
 45193  		if false {
 45194  		} else {
 45195  			z.F.DecMapStringStringX(yyv66, false, d)
 45196  		}
 45197  	}
 45198  	yyj47++
 45199  	if yyhl47 {
 45200  		yyb47 = yyj47 > l
 45201  	} else {
 45202  		yyb47 = r.CheckBreak()
 45203  	}
 45204  	if yyb47 {
 45205  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45206  		return
 45207  	}
 45208  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45209  	if r.TryDecodeAsNil() {
 45210  		x.NodeClass = ""
 45211  	} else {
 45212  		yyv68 := &x.NodeClass
 45213  		yym69 := z.DecBinary()
 45214  		_ = yym69
 45215  		if false {
 45216  		} else {
 45217  			*((*string)(yyv68)) = r.DecodeString()
 45218  		}
 45219  	}
 45220  	yyj47++
 45221  	if yyhl47 {
 45222  		yyb47 = yyj47 > l
 45223  	} else {
 45224  		yyb47 = r.CheckBreak()
 45225  	}
 45226  	if yyb47 {
 45227  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45228  		return
 45229  	}
 45230  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45231  	if r.TryDecodeAsNil() {
 45232  		x.ComputedClass = ""
 45233  	} else {
 45234  		yyv70 := &x.ComputedClass
 45235  		yym71 := z.DecBinary()
 45236  		_ = yym71
 45237  		if false {
 45238  		} else {
 45239  			*((*string)(yyv70)) = r.DecodeString()
 45240  		}
 45241  	}
 45242  	yyj47++
 45243  	if yyhl47 {
 45244  		yyb47 = yyj47 > l
 45245  	} else {
 45246  		yyb47 = r.CheckBreak()
 45247  	}
 45248  	if yyb47 {
 45249  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45250  		return
 45251  	}
 45252  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45253  	if r.TryDecodeAsNil() {
 45254  		x.Drain = false
 45255  	} else {
 45256  		yyv72 := &x.Drain
 45257  		yym73 := z.DecBinary()
 45258  		_ = yym73
 45259  		if false {
 45260  		} else {
 45261  			*((*bool)(yyv72)) = r.DecodeBool()
 45262  		}
 45263  	}
 45264  	yyj47++
 45265  	if yyhl47 {
 45266  		yyb47 = yyj47 > l
 45267  	} else {
 45268  		yyb47 = r.CheckBreak()
 45269  	}
 45270  	if yyb47 {
 45271  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45272  		return
 45273  	}
 45274  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45275  	if r.TryDecodeAsNil() {
 45276  		if x.DrainStrategy != nil {
 45277  			x.DrainStrategy = nil
 45278  		}
 45279  	} else {
 45280  		if x.DrainStrategy == nil {
 45281  			x.DrainStrategy = new(DrainStrategy)
 45282  		}
 45283  		x.DrainStrategy.CodecDecodeSelf(d)
 45284  	}
 45285  	yyj47++
 45286  	if yyhl47 {
 45287  		yyb47 = yyj47 > l
 45288  	} else {
 45289  		yyb47 = r.CheckBreak()
 45290  	}
 45291  	if yyb47 {
 45292  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45293  		return
 45294  	}
 45295  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45296  	if r.TryDecodeAsNil() {
 45297  		x.SchedulingEligibility = ""
 45298  	} else {
 45299  		yyv75 := &x.SchedulingEligibility
 45300  		yym76 := z.DecBinary()
 45301  		_ = yym76
 45302  		if false {
 45303  		} else {
 45304  			*((*string)(yyv75)) = r.DecodeString()
 45305  		}
 45306  	}
 45307  	yyj47++
 45308  	if yyhl47 {
 45309  		yyb47 = yyj47 > l
 45310  	} else {
 45311  		yyb47 = r.CheckBreak()
 45312  	}
 45313  	if yyb47 {
 45314  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45315  		return
 45316  	}
 45317  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45318  	if r.TryDecodeAsNil() {
 45319  		x.Status = ""
 45320  	} else {
 45321  		yyv77 := &x.Status
 45322  		yym78 := z.DecBinary()
 45323  		_ = yym78
 45324  		if false {
 45325  		} else {
 45326  			*((*string)(yyv77)) = r.DecodeString()
 45327  		}
 45328  	}
 45329  	yyj47++
 45330  	if yyhl47 {
 45331  		yyb47 = yyj47 > l
 45332  	} else {
 45333  		yyb47 = r.CheckBreak()
 45334  	}
 45335  	if yyb47 {
 45336  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45337  		return
 45338  	}
 45339  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45340  	if r.TryDecodeAsNil() {
 45341  		x.StatusDescription = ""
 45342  	} else {
 45343  		yyv79 := &x.StatusDescription
 45344  		yym80 := z.DecBinary()
 45345  		_ = yym80
 45346  		if false {
 45347  		} else {
 45348  			*((*string)(yyv79)) = r.DecodeString()
 45349  		}
 45350  	}
 45351  	yyj47++
 45352  	if yyhl47 {
 45353  		yyb47 = yyj47 > l
 45354  	} else {
 45355  		yyb47 = r.CheckBreak()
 45356  	}
 45357  	if yyb47 {
 45358  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45359  		return
 45360  	}
 45361  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45362  	if r.TryDecodeAsNil() {
 45363  		x.StatusUpdatedAt = 0
 45364  	} else {
 45365  		yyv81 := &x.StatusUpdatedAt
 45366  		yym82 := z.DecBinary()
 45367  		_ = yym82
 45368  		if false {
 45369  		} else {
 45370  			*((*int64)(yyv81)) = int64(r.DecodeInt(64))
 45371  		}
 45372  	}
 45373  	yyj47++
 45374  	if yyhl47 {
 45375  		yyb47 = yyj47 > l
 45376  	} else {
 45377  		yyb47 = r.CheckBreak()
 45378  	}
 45379  	if yyb47 {
 45380  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45381  		return
 45382  	}
 45383  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45384  	if r.TryDecodeAsNil() {
 45385  		x.Events = nil
 45386  	} else {
 45387  		yyv83 := &x.Events
 45388  		yym84 := z.DecBinary()
 45389  		_ = yym84
 45390  		if false {
 45391  		} else {
 45392  			h.decSlicePtrtoNodeEvent((*[]*NodeEvent)(yyv83), d)
 45393  		}
 45394  	}
 45395  	yyj47++
 45396  	if yyhl47 {
 45397  		yyb47 = yyj47 > l
 45398  	} else {
 45399  		yyb47 = r.CheckBreak()
 45400  	}
 45401  	if yyb47 {
 45402  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45403  		return
 45404  	}
 45405  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45406  	if r.TryDecodeAsNil() {
 45407  		x.Drivers = nil
 45408  	} else {
 45409  		yyv85 := &x.Drivers
 45410  		yym86 := z.DecBinary()
 45411  		_ = yym86
 45412  		if false {
 45413  		} else {
 45414  			h.decMapstringPtrtoDriverInfo((*map[string]*DriverInfo)(yyv85), d)
 45415  		}
 45416  	}
 45417  	yyj47++
 45418  	if yyhl47 {
 45419  		yyb47 = yyj47 > l
 45420  	} else {
 45421  		yyb47 = r.CheckBreak()
 45422  	}
 45423  	if yyb47 {
 45424  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45425  		return
 45426  	}
 45427  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45428  	if r.TryDecodeAsNil() {
 45429  		x.CreateIndex = 0
 45430  	} else {
 45431  		yyv87 := &x.CreateIndex
 45432  		yym88 := z.DecBinary()
 45433  		_ = yym88
 45434  		if false {
 45435  		} else {
 45436  			*((*uint64)(yyv87)) = uint64(r.DecodeUint(64))
 45437  		}
 45438  	}
 45439  	yyj47++
 45440  	if yyhl47 {
 45441  		yyb47 = yyj47 > l
 45442  	} else {
 45443  		yyb47 = r.CheckBreak()
 45444  	}
 45445  	if yyb47 {
 45446  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45447  		return
 45448  	}
 45449  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45450  	if r.TryDecodeAsNil() {
 45451  		x.ModifyIndex = 0
 45452  	} else {
 45453  		yyv89 := &x.ModifyIndex
 45454  		yym90 := z.DecBinary()
 45455  		_ = yym90
 45456  		if false {
 45457  		} else {
 45458  			*((*uint64)(yyv89)) = uint64(r.DecodeUint(64))
 45459  		}
 45460  	}
 45461  	for {
 45462  		yyj47++
 45463  		if yyhl47 {
 45464  			yyb47 = yyj47 > l
 45465  		} else {
 45466  			yyb47 = r.CheckBreak()
 45467  		}
 45468  		if yyb47 {
 45469  			break
 45470  		}
 45471  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45472  		z.DecStructFieldNotFound(yyj47-1, "")
 45473  	}
 45474  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45475  }
 45476  
 45477  func (x *NodeListStub) CodecEncodeSelf(e *codec1978.Encoder) {
 45478  	var h codecSelfer100
 45479  	z, r := codec1978.GenHelperEncoder(e)
 45480  	_, _, _ = h, z, r
 45481  	if x == nil {
 45482  		r.EncodeNil()
 45483  	} else {
 45484  		yym1 := z.EncBinary()
 45485  		_ = yym1
 45486  		if false {
 45487  		} else if z.HasExtensions() && z.EncExt(x) {
 45488  		} else {
 45489  			yysep2 := !z.EncBinary()
 45490  			yy2arr2 := z.EncBasicHandle().StructToArray
 45491  			var yyq2 [12]bool
 45492  			_, _, _ = yysep2, yyq2, yy2arr2
 45493  			const yyr2 bool = false
 45494  			var yynn2 int
 45495  			if yyr2 || yy2arr2 {
 45496  				r.EncodeArrayStart(12)
 45497  			} else {
 45498  				yynn2 = 12
 45499  				for _, b := range yyq2 {
 45500  					if b {
 45501  						yynn2++
 45502  					}
 45503  				}
 45504  				r.EncodeMapStart(yynn2)
 45505  				yynn2 = 0
 45506  			}
 45507  			if yyr2 || yy2arr2 {
 45508  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 45509  				yym4 := z.EncBinary()
 45510  				_ = yym4
 45511  				if false {
 45512  				} else {
 45513  					r.EncodeString(codecSelferC_UTF8100, string(x.Address))
 45514  				}
 45515  			} else {
 45516  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 45517  				r.EncodeString(codecSelferC_UTF8100, string("Address"))
 45518  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 45519  				yym5 := z.EncBinary()
 45520  				_ = yym5
 45521  				if false {
 45522  				} else {
 45523  					r.EncodeString(codecSelferC_UTF8100, string(x.Address))
 45524  				}
 45525  			}
 45526  			if yyr2 || yy2arr2 {
 45527  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 45528  				yym7 := z.EncBinary()
 45529  				_ = yym7
 45530  				if false {
 45531  				} else {
 45532  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 45533  				}
 45534  			} else {
 45535  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 45536  				r.EncodeString(codecSelferC_UTF8100, string("ID"))
 45537  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 45538  				yym8 := z.EncBinary()
 45539  				_ = yym8
 45540  				if false {
 45541  				} else {
 45542  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 45543  				}
 45544  			}
 45545  			if yyr2 || yy2arr2 {
 45546  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 45547  				yym10 := z.EncBinary()
 45548  				_ = yym10
 45549  				if false {
 45550  				} else {
 45551  					r.EncodeString(codecSelferC_UTF8100, string(x.Datacenter))
 45552  				}
 45553  			} else {
 45554  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 45555  				r.EncodeString(codecSelferC_UTF8100, string("Datacenter"))
 45556  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 45557  				yym11 := z.EncBinary()
 45558  				_ = yym11
 45559  				if false {
 45560  				} else {
 45561  					r.EncodeString(codecSelferC_UTF8100, string(x.Datacenter))
 45562  				}
 45563  			}
 45564  			if yyr2 || yy2arr2 {
 45565  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 45566  				yym13 := z.EncBinary()
 45567  				_ = yym13
 45568  				if false {
 45569  				} else {
 45570  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 45571  				}
 45572  			} else {
 45573  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 45574  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 45575  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 45576  				yym14 := z.EncBinary()
 45577  				_ = yym14
 45578  				if false {
 45579  				} else {
 45580  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 45581  				}
 45582  			}
 45583  			if yyr2 || yy2arr2 {
 45584  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 45585  				yym16 := z.EncBinary()
 45586  				_ = yym16
 45587  				if false {
 45588  				} else {
 45589  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeClass))
 45590  				}
 45591  			} else {
 45592  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 45593  				r.EncodeString(codecSelferC_UTF8100, string("NodeClass"))
 45594  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 45595  				yym17 := z.EncBinary()
 45596  				_ = yym17
 45597  				if false {
 45598  				} else {
 45599  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeClass))
 45600  				}
 45601  			}
 45602  			if yyr2 || yy2arr2 {
 45603  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 45604  				yym19 := z.EncBinary()
 45605  				_ = yym19
 45606  				if false {
 45607  				} else {
 45608  					r.EncodeString(codecSelferC_UTF8100, string(x.Version))
 45609  				}
 45610  			} else {
 45611  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 45612  				r.EncodeString(codecSelferC_UTF8100, string("Version"))
 45613  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 45614  				yym20 := z.EncBinary()
 45615  				_ = yym20
 45616  				if false {
 45617  				} else {
 45618  					r.EncodeString(codecSelferC_UTF8100, string(x.Version))
 45619  				}
 45620  			}
 45621  			if yyr2 || yy2arr2 {
 45622  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 45623  				yym22 := z.EncBinary()
 45624  				_ = yym22
 45625  				if false {
 45626  				} else {
 45627  					r.EncodeBool(bool(x.Drain))
 45628  				}
 45629  			} else {
 45630  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 45631  				r.EncodeString(codecSelferC_UTF8100, string("Drain"))
 45632  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 45633  				yym23 := z.EncBinary()
 45634  				_ = yym23
 45635  				if false {
 45636  				} else {
 45637  					r.EncodeBool(bool(x.Drain))
 45638  				}
 45639  			}
 45640  			if yyr2 || yy2arr2 {
 45641  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 45642  				yym25 := z.EncBinary()
 45643  				_ = yym25
 45644  				if false {
 45645  				} else {
 45646  					r.EncodeString(codecSelferC_UTF8100, string(x.SchedulingEligibility))
 45647  				}
 45648  			} else {
 45649  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 45650  				r.EncodeString(codecSelferC_UTF8100, string("SchedulingEligibility"))
 45651  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 45652  				yym26 := z.EncBinary()
 45653  				_ = yym26
 45654  				if false {
 45655  				} else {
 45656  					r.EncodeString(codecSelferC_UTF8100, string(x.SchedulingEligibility))
 45657  				}
 45658  			}
 45659  			if yyr2 || yy2arr2 {
 45660  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 45661  				yym28 := z.EncBinary()
 45662  				_ = yym28
 45663  				if false {
 45664  				} else {
 45665  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 45666  				}
 45667  			} else {
 45668  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 45669  				r.EncodeString(codecSelferC_UTF8100, string("Status"))
 45670  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 45671  				yym29 := z.EncBinary()
 45672  				_ = yym29
 45673  				if false {
 45674  				} else {
 45675  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 45676  				}
 45677  			}
 45678  			if yyr2 || yy2arr2 {
 45679  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 45680  				yym31 := z.EncBinary()
 45681  				_ = yym31
 45682  				if false {
 45683  				} else {
 45684  					r.EncodeString(codecSelferC_UTF8100, string(x.StatusDescription))
 45685  				}
 45686  			} else {
 45687  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 45688  				r.EncodeString(codecSelferC_UTF8100, string("StatusDescription"))
 45689  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 45690  				yym32 := z.EncBinary()
 45691  				_ = yym32
 45692  				if false {
 45693  				} else {
 45694  					r.EncodeString(codecSelferC_UTF8100, string(x.StatusDescription))
 45695  				}
 45696  			}
 45697  			if yyr2 || yy2arr2 {
 45698  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 45699  				yym34 := z.EncBinary()
 45700  				_ = yym34
 45701  				if false {
 45702  				} else {
 45703  					r.EncodeUint(uint64(x.CreateIndex))
 45704  				}
 45705  			} else {
 45706  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 45707  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 45708  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 45709  				yym35 := z.EncBinary()
 45710  				_ = yym35
 45711  				if false {
 45712  				} else {
 45713  					r.EncodeUint(uint64(x.CreateIndex))
 45714  				}
 45715  			}
 45716  			if yyr2 || yy2arr2 {
 45717  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 45718  				yym37 := z.EncBinary()
 45719  				_ = yym37
 45720  				if false {
 45721  				} else {
 45722  					r.EncodeUint(uint64(x.ModifyIndex))
 45723  				}
 45724  			} else {
 45725  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 45726  				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
 45727  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 45728  				yym38 := z.EncBinary()
 45729  				_ = yym38
 45730  				if false {
 45731  				} else {
 45732  					r.EncodeUint(uint64(x.ModifyIndex))
 45733  				}
 45734  			}
 45735  			if yyr2 || yy2arr2 {
 45736  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 45737  			} else {
 45738  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 45739  			}
 45740  		}
 45741  	}
 45742  }
 45743  
 45744  func (x *NodeListStub) CodecDecodeSelf(d *codec1978.Decoder) {
 45745  	var h codecSelfer100
 45746  	z, r := codec1978.GenHelperDecoder(d)
 45747  	_, _, _ = h, z, r
 45748  	yym1 := z.DecBinary()
 45749  	_ = yym1
 45750  	if false {
 45751  	} else if z.HasExtensions() && z.DecExt(x) {
 45752  	} else {
 45753  		yyct2 := r.ContainerType()
 45754  		if yyct2 == codecSelferValueTypeMap100 {
 45755  			yyl2 := r.ReadMapStart()
 45756  			if yyl2 == 0 {
 45757  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 45758  			} else {
 45759  				x.codecDecodeSelfFromMap(yyl2, d)
 45760  			}
 45761  		} else if yyct2 == codecSelferValueTypeArray100 {
 45762  			yyl2 := r.ReadArrayStart()
 45763  			if yyl2 == 0 {
 45764  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45765  			} else {
 45766  				x.codecDecodeSelfFromArray(yyl2, d)
 45767  			}
 45768  		} else {
 45769  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 45770  		}
 45771  	}
 45772  }
 45773  
 45774  func (x *NodeListStub) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 45775  	var h codecSelfer100
 45776  	z, r := codec1978.GenHelperDecoder(d)
 45777  	_, _, _ = h, z, r
 45778  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 45779  	_ = yys3Slc
 45780  	var yyhl3 bool = l >= 0
 45781  	for yyj3 := 0; ; yyj3++ {
 45782  		if yyhl3 {
 45783  			if yyj3 >= l {
 45784  				break
 45785  			}
 45786  		} else {
 45787  			if r.CheckBreak() {
 45788  				break
 45789  			}
 45790  		}
 45791  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 45792  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 45793  		yys3 := string(yys3Slc)
 45794  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 45795  		switch yys3 {
 45796  		case "Address":
 45797  			if r.TryDecodeAsNil() {
 45798  				x.Address = ""
 45799  			} else {
 45800  				yyv4 := &x.Address
 45801  				yym5 := z.DecBinary()
 45802  				_ = yym5
 45803  				if false {
 45804  				} else {
 45805  					*((*string)(yyv4)) = r.DecodeString()
 45806  				}
 45807  			}
 45808  		case "ID":
 45809  			if r.TryDecodeAsNil() {
 45810  				x.ID = ""
 45811  			} else {
 45812  				yyv6 := &x.ID
 45813  				yym7 := z.DecBinary()
 45814  				_ = yym7
 45815  				if false {
 45816  				} else {
 45817  					*((*string)(yyv6)) = r.DecodeString()
 45818  				}
 45819  			}
 45820  		case "Datacenter":
 45821  			if r.TryDecodeAsNil() {
 45822  				x.Datacenter = ""
 45823  			} else {
 45824  				yyv8 := &x.Datacenter
 45825  				yym9 := z.DecBinary()
 45826  				_ = yym9
 45827  				if false {
 45828  				} else {
 45829  					*((*string)(yyv8)) = r.DecodeString()
 45830  				}
 45831  			}
 45832  		case "Name":
 45833  			if r.TryDecodeAsNil() {
 45834  				x.Name = ""
 45835  			} else {
 45836  				yyv10 := &x.Name
 45837  				yym11 := z.DecBinary()
 45838  				_ = yym11
 45839  				if false {
 45840  				} else {
 45841  					*((*string)(yyv10)) = r.DecodeString()
 45842  				}
 45843  			}
 45844  		case "NodeClass":
 45845  			if r.TryDecodeAsNil() {
 45846  				x.NodeClass = ""
 45847  			} else {
 45848  				yyv12 := &x.NodeClass
 45849  				yym13 := z.DecBinary()
 45850  				_ = yym13
 45851  				if false {
 45852  				} else {
 45853  					*((*string)(yyv12)) = r.DecodeString()
 45854  				}
 45855  			}
 45856  		case "Version":
 45857  			if r.TryDecodeAsNil() {
 45858  				x.Version = ""
 45859  			} else {
 45860  				yyv14 := &x.Version
 45861  				yym15 := z.DecBinary()
 45862  				_ = yym15
 45863  				if false {
 45864  				} else {
 45865  					*((*string)(yyv14)) = r.DecodeString()
 45866  				}
 45867  			}
 45868  		case "Drain":
 45869  			if r.TryDecodeAsNil() {
 45870  				x.Drain = false
 45871  			} else {
 45872  				yyv16 := &x.Drain
 45873  				yym17 := z.DecBinary()
 45874  				_ = yym17
 45875  				if false {
 45876  				} else {
 45877  					*((*bool)(yyv16)) = r.DecodeBool()
 45878  				}
 45879  			}
 45880  		case "SchedulingEligibility":
 45881  			if r.TryDecodeAsNil() {
 45882  				x.SchedulingEligibility = ""
 45883  			} else {
 45884  				yyv18 := &x.SchedulingEligibility
 45885  				yym19 := z.DecBinary()
 45886  				_ = yym19
 45887  				if false {
 45888  				} else {
 45889  					*((*string)(yyv18)) = r.DecodeString()
 45890  				}
 45891  			}
 45892  		case "Status":
 45893  			if r.TryDecodeAsNil() {
 45894  				x.Status = ""
 45895  			} else {
 45896  				yyv20 := &x.Status
 45897  				yym21 := z.DecBinary()
 45898  				_ = yym21
 45899  				if false {
 45900  				} else {
 45901  					*((*string)(yyv20)) = r.DecodeString()
 45902  				}
 45903  			}
 45904  		case "StatusDescription":
 45905  			if r.TryDecodeAsNil() {
 45906  				x.StatusDescription = ""
 45907  			} else {
 45908  				yyv22 := &x.StatusDescription
 45909  				yym23 := z.DecBinary()
 45910  				_ = yym23
 45911  				if false {
 45912  				} else {
 45913  					*((*string)(yyv22)) = r.DecodeString()
 45914  				}
 45915  			}
 45916  		case "CreateIndex":
 45917  			if r.TryDecodeAsNil() {
 45918  				x.CreateIndex = 0
 45919  			} else {
 45920  				yyv24 := &x.CreateIndex
 45921  				yym25 := z.DecBinary()
 45922  				_ = yym25
 45923  				if false {
 45924  				} else {
 45925  					*((*uint64)(yyv24)) = uint64(r.DecodeUint(64))
 45926  				}
 45927  			}
 45928  		case "ModifyIndex":
 45929  			if r.TryDecodeAsNil() {
 45930  				x.ModifyIndex = 0
 45931  			} else {
 45932  				yyv26 := &x.ModifyIndex
 45933  				yym27 := z.DecBinary()
 45934  				_ = yym27
 45935  				if false {
 45936  				} else {
 45937  					*((*uint64)(yyv26)) = uint64(r.DecodeUint(64))
 45938  				}
 45939  			}
 45940  		default:
 45941  			z.DecStructFieldNotFound(-1, yys3)
 45942  		} // end switch yys3
 45943  	} // end for yyj3
 45944  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 45945  }
 45946  
 45947  func (x *NodeListStub) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 45948  	var h codecSelfer100
 45949  	z, r := codec1978.GenHelperDecoder(d)
 45950  	_, _, _ = h, z, r
 45951  	var yyj28 int
 45952  	var yyb28 bool
 45953  	var yyhl28 bool = l >= 0
 45954  	yyj28++
 45955  	if yyhl28 {
 45956  		yyb28 = yyj28 > l
 45957  	} else {
 45958  		yyb28 = r.CheckBreak()
 45959  	}
 45960  	if yyb28 {
 45961  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45962  		return
 45963  	}
 45964  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45965  	if r.TryDecodeAsNil() {
 45966  		x.Address = ""
 45967  	} else {
 45968  		yyv29 := &x.Address
 45969  		yym30 := z.DecBinary()
 45970  		_ = yym30
 45971  		if false {
 45972  		} else {
 45973  			*((*string)(yyv29)) = r.DecodeString()
 45974  		}
 45975  	}
 45976  	yyj28++
 45977  	if yyhl28 {
 45978  		yyb28 = yyj28 > l
 45979  	} else {
 45980  		yyb28 = r.CheckBreak()
 45981  	}
 45982  	if yyb28 {
 45983  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 45984  		return
 45985  	}
 45986  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 45987  	if r.TryDecodeAsNil() {
 45988  		x.ID = ""
 45989  	} else {
 45990  		yyv31 := &x.ID
 45991  		yym32 := z.DecBinary()
 45992  		_ = yym32
 45993  		if false {
 45994  		} else {
 45995  			*((*string)(yyv31)) = r.DecodeString()
 45996  		}
 45997  	}
 45998  	yyj28++
 45999  	if yyhl28 {
 46000  		yyb28 = yyj28 > l
 46001  	} else {
 46002  		yyb28 = r.CheckBreak()
 46003  	}
 46004  	if yyb28 {
 46005  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46006  		return
 46007  	}
 46008  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46009  	if r.TryDecodeAsNil() {
 46010  		x.Datacenter = ""
 46011  	} else {
 46012  		yyv33 := &x.Datacenter
 46013  		yym34 := z.DecBinary()
 46014  		_ = yym34
 46015  		if false {
 46016  		} else {
 46017  			*((*string)(yyv33)) = r.DecodeString()
 46018  		}
 46019  	}
 46020  	yyj28++
 46021  	if yyhl28 {
 46022  		yyb28 = yyj28 > l
 46023  	} else {
 46024  		yyb28 = r.CheckBreak()
 46025  	}
 46026  	if yyb28 {
 46027  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46028  		return
 46029  	}
 46030  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46031  	if r.TryDecodeAsNil() {
 46032  		x.Name = ""
 46033  	} else {
 46034  		yyv35 := &x.Name
 46035  		yym36 := z.DecBinary()
 46036  		_ = yym36
 46037  		if false {
 46038  		} else {
 46039  			*((*string)(yyv35)) = r.DecodeString()
 46040  		}
 46041  	}
 46042  	yyj28++
 46043  	if yyhl28 {
 46044  		yyb28 = yyj28 > l
 46045  	} else {
 46046  		yyb28 = r.CheckBreak()
 46047  	}
 46048  	if yyb28 {
 46049  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46050  		return
 46051  	}
 46052  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46053  	if r.TryDecodeAsNil() {
 46054  		x.NodeClass = ""
 46055  	} else {
 46056  		yyv37 := &x.NodeClass
 46057  		yym38 := z.DecBinary()
 46058  		_ = yym38
 46059  		if false {
 46060  		} else {
 46061  			*((*string)(yyv37)) = r.DecodeString()
 46062  		}
 46063  	}
 46064  	yyj28++
 46065  	if yyhl28 {
 46066  		yyb28 = yyj28 > l
 46067  	} else {
 46068  		yyb28 = r.CheckBreak()
 46069  	}
 46070  	if yyb28 {
 46071  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46072  		return
 46073  	}
 46074  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46075  	if r.TryDecodeAsNil() {
 46076  		x.Version = ""
 46077  	} else {
 46078  		yyv39 := &x.Version
 46079  		yym40 := z.DecBinary()
 46080  		_ = yym40
 46081  		if false {
 46082  		} else {
 46083  			*((*string)(yyv39)) = r.DecodeString()
 46084  		}
 46085  	}
 46086  	yyj28++
 46087  	if yyhl28 {
 46088  		yyb28 = yyj28 > l
 46089  	} else {
 46090  		yyb28 = r.CheckBreak()
 46091  	}
 46092  	if yyb28 {
 46093  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46094  		return
 46095  	}
 46096  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46097  	if r.TryDecodeAsNil() {
 46098  		x.Drain = false
 46099  	} else {
 46100  		yyv41 := &x.Drain
 46101  		yym42 := z.DecBinary()
 46102  		_ = yym42
 46103  		if false {
 46104  		} else {
 46105  			*((*bool)(yyv41)) = r.DecodeBool()
 46106  		}
 46107  	}
 46108  	yyj28++
 46109  	if yyhl28 {
 46110  		yyb28 = yyj28 > l
 46111  	} else {
 46112  		yyb28 = r.CheckBreak()
 46113  	}
 46114  	if yyb28 {
 46115  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46116  		return
 46117  	}
 46118  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46119  	if r.TryDecodeAsNil() {
 46120  		x.SchedulingEligibility = ""
 46121  	} else {
 46122  		yyv43 := &x.SchedulingEligibility
 46123  		yym44 := z.DecBinary()
 46124  		_ = yym44
 46125  		if false {
 46126  		} else {
 46127  			*((*string)(yyv43)) = r.DecodeString()
 46128  		}
 46129  	}
 46130  	yyj28++
 46131  	if yyhl28 {
 46132  		yyb28 = yyj28 > l
 46133  	} else {
 46134  		yyb28 = r.CheckBreak()
 46135  	}
 46136  	if yyb28 {
 46137  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46138  		return
 46139  	}
 46140  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46141  	if r.TryDecodeAsNil() {
 46142  		x.Status = ""
 46143  	} else {
 46144  		yyv45 := &x.Status
 46145  		yym46 := z.DecBinary()
 46146  		_ = yym46
 46147  		if false {
 46148  		} else {
 46149  			*((*string)(yyv45)) = r.DecodeString()
 46150  		}
 46151  	}
 46152  	yyj28++
 46153  	if yyhl28 {
 46154  		yyb28 = yyj28 > l
 46155  	} else {
 46156  		yyb28 = r.CheckBreak()
 46157  	}
 46158  	if yyb28 {
 46159  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46160  		return
 46161  	}
 46162  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46163  	if r.TryDecodeAsNil() {
 46164  		x.StatusDescription = ""
 46165  	} else {
 46166  		yyv47 := &x.StatusDescription
 46167  		yym48 := z.DecBinary()
 46168  		_ = yym48
 46169  		if false {
 46170  		} else {
 46171  			*((*string)(yyv47)) = r.DecodeString()
 46172  		}
 46173  	}
 46174  	yyj28++
 46175  	if yyhl28 {
 46176  		yyb28 = yyj28 > l
 46177  	} else {
 46178  		yyb28 = r.CheckBreak()
 46179  	}
 46180  	if yyb28 {
 46181  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46182  		return
 46183  	}
 46184  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46185  	if r.TryDecodeAsNil() {
 46186  		x.CreateIndex = 0
 46187  	} else {
 46188  		yyv49 := &x.CreateIndex
 46189  		yym50 := z.DecBinary()
 46190  		_ = yym50
 46191  		if false {
 46192  		} else {
 46193  			*((*uint64)(yyv49)) = uint64(r.DecodeUint(64))
 46194  		}
 46195  	}
 46196  	yyj28++
 46197  	if yyhl28 {
 46198  		yyb28 = yyj28 > l
 46199  	} else {
 46200  		yyb28 = r.CheckBreak()
 46201  	}
 46202  	if yyb28 {
 46203  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46204  		return
 46205  	}
 46206  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46207  	if r.TryDecodeAsNil() {
 46208  		x.ModifyIndex = 0
 46209  	} else {
 46210  		yyv51 := &x.ModifyIndex
 46211  		yym52 := z.DecBinary()
 46212  		_ = yym52
 46213  		if false {
 46214  		} else {
 46215  			*((*uint64)(yyv51)) = uint64(r.DecodeUint(64))
 46216  		}
 46217  	}
 46218  	for {
 46219  		yyj28++
 46220  		if yyhl28 {
 46221  			yyb28 = yyj28 > l
 46222  		} else {
 46223  			yyb28 = r.CheckBreak()
 46224  		}
 46225  		if yyb28 {
 46226  			break
 46227  		}
 46228  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46229  		z.DecStructFieldNotFound(yyj28-1, "")
 46230  	}
 46231  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46232  }
 46233  
 46234  func (x Networks) CodecEncodeSelf(e *codec1978.Encoder) {
 46235  	var h codecSelfer100
 46236  	z, r := codec1978.GenHelperEncoder(e)
 46237  	_, _, _ = h, z, r
 46238  	if x == nil {
 46239  		r.EncodeNil()
 46240  	} else {
 46241  		yym1 := z.EncBinary()
 46242  		_ = yym1
 46243  		if false {
 46244  		} else if z.HasExtensions() && z.EncExt(x) {
 46245  		} else {
 46246  			h.encNetworks((Networks)(x), e)
 46247  		}
 46248  	}
 46249  }
 46250  
 46251  func (x *Networks) CodecDecodeSelf(d *codec1978.Decoder) {
 46252  	var h codecSelfer100
 46253  	z, r := codec1978.GenHelperDecoder(d)
 46254  	_, _, _ = h, z, r
 46255  	yym1 := z.DecBinary()
 46256  	_ = yym1
 46257  	if false {
 46258  	} else if z.HasExtensions() && z.DecExt(x) {
 46259  	} else {
 46260  		h.decNetworks((*Networks)(x), d)
 46261  	}
 46262  }
 46263  
 46264  func (x *Resources) CodecEncodeSelf(e *codec1978.Encoder) {
 46265  	var h codecSelfer100
 46266  	z, r := codec1978.GenHelperEncoder(e)
 46267  	_, _, _ = h, z, r
 46268  	if x == nil {
 46269  		r.EncodeNil()
 46270  	} else {
 46271  		yym1 := z.EncBinary()
 46272  		_ = yym1
 46273  		if false {
 46274  		} else if z.HasExtensions() && z.EncExt(x) {
 46275  		} else {
 46276  			yysep2 := !z.EncBinary()
 46277  			yy2arr2 := z.EncBasicHandle().StructToArray
 46278  			var yyq2 [5]bool
 46279  			_, _, _ = yysep2, yyq2, yy2arr2
 46280  			const yyr2 bool = false
 46281  			var yynn2 int
 46282  			if yyr2 || yy2arr2 {
 46283  				r.EncodeArrayStart(5)
 46284  			} else {
 46285  				yynn2 = 5
 46286  				for _, b := range yyq2 {
 46287  					if b {
 46288  						yynn2++
 46289  					}
 46290  				}
 46291  				r.EncodeMapStart(yynn2)
 46292  				yynn2 = 0
 46293  			}
 46294  			if yyr2 || yy2arr2 {
 46295  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 46296  				yym4 := z.EncBinary()
 46297  				_ = yym4
 46298  				if false {
 46299  				} else {
 46300  					r.EncodeInt(int64(x.CPU))
 46301  				}
 46302  			} else {
 46303  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 46304  				r.EncodeString(codecSelferC_UTF8100, string("CPU"))
 46305  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 46306  				yym5 := z.EncBinary()
 46307  				_ = yym5
 46308  				if false {
 46309  				} else {
 46310  					r.EncodeInt(int64(x.CPU))
 46311  				}
 46312  			}
 46313  			if yyr2 || yy2arr2 {
 46314  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 46315  				yym7 := z.EncBinary()
 46316  				_ = yym7
 46317  				if false {
 46318  				} else {
 46319  					r.EncodeInt(int64(x.MemoryMB))
 46320  				}
 46321  			} else {
 46322  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 46323  				r.EncodeString(codecSelferC_UTF8100, string("MemoryMB"))
 46324  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 46325  				yym8 := z.EncBinary()
 46326  				_ = yym8
 46327  				if false {
 46328  				} else {
 46329  					r.EncodeInt(int64(x.MemoryMB))
 46330  				}
 46331  			}
 46332  			if yyr2 || yy2arr2 {
 46333  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 46334  				yym10 := z.EncBinary()
 46335  				_ = yym10
 46336  				if false {
 46337  				} else {
 46338  					r.EncodeInt(int64(x.DiskMB))
 46339  				}
 46340  			} else {
 46341  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 46342  				r.EncodeString(codecSelferC_UTF8100, string("DiskMB"))
 46343  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 46344  				yym11 := z.EncBinary()
 46345  				_ = yym11
 46346  				if false {
 46347  				} else {
 46348  					r.EncodeInt(int64(x.DiskMB))
 46349  				}
 46350  			}
 46351  			if yyr2 || yy2arr2 {
 46352  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 46353  				yym13 := z.EncBinary()
 46354  				_ = yym13
 46355  				if false {
 46356  				} else {
 46357  					r.EncodeInt(int64(x.IOPS))
 46358  				}
 46359  			} else {
 46360  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 46361  				r.EncodeString(codecSelferC_UTF8100, string("IOPS"))
 46362  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 46363  				yym14 := z.EncBinary()
 46364  				_ = yym14
 46365  				if false {
 46366  				} else {
 46367  					r.EncodeInt(int64(x.IOPS))
 46368  				}
 46369  			}
 46370  			if yyr2 || yy2arr2 {
 46371  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 46372  				if x.Networks == nil {
 46373  					r.EncodeNil()
 46374  				} else {
 46375  					x.Networks.CodecEncodeSelf(e)
 46376  				}
 46377  			} else {
 46378  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 46379  				r.EncodeString(codecSelferC_UTF8100, string("Networks"))
 46380  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 46381  				if x.Networks == nil {
 46382  					r.EncodeNil()
 46383  				} else {
 46384  					x.Networks.CodecEncodeSelf(e)
 46385  				}
 46386  			}
 46387  			if yyr2 || yy2arr2 {
 46388  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 46389  			} else {
 46390  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 46391  			}
 46392  		}
 46393  	}
 46394  }
 46395  
 46396  func (x *Resources) CodecDecodeSelf(d *codec1978.Decoder) {
 46397  	var h codecSelfer100
 46398  	z, r := codec1978.GenHelperDecoder(d)
 46399  	_, _, _ = h, z, r
 46400  	yym1 := z.DecBinary()
 46401  	_ = yym1
 46402  	if false {
 46403  	} else if z.HasExtensions() && z.DecExt(x) {
 46404  	} else {
 46405  		yyct2 := r.ContainerType()
 46406  		if yyct2 == codecSelferValueTypeMap100 {
 46407  			yyl2 := r.ReadMapStart()
 46408  			if yyl2 == 0 {
 46409  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 46410  			} else {
 46411  				x.codecDecodeSelfFromMap(yyl2, d)
 46412  			}
 46413  		} else if yyct2 == codecSelferValueTypeArray100 {
 46414  			yyl2 := r.ReadArrayStart()
 46415  			if yyl2 == 0 {
 46416  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46417  			} else {
 46418  				x.codecDecodeSelfFromArray(yyl2, d)
 46419  			}
 46420  		} else {
 46421  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 46422  		}
 46423  	}
 46424  }
 46425  
 46426  func (x *Resources) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 46427  	var h codecSelfer100
 46428  	z, r := codec1978.GenHelperDecoder(d)
 46429  	_, _, _ = h, z, r
 46430  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 46431  	_ = yys3Slc
 46432  	var yyhl3 bool = l >= 0
 46433  	for yyj3 := 0; ; yyj3++ {
 46434  		if yyhl3 {
 46435  			if yyj3 >= l {
 46436  				break
 46437  			}
 46438  		} else {
 46439  			if r.CheckBreak() {
 46440  				break
 46441  			}
 46442  		}
 46443  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 46444  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 46445  		yys3 := string(yys3Slc)
 46446  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 46447  		switch yys3 {
 46448  		case "CPU":
 46449  			if r.TryDecodeAsNil() {
 46450  				x.CPU = 0
 46451  			} else {
 46452  				yyv4 := &x.CPU
 46453  				yym5 := z.DecBinary()
 46454  				_ = yym5
 46455  				if false {
 46456  				} else {
 46457  					*((*int)(yyv4)) = int(r.DecodeInt(codecSelferBitsize100))
 46458  				}
 46459  			}
 46460  		case "MemoryMB":
 46461  			if r.TryDecodeAsNil() {
 46462  				x.MemoryMB = 0
 46463  			} else {
 46464  				yyv6 := &x.MemoryMB
 46465  				yym7 := z.DecBinary()
 46466  				_ = yym7
 46467  				if false {
 46468  				} else {
 46469  					*((*int)(yyv6)) = int(r.DecodeInt(codecSelferBitsize100))
 46470  				}
 46471  			}
 46472  		case "DiskMB":
 46473  			if r.TryDecodeAsNil() {
 46474  				x.DiskMB = 0
 46475  			} else {
 46476  				yyv8 := &x.DiskMB
 46477  				yym9 := z.DecBinary()
 46478  				_ = yym9
 46479  				if false {
 46480  				} else {
 46481  					*((*int)(yyv8)) = int(r.DecodeInt(codecSelferBitsize100))
 46482  				}
 46483  			}
 46484  		case "IOPS":
 46485  			if r.TryDecodeAsNil() {
 46486  				x.IOPS = 0
 46487  			} else {
 46488  				yyv10 := &x.IOPS
 46489  				yym11 := z.DecBinary()
 46490  				_ = yym11
 46491  				if false {
 46492  				} else {
 46493  					*((*int)(yyv10)) = int(r.DecodeInt(codecSelferBitsize100))
 46494  				}
 46495  			}
 46496  		case "Networks":
 46497  			if r.TryDecodeAsNil() {
 46498  				x.Networks = nil
 46499  			} else {
 46500  				yyv12 := &x.Networks
 46501  				yyv12.CodecDecodeSelf(d)
 46502  			}
 46503  		default:
 46504  			z.DecStructFieldNotFound(-1, yys3)
 46505  		} // end switch yys3
 46506  	} // end for yyj3
 46507  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 46508  }
 46509  
 46510  func (x *Resources) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 46511  	var h codecSelfer100
 46512  	z, r := codec1978.GenHelperDecoder(d)
 46513  	_, _, _ = h, z, r
 46514  	var yyj13 int
 46515  	var yyb13 bool
 46516  	var yyhl13 bool = l >= 0
 46517  	yyj13++
 46518  	if yyhl13 {
 46519  		yyb13 = yyj13 > l
 46520  	} else {
 46521  		yyb13 = r.CheckBreak()
 46522  	}
 46523  	if yyb13 {
 46524  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46525  		return
 46526  	}
 46527  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46528  	if r.TryDecodeAsNil() {
 46529  		x.CPU = 0
 46530  	} else {
 46531  		yyv14 := &x.CPU
 46532  		yym15 := z.DecBinary()
 46533  		_ = yym15
 46534  		if false {
 46535  		} else {
 46536  			*((*int)(yyv14)) = int(r.DecodeInt(codecSelferBitsize100))
 46537  		}
 46538  	}
 46539  	yyj13++
 46540  	if yyhl13 {
 46541  		yyb13 = yyj13 > l
 46542  	} else {
 46543  		yyb13 = r.CheckBreak()
 46544  	}
 46545  	if yyb13 {
 46546  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46547  		return
 46548  	}
 46549  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46550  	if r.TryDecodeAsNil() {
 46551  		x.MemoryMB = 0
 46552  	} else {
 46553  		yyv16 := &x.MemoryMB
 46554  		yym17 := z.DecBinary()
 46555  		_ = yym17
 46556  		if false {
 46557  		} else {
 46558  			*((*int)(yyv16)) = int(r.DecodeInt(codecSelferBitsize100))
 46559  		}
 46560  	}
 46561  	yyj13++
 46562  	if yyhl13 {
 46563  		yyb13 = yyj13 > l
 46564  	} else {
 46565  		yyb13 = r.CheckBreak()
 46566  	}
 46567  	if yyb13 {
 46568  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46569  		return
 46570  	}
 46571  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46572  	if r.TryDecodeAsNil() {
 46573  		x.DiskMB = 0
 46574  	} else {
 46575  		yyv18 := &x.DiskMB
 46576  		yym19 := z.DecBinary()
 46577  		_ = yym19
 46578  		if false {
 46579  		} else {
 46580  			*((*int)(yyv18)) = int(r.DecodeInt(codecSelferBitsize100))
 46581  		}
 46582  	}
 46583  	yyj13++
 46584  	if yyhl13 {
 46585  		yyb13 = yyj13 > l
 46586  	} else {
 46587  		yyb13 = r.CheckBreak()
 46588  	}
 46589  	if yyb13 {
 46590  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46591  		return
 46592  	}
 46593  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46594  	if r.TryDecodeAsNil() {
 46595  		x.IOPS = 0
 46596  	} else {
 46597  		yyv20 := &x.IOPS
 46598  		yym21 := z.DecBinary()
 46599  		_ = yym21
 46600  		if false {
 46601  		} else {
 46602  			*((*int)(yyv20)) = int(r.DecodeInt(codecSelferBitsize100))
 46603  		}
 46604  	}
 46605  	yyj13++
 46606  	if yyhl13 {
 46607  		yyb13 = yyj13 > l
 46608  	} else {
 46609  		yyb13 = r.CheckBreak()
 46610  	}
 46611  	if yyb13 {
 46612  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46613  		return
 46614  	}
 46615  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46616  	if r.TryDecodeAsNil() {
 46617  		x.Networks = nil
 46618  	} else {
 46619  		yyv22 := &x.Networks
 46620  		yyv22.CodecDecodeSelf(d)
 46621  	}
 46622  	for {
 46623  		yyj13++
 46624  		if yyhl13 {
 46625  			yyb13 = yyj13 > l
 46626  		} else {
 46627  			yyb13 = r.CheckBreak()
 46628  		}
 46629  		if yyb13 {
 46630  			break
 46631  		}
 46632  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46633  		z.DecStructFieldNotFound(yyj13-1, "")
 46634  	}
 46635  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46636  }
 46637  
 46638  func (x *Port) CodecEncodeSelf(e *codec1978.Encoder) {
 46639  	var h codecSelfer100
 46640  	z, r := codec1978.GenHelperEncoder(e)
 46641  	_, _, _ = h, z, r
 46642  	if x == nil {
 46643  		r.EncodeNil()
 46644  	} else {
 46645  		yym1 := z.EncBinary()
 46646  		_ = yym1
 46647  		if false {
 46648  		} else if z.HasExtensions() && z.EncExt(x) {
 46649  		} else {
 46650  			yysep2 := !z.EncBinary()
 46651  			yy2arr2 := z.EncBasicHandle().StructToArray
 46652  			var yyq2 [2]bool
 46653  			_, _, _ = yysep2, yyq2, yy2arr2
 46654  			const yyr2 bool = false
 46655  			var yynn2 int
 46656  			if yyr2 || yy2arr2 {
 46657  				r.EncodeArrayStart(2)
 46658  			} else {
 46659  				yynn2 = 2
 46660  				for _, b := range yyq2 {
 46661  					if b {
 46662  						yynn2++
 46663  					}
 46664  				}
 46665  				r.EncodeMapStart(yynn2)
 46666  				yynn2 = 0
 46667  			}
 46668  			if yyr2 || yy2arr2 {
 46669  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 46670  				yym4 := z.EncBinary()
 46671  				_ = yym4
 46672  				if false {
 46673  				} else {
 46674  					r.EncodeString(codecSelferC_UTF8100, string(x.Label))
 46675  				}
 46676  			} else {
 46677  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 46678  				r.EncodeString(codecSelferC_UTF8100, string("Label"))
 46679  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 46680  				yym5 := z.EncBinary()
 46681  				_ = yym5
 46682  				if false {
 46683  				} else {
 46684  					r.EncodeString(codecSelferC_UTF8100, string(x.Label))
 46685  				}
 46686  			}
 46687  			if yyr2 || yy2arr2 {
 46688  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 46689  				yym7 := z.EncBinary()
 46690  				_ = yym7
 46691  				if false {
 46692  				} else {
 46693  					r.EncodeInt(int64(x.Value))
 46694  				}
 46695  			} else {
 46696  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 46697  				r.EncodeString(codecSelferC_UTF8100, string("Value"))
 46698  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 46699  				yym8 := z.EncBinary()
 46700  				_ = yym8
 46701  				if false {
 46702  				} else {
 46703  					r.EncodeInt(int64(x.Value))
 46704  				}
 46705  			}
 46706  			if yyr2 || yy2arr2 {
 46707  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 46708  			} else {
 46709  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 46710  			}
 46711  		}
 46712  	}
 46713  }
 46714  
 46715  func (x *Port) CodecDecodeSelf(d *codec1978.Decoder) {
 46716  	var h codecSelfer100
 46717  	z, r := codec1978.GenHelperDecoder(d)
 46718  	_, _, _ = h, z, r
 46719  	yym1 := z.DecBinary()
 46720  	_ = yym1
 46721  	if false {
 46722  	} else if z.HasExtensions() && z.DecExt(x) {
 46723  	} else {
 46724  		yyct2 := r.ContainerType()
 46725  		if yyct2 == codecSelferValueTypeMap100 {
 46726  			yyl2 := r.ReadMapStart()
 46727  			if yyl2 == 0 {
 46728  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 46729  			} else {
 46730  				x.codecDecodeSelfFromMap(yyl2, d)
 46731  			}
 46732  		} else if yyct2 == codecSelferValueTypeArray100 {
 46733  			yyl2 := r.ReadArrayStart()
 46734  			if yyl2 == 0 {
 46735  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46736  			} else {
 46737  				x.codecDecodeSelfFromArray(yyl2, d)
 46738  			}
 46739  		} else {
 46740  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 46741  		}
 46742  	}
 46743  }
 46744  
 46745  func (x *Port) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 46746  	var h codecSelfer100
 46747  	z, r := codec1978.GenHelperDecoder(d)
 46748  	_, _, _ = h, z, r
 46749  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 46750  	_ = yys3Slc
 46751  	var yyhl3 bool = l >= 0
 46752  	for yyj3 := 0; ; yyj3++ {
 46753  		if yyhl3 {
 46754  			if yyj3 >= l {
 46755  				break
 46756  			}
 46757  		} else {
 46758  			if r.CheckBreak() {
 46759  				break
 46760  			}
 46761  		}
 46762  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 46763  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 46764  		yys3 := string(yys3Slc)
 46765  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 46766  		switch yys3 {
 46767  		case "Label":
 46768  			if r.TryDecodeAsNil() {
 46769  				x.Label = ""
 46770  			} else {
 46771  				yyv4 := &x.Label
 46772  				yym5 := z.DecBinary()
 46773  				_ = yym5
 46774  				if false {
 46775  				} else {
 46776  					*((*string)(yyv4)) = r.DecodeString()
 46777  				}
 46778  			}
 46779  		case "Value":
 46780  			if r.TryDecodeAsNil() {
 46781  				x.Value = 0
 46782  			} else {
 46783  				yyv6 := &x.Value
 46784  				yym7 := z.DecBinary()
 46785  				_ = yym7
 46786  				if false {
 46787  				} else {
 46788  					*((*int)(yyv6)) = int(r.DecodeInt(codecSelferBitsize100))
 46789  				}
 46790  			}
 46791  		default:
 46792  			z.DecStructFieldNotFound(-1, yys3)
 46793  		} // end switch yys3
 46794  	} // end for yyj3
 46795  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 46796  }
 46797  
 46798  func (x *Port) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 46799  	var h codecSelfer100
 46800  	z, r := codec1978.GenHelperDecoder(d)
 46801  	_, _, _ = h, z, r
 46802  	var yyj8 int
 46803  	var yyb8 bool
 46804  	var yyhl8 bool = l >= 0
 46805  	yyj8++
 46806  	if yyhl8 {
 46807  		yyb8 = yyj8 > l
 46808  	} else {
 46809  		yyb8 = r.CheckBreak()
 46810  	}
 46811  	if yyb8 {
 46812  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46813  		return
 46814  	}
 46815  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46816  	if r.TryDecodeAsNil() {
 46817  		x.Label = ""
 46818  	} else {
 46819  		yyv9 := &x.Label
 46820  		yym10 := z.DecBinary()
 46821  		_ = yym10
 46822  		if false {
 46823  		} else {
 46824  			*((*string)(yyv9)) = r.DecodeString()
 46825  		}
 46826  	}
 46827  	yyj8++
 46828  	if yyhl8 {
 46829  		yyb8 = yyj8 > l
 46830  	} else {
 46831  		yyb8 = r.CheckBreak()
 46832  	}
 46833  	if yyb8 {
 46834  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46835  		return
 46836  	}
 46837  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46838  	if r.TryDecodeAsNil() {
 46839  		x.Value = 0
 46840  	} else {
 46841  		yyv11 := &x.Value
 46842  		yym12 := z.DecBinary()
 46843  		_ = yym12
 46844  		if false {
 46845  		} else {
 46846  			*((*int)(yyv11)) = int(r.DecodeInt(codecSelferBitsize100))
 46847  		}
 46848  	}
 46849  	for {
 46850  		yyj8++
 46851  		if yyhl8 {
 46852  			yyb8 = yyj8 > l
 46853  		} else {
 46854  			yyb8 = r.CheckBreak()
 46855  		}
 46856  		if yyb8 {
 46857  			break
 46858  		}
 46859  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 46860  		z.DecStructFieldNotFound(yyj8-1, "")
 46861  	}
 46862  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 46863  }
 46864  
 46865  func (x *NetworkResource) CodecEncodeSelf(e *codec1978.Encoder) {
 46866  	var h codecSelfer100
 46867  	z, r := codec1978.GenHelperEncoder(e)
 46868  	_, _, _ = h, z, r
 46869  	if x == nil {
 46870  		r.EncodeNil()
 46871  	} else {
 46872  		yym1 := z.EncBinary()
 46873  		_ = yym1
 46874  		if false {
 46875  		} else if z.HasExtensions() && z.EncExt(x) {
 46876  		} else {
 46877  			yysep2 := !z.EncBinary()
 46878  			yy2arr2 := z.EncBasicHandle().StructToArray
 46879  			var yyq2 [6]bool
 46880  			_, _, _ = yysep2, yyq2, yy2arr2
 46881  			const yyr2 bool = false
 46882  			var yynn2 int
 46883  			if yyr2 || yy2arr2 {
 46884  				r.EncodeArrayStart(6)
 46885  			} else {
 46886  				yynn2 = 6
 46887  				for _, b := range yyq2 {
 46888  					if b {
 46889  						yynn2++
 46890  					}
 46891  				}
 46892  				r.EncodeMapStart(yynn2)
 46893  				yynn2 = 0
 46894  			}
 46895  			if yyr2 || yy2arr2 {
 46896  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 46897  				yym4 := z.EncBinary()
 46898  				_ = yym4
 46899  				if false {
 46900  				} else {
 46901  					r.EncodeString(codecSelferC_UTF8100, string(x.Device))
 46902  				}
 46903  			} else {
 46904  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 46905  				r.EncodeString(codecSelferC_UTF8100, string("Device"))
 46906  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 46907  				yym5 := z.EncBinary()
 46908  				_ = yym5
 46909  				if false {
 46910  				} else {
 46911  					r.EncodeString(codecSelferC_UTF8100, string(x.Device))
 46912  				}
 46913  			}
 46914  			if yyr2 || yy2arr2 {
 46915  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 46916  				yym7 := z.EncBinary()
 46917  				_ = yym7
 46918  				if false {
 46919  				} else {
 46920  					r.EncodeString(codecSelferC_UTF8100, string(x.CIDR))
 46921  				}
 46922  			} else {
 46923  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 46924  				r.EncodeString(codecSelferC_UTF8100, string("CIDR"))
 46925  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 46926  				yym8 := z.EncBinary()
 46927  				_ = yym8
 46928  				if false {
 46929  				} else {
 46930  					r.EncodeString(codecSelferC_UTF8100, string(x.CIDR))
 46931  				}
 46932  			}
 46933  			if yyr2 || yy2arr2 {
 46934  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 46935  				yym10 := z.EncBinary()
 46936  				_ = yym10
 46937  				if false {
 46938  				} else {
 46939  					r.EncodeString(codecSelferC_UTF8100, string(x.IP))
 46940  				}
 46941  			} else {
 46942  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 46943  				r.EncodeString(codecSelferC_UTF8100, string("IP"))
 46944  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 46945  				yym11 := z.EncBinary()
 46946  				_ = yym11
 46947  				if false {
 46948  				} else {
 46949  					r.EncodeString(codecSelferC_UTF8100, string(x.IP))
 46950  				}
 46951  			}
 46952  			if yyr2 || yy2arr2 {
 46953  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 46954  				yym13 := z.EncBinary()
 46955  				_ = yym13
 46956  				if false {
 46957  				} else {
 46958  					r.EncodeInt(int64(x.MBits))
 46959  				}
 46960  			} else {
 46961  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 46962  				r.EncodeString(codecSelferC_UTF8100, string("MBits"))
 46963  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 46964  				yym14 := z.EncBinary()
 46965  				_ = yym14
 46966  				if false {
 46967  				} else {
 46968  					r.EncodeInt(int64(x.MBits))
 46969  				}
 46970  			}
 46971  			if yyr2 || yy2arr2 {
 46972  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 46973  				if x.ReservedPorts == nil {
 46974  					r.EncodeNil()
 46975  				} else {
 46976  					yym16 := z.EncBinary()
 46977  					_ = yym16
 46978  					if false {
 46979  					} else {
 46980  						h.encSlicePort(([]Port)(x.ReservedPorts), e)
 46981  					}
 46982  				}
 46983  			} else {
 46984  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 46985  				r.EncodeString(codecSelferC_UTF8100, string("ReservedPorts"))
 46986  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 46987  				if x.ReservedPorts == nil {
 46988  					r.EncodeNil()
 46989  				} else {
 46990  					yym17 := z.EncBinary()
 46991  					_ = yym17
 46992  					if false {
 46993  					} else {
 46994  						h.encSlicePort(([]Port)(x.ReservedPorts), e)
 46995  					}
 46996  				}
 46997  			}
 46998  			if yyr2 || yy2arr2 {
 46999  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47000  				if x.DynamicPorts == nil {
 47001  					r.EncodeNil()
 47002  				} else {
 47003  					yym19 := z.EncBinary()
 47004  					_ = yym19
 47005  					if false {
 47006  					} else {
 47007  						h.encSlicePort(([]Port)(x.DynamicPorts), e)
 47008  					}
 47009  				}
 47010  			} else {
 47011  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47012  				r.EncodeString(codecSelferC_UTF8100, string("DynamicPorts"))
 47013  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47014  				if x.DynamicPorts == nil {
 47015  					r.EncodeNil()
 47016  				} else {
 47017  					yym20 := z.EncBinary()
 47018  					_ = yym20
 47019  					if false {
 47020  					} else {
 47021  						h.encSlicePort(([]Port)(x.DynamicPorts), e)
 47022  					}
 47023  				}
 47024  			}
 47025  			if yyr2 || yy2arr2 {
 47026  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 47027  			} else {
 47028  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 47029  			}
 47030  		}
 47031  	}
 47032  }
 47033  
 47034  func (x *NetworkResource) CodecDecodeSelf(d *codec1978.Decoder) {
 47035  	var h codecSelfer100
 47036  	z, r := codec1978.GenHelperDecoder(d)
 47037  	_, _, _ = h, z, r
 47038  	yym1 := z.DecBinary()
 47039  	_ = yym1
 47040  	if false {
 47041  	} else if z.HasExtensions() && z.DecExt(x) {
 47042  	} else {
 47043  		yyct2 := r.ContainerType()
 47044  		if yyct2 == codecSelferValueTypeMap100 {
 47045  			yyl2 := r.ReadMapStart()
 47046  			if yyl2 == 0 {
 47047  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 47048  			} else {
 47049  				x.codecDecodeSelfFromMap(yyl2, d)
 47050  			}
 47051  		} else if yyct2 == codecSelferValueTypeArray100 {
 47052  			yyl2 := r.ReadArrayStart()
 47053  			if yyl2 == 0 {
 47054  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 47055  			} else {
 47056  				x.codecDecodeSelfFromArray(yyl2, d)
 47057  			}
 47058  		} else {
 47059  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 47060  		}
 47061  	}
 47062  }
 47063  
 47064  func (x *NetworkResource) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 47065  	var h codecSelfer100
 47066  	z, r := codec1978.GenHelperDecoder(d)
 47067  	_, _, _ = h, z, r
 47068  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 47069  	_ = yys3Slc
 47070  	var yyhl3 bool = l >= 0
 47071  	for yyj3 := 0; ; yyj3++ {
 47072  		if yyhl3 {
 47073  			if yyj3 >= l {
 47074  				break
 47075  			}
 47076  		} else {
 47077  			if r.CheckBreak() {
 47078  				break
 47079  			}
 47080  		}
 47081  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 47082  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 47083  		yys3 := string(yys3Slc)
 47084  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 47085  		switch yys3 {
 47086  		case "Device":
 47087  			if r.TryDecodeAsNil() {
 47088  				x.Device = ""
 47089  			} else {
 47090  				yyv4 := &x.Device
 47091  				yym5 := z.DecBinary()
 47092  				_ = yym5
 47093  				if false {
 47094  				} else {
 47095  					*((*string)(yyv4)) = r.DecodeString()
 47096  				}
 47097  			}
 47098  		case "CIDR":
 47099  			if r.TryDecodeAsNil() {
 47100  				x.CIDR = ""
 47101  			} else {
 47102  				yyv6 := &x.CIDR
 47103  				yym7 := z.DecBinary()
 47104  				_ = yym7
 47105  				if false {
 47106  				} else {
 47107  					*((*string)(yyv6)) = r.DecodeString()
 47108  				}
 47109  			}
 47110  		case "IP":
 47111  			if r.TryDecodeAsNil() {
 47112  				x.IP = ""
 47113  			} else {
 47114  				yyv8 := &x.IP
 47115  				yym9 := z.DecBinary()
 47116  				_ = yym9
 47117  				if false {
 47118  				} else {
 47119  					*((*string)(yyv8)) = r.DecodeString()
 47120  				}
 47121  			}
 47122  		case "MBits":
 47123  			if r.TryDecodeAsNil() {
 47124  				x.MBits = 0
 47125  			} else {
 47126  				yyv10 := &x.MBits
 47127  				yym11 := z.DecBinary()
 47128  				_ = yym11
 47129  				if false {
 47130  				} else {
 47131  					*((*int)(yyv10)) = int(r.DecodeInt(codecSelferBitsize100))
 47132  				}
 47133  			}
 47134  		case "ReservedPorts":
 47135  			if r.TryDecodeAsNil() {
 47136  				x.ReservedPorts = nil
 47137  			} else {
 47138  				yyv12 := &x.ReservedPorts
 47139  				yym13 := z.DecBinary()
 47140  				_ = yym13
 47141  				if false {
 47142  				} else {
 47143  					h.decSlicePort((*[]Port)(yyv12), d)
 47144  				}
 47145  			}
 47146  		case "DynamicPorts":
 47147  			if r.TryDecodeAsNil() {
 47148  				x.DynamicPorts = nil
 47149  			} else {
 47150  				yyv14 := &x.DynamicPorts
 47151  				yym15 := z.DecBinary()
 47152  				_ = yym15
 47153  				if false {
 47154  				} else {
 47155  					h.decSlicePort((*[]Port)(yyv14), d)
 47156  				}
 47157  			}
 47158  		default:
 47159  			z.DecStructFieldNotFound(-1, yys3)
 47160  		} // end switch yys3
 47161  	} // end for yyj3
 47162  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 47163  }
 47164  
 47165  func (x *NetworkResource) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 47166  	var h codecSelfer100
 47167  	z, r := codec1978.GenHelperDecoder(d)
 47168  	_, _, _ = h, z, r
 47169  	var yyj16 int
 47170  	var yyb16 bool
 47171  	var yyhl16 bool = l >= 0
 47172  	yyj16++
 47173  	if yyhl16 {
 47174  		yyb16 = yyj16 > l
 47175  	} else {
 47176  		yyb16 = r.CheckBreak()
 47177  	}
 47178  	if yyb16 {
 47179  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 47180  		return
 47181  	}
 47182  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 47183  	if r.TryDecodeAsNil() {
 47184  		x.Device = ""
 47185  	} else {
 47186  		yyv17 := &x.Device
 47187  		yym18 := z.DecBinary()
 47188  		_ = yym18
 47189  		if false {
 47190  		} else {
 47191  			*((*string)(yyv17)) = r.DecodeString()
 47192  		}
 47193  	}
 47194  	yyj16++
 47195  	if yyhl16 {
 47196  		yyb16 = yyj16 > l
 47197  	} else {
 47198  		yyb16 = r.CheckBreak()
 47199  	}
 47200  	if yyb16 {
 47201  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 47202  		return
 47203  	}
 47204  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 47205  	if r.TryDecodeAsNil() {
 47206  		x.CIDR = ""
 47207  	} else {
 47208  		yyv19 := &x.CIDR
 47209  		yym20 := z.DecBinary()
 47210  		_ = yym20
 47211  		if false {
 47212  		} else {
 47213  			*((*string)(yyv19)) = r.DecodeString()
 47214  		}
 47215  	}
 47216  	yyj16++
 47217  	if yyhl16 {
 47218  		yyb16 = yyj16 > l
 47219  	} else {
 47220  		yyb16 = r.CheckBreak()
 47221  	}
 47222  	if yyb16 {
 47223  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 47224  		return
 47225  	}
 47226  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 47227  	if r.TryDecodeAsNil() {
 47228  		x.IP = ""
 47229  	} else {
 47230  		yyv21 := &x.IP
 47231  		yym22 := z.DecBinary()
 47232  		_ = yym22
 47233  		if false {
 47234  		} else {
 47235  			*((*string)(yyv21)) = r.DecodeString()
 47236  		}
 47237  	}
 47238  	yyj16++
 47239  	if yyhl16 {
 47240  		yyb16 = yyj16 > l
 47241  	} else {
 47242  		yyb16 = r.CheckBreak()
 47243  	}
 47244  	if yyb16 {
 47245  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 47246  		return
 47247  	}
 47248  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 47249  	if r.TryDecodeAsNil() {
 47250  		x.MBits = 0
 47251  	} else {
 47252  		yyv23 := &x.MBits
 47253  		yym24 := z.DecBinary()
 47254  		_ = yym24
 47255  		if false {
 47256  		} else {
 47257  			*((*int)(yyv23)) = int(r.DecodeInt(codecSelferBitsize100))
 47258  		}
 47259  	}
 47260  	yyj16++
 47261  	if yyhl16 {
 47262  		yyb16 = yyj16 > l
 47263  	} else {
 47264  		yyb16 = r.CheckBreak()
 47265  	}
 47266  	if yyb16 {
 47267  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 47268  		return
 47269  	}
 47270  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 47271  	if r.TryDecodeAsNil() {
 47272  		x.ReservedPorts = nil
 47273  	} else {
 47274  		yyv25 := &x.ReservedPorts
 47275  		yym26 := z.DecBinary()
 47276  		_ = yym26
 47277  		if false {
 47278  		} else {
 47279  			h.decSlicePort((*[]Port)(yyv25), d)
 47280  		}
 47281  	}
 47282  	yyj16++
 47283  	if yyhl16 {
 47284  		yyb16 = yyj16 > l
 47285  	} else {
 47286  		yyb16 = r.CheckBreak()
 47287  	}
 47288  	if yyb16 {
 47289  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 47290  		return
 47291  	}
 47292  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 47293  	if r.TryDecodeAsNil() {
 47294  		x.DynamicPorts = nil
 47295  	} else {
 47296  		yyv27 := &x.DynamicPorts
 47297  		yym28 := z.DecBinary()
 47298  		_ = yym28
 47299  		if false {
 47300  		} else {
 47301  			h.decSlicePort((*[]Port)(yyv27), d)
 47302  		}
 47303  	}
 47304  	for {
 47305  		yyj16++
 47306  		if yyhl16 {
 47307  			yyb16 = yyj16 > l
 47308  		} else {
 47309  			yyb16 = r.CheckBreak()
 47310  		}
 47311  		if yyb16 {
 47312  			break
 47313  		}
 47314  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 47315  		z.DecStructFieldNotFound(yyj16-1, "")
 47316  	}
 47317  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 47318  }
 47319  
 47320  func (x *Job) CodecEncodeSelf(e *codec1978.Encoder) {
 47321  	var h codecSelfer100
 47322  	z, r := codec1978.GenHelperEncoder(e)
 47323  	_, _, _ = h, z, r
 47324  	if x == nil {
 47325  		r.EncodeNil()
 47326  	} else {
 47327  		yym1 := z.EncBinary()
 47328  		_ = yym1
 47329  		if false {
 47330  		} else if z.HasExtensions() && z.EncExt(x) {
 47331  		} else {
 47332  			yysep2 := !z.EncBinary()
 47333  			yy2arr2 := z.EncBasicHandle().StructToArray
 47334  			var yyq2 [26]bool
 47335  			_, _, _ = yysep2, yyq2, yy2arr2
 47336  			const yyr2 bool = false
 47337  			var yynn2 int
 47338  			if yyr2 || yy2arr2 {
 47339  				r.EncodeArrayStart(26)
 47340  			} else {
 47341  				yynn2 = 26
 47342  				for _, b := range yyq2 {
 47343  					if b {
 47344  						yynn2++
 47345  					}
 47346  				}
 47347  				r.EncodeMapStart(yynn2)
 47348  				yynn2 = 0
 47349  			}
 47350  			if yyr2 || yy2arr2 {
 47351  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47352  				yym4 := z.EncBinary()
 47353  				_ = yym4
 47354  				if false {
 47355  				} else {
 47356  					r.EncodeBool(bool(x.Stop))
 47357  				}
 47358  			} else {
 47359  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47360  				r.EncodeString(codecSelferC_UTF8100, string("Stop"))
 47361  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47362  				yym5 := z.EncBinary()
 47363  				_ = yym5
 47364  				if false {
 47365  				} else {
 47366  					r.EncodeBool(bool(x.Stop))
 47367  				}
 47368  			}
 47369  			if yyr2 || yy2arr2 {
 47370  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47371  				yym7 := z.EncBinary()
 47372  				_ = yym7
 47373  				if false {
 47374  				} else {
 47375  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 47376  				}
 47377  			} else {
 47378  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47379  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 47380  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47381  				yym8 := z.EncBinary()
 47382  				_ = yym8
 47383  				if false {
 47384  				} else {
 47385  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 47386  				}
 47387  			}
 47388  			if yyr2 || yy2arr2 {
 47389  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47390  				yym10 := z.EncBinary()
 47391  				_ = yym10
 47392  				if false {
 47393  				} else {
 47394  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 47395  				}
 47396  			} else {
 47397  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47398  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 47399  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47400  				yym11 := z.EncBinary()
 47401  				_ = yym11
 47402  				if false {
 47403  				} else {
 47404  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 47405  				}
 47406  			}
 47407  			if yyr2 || yy2arr2 {
 47408  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47409  				yym13 := z.EncBinary()
 47410  				_ = yym13
 47411  				if false {
 47412  				} else {
 47413  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 47414  				}
 47415  			} else {
 47416  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47417  				r.EncodeString(codecSelferC_UTF8100, string("ID"))
 47418  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47419  				yym14 := z.EncBinary()
 47420  				_ = yym14
 47421  				if false {
 47422  				} else {
 47423  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 47424  				}
 47425  			}
 47426  			if yyr2 || yy2arr2 {
 47427  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47428  				yym16 := z.EncBinary()
 47429  				_ = yym16
 47430  				if false {
 47431  				} else {
 47432  					r.EncodeString(codecSelferC_UTF8100, string(x.ParentID))
 47433  				}
 47434  			} else {
 47435  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47436  				r.EncodeString(codecSelferC_UTF8100, string("ParentID"))
 47437  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47438  				yym17 := z.EncBinary()
 47439  				_ = yym17
 47440  				if false {
 47441  				} else {
 47442  					r.EncodeString(codecSelferC_UTF8100, string(x.ParentID))
 47443  				}
 47444  			}
 47445  			if yyr2 || yy2arr2 {
 47446  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47447  				yym19 := z.EncBinary()
 47448  				_ = yym19
 47449  				if false {
 47450  				} else {
 47451  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 47452  				}
 47453  			} else {
 47454  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47455  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 47456  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47457  				yym20 := z.EncBinary()
 47458  				_ = yym20
 47459  				if false {
 47460  				} else {
 47461  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 47462  				}
 47463  			}
 47464  			if yyr2 || yy2arr2 {
 47465  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47466  				yym22 := z.EncBinary()
 47467  				_ = yym22
 47468  				if false {
 47469  				} else {
 47470  					r.EncodeString(codecSelferC_UTF8100, string(x.Type))
 47471  				}
 47472  			} else {
 47473  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47474  				r.EncodeString(codecSelferC_UTF8100, string("Type"))
 47475  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47476  				yym23 := z.EncBinary()
 47477  				_ = yym23
 47478  				if false {
 47479  				} else {
 47480  					r.EncodeString(codecSelferC_UTF8100, string(x.Type))
 47481  				}
 47482  			}
 47483  			if yyr2 || yy2arr2 {
 47484  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47485  				yym25 := z.EncBinary()
 47486  				_ = yym25
 47487  				if false {
 47488  				} else {
 47489  					r.EncodeInt(int64(x.Priority))
 47490  				}
 47491  			} else {
 47492  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47493  				r.EncodeString(codecSelferC_UTF8100, string("Priority"))
 47494  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47495  				yym26 := z.EncBinary()
 47496  				_ = yym26
 47497  				if false {
 47498  				} else {
 47499  					r.EncodeInt(int64(x.Priority))
 47500  				}
 47501  			}
 47502  			if yyr2 || yy2arr2 {
 47503  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47504  				yym28 := z.EncBinary()
 47505  				_ = yym28
 47506  				if false {
 47507  				} else {
 47508  					r.EncodeBool(bool(x.AllAtOnce))
 47509  				}
 47510  			} else {
 47511  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47512  				r.EncodeString(codecSelferC_UTF8100, string("AllAtOnce"))
 47513  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47514  				yym29 := z.EncBinary()
 47515  				_ = yym29
 47516  				if false {
 47517  				} else {
 47518  					r.EncodeBool(bool(x.AllAtOnce))
 47519  				}
 47520  			}
 47521  			if yyr2 || yy2arr2 {
 47522  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47523  				if x.Datacenters == nil {
 47524  					r.EncodeNil()
 47525  				} else {
 47526  					yym31 := z.EncBinary()
 47527  					_ = yym31
 47528  					if false {
 47529  					} else {
 47530  						z.F.EncSliceStringV(x.Datacenters, false, e)
 47531  					}
 47532  				}
 47533  			} else {
 47534  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47535  				r.EncodeString(codecSelferC_UTF8100, string("Datacenters"))
 47536  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47537  				if x.Datacenters == nil {
 47538  					r.EncodeNil()
 47539  				} else {
 47540  					yym32 := z.EncBinary()
 47541  					_ = yym32
 47542  					if false {
 47543  					} else {
 47544  						z.F.EncSliceStringV(x.Datacenters, false, e)
 47545  					}
 47546  				}
 47547  			}
 47548  			if yyr2 || yy2arr2 {
 47549  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47550  				if x.Constraints == nil {
 47551  					r.EncodeNil()
 47552  				} else {
 47553  					yym34 := z.EncBinary()
 47554  					_ = yym34
 47555  					if false {
 47556  					} else {
 47557  						h.encSlicePtrtoConstraint(([]*Constraint)(x.Constraints), e)
 47558  					}
 47559  				}
 47560  			} else {
 47561  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47562  				r.EncodeString(codecSelferC_UTF8100, string("Constraints"))
 47563  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47564  				if x.Constraints == nil {
 47565  					r.EncodeNil()
 47566  				} else {
 47567  					yym35 := z.EncBinary()
 47568  					_ = yym35
 47569  					if false {
 47570  					} else {
 47571  						h.encSlicePtrtoConstraint(([]*Constraint)(x.Constraints), e)
 47572  					}
 47573  				}
 47574  			}
 47575  			if yyr2 || yy2arr2 {
 47576  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47577  				if x.TaskGroups == nil {
 47578  					r.EncodeNil()
 47579  				} else {
 47580  					yym37 := z.EncBinary()
 47581  					_ = yym37
 47582  					if false {
 47583  					} else {
 47584  						h.encSlicePtrtoTaskGroup(([]*TaskGroup)(x.TaskGroups), e)
 47585  					}
 47586  				}
 47587  			} else {
 47588  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47589  				r.EncodeString(codecSelferC_UTF8100, string("TaskGroups"))
 47590  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47591  				if x.TaskGroups == nil {
 47592  					r.EncodeNil()
 47593  				} else {
 47594  					yym38 := z.EncBinary()
 47595  					_ = yym38
 47596  					if false {
 47597  					} else {
 47598  						h.encSlicePtrtoTaskGroup(([]*TaskGroup)(x.TaskGroups), e)
 47599  					}
 47600  				}
 47601  			}
 47602  			if yyr2 || yy2arr2 {
 47603  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47604  				yy40 := &x.Update
 47605  				yy40.CodecEncodeSelf(e)
 47606  			} else {
 47607  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47608  				r.EncodeString(codecSelferC_UTF8100, string("Update"))
 47609  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47610  				yy42 := &x.Update
 47611  				yy42.CodecEncodeSelf(e)
 47612  			}
 47613  			if yyr2 || yy2arr2 {
 47614  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47615  				if x.Periodic == nil {
 47616  					r.EncodeNil()
 47617  				} else {
 47618  					x.Periodic.CodecEncodeSelf(e)
 47619  				}
 47620  			} else {
 47621  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47622  				r.EncodeString(codecSelferC_UTF8100, string("Periodic"))
 47623  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47624  				if x.Periodic == nil {
 47625  					r.EncodeNil()
 47626  				} else {
 47627  					x.Periodic.CodecEncodeSelf(e)
 47628  				}
 47629  			}
 47630  			if yyr2 || yy2arr2 {
 47631  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47632  				if x.ParameterizedJob == nil {
 47633  					r.EncodeNil()
 47634  				} else {
 47635  					x.ParameterizedJob.CodecEncodeSelf(e)
 47636  				}
 47637  			} else {
 47638  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47639  				r.EncodeString(codecSelferC_UTF8100, string("ParameterizedJob"))
 47640  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47641  				if x.ParameterizedJob == nil {
 47642  					r.EncodeNil()
 47643  				} else {
 47644  					x.ParameterizedJob.CodecEncodeSelf(e)
 47645  				}
 47646  			}
 47647  			if yyr2 || yy2arr2 {
 47648  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47649  				if x.Payload == nil {
 47650  					r.EncodeNil()
 47651  				} else {
 47652  					yym51 := z.EncBinary()
 47653  					_ = yym51
 47654  					if false {
 47655  					} else {
 47656  						r.EncodeStringBytes(codecSelferC_RAW100, []byte(x.Payload))
 47657  					}
 47658  				}
 47659  			} else {
 47660  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47661  				r.EncodeString(codecSelferC_UTF8100, string("Payload"))
 47662  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47663  				if x.Payload == nil {
 47664  					r.EncodeNil()
 47665  				} else {
 47666  					yym52 := z.EncBinary()
 47667  					_ = yym52
 47668  					if false {
 47669  					} else {
 47670  						r.EncodeStringBytes(codecSelferC_RAW100, []byte(x.Payload))
 47671  					}
 47672  				}
 47673  			}
 47674  			if yyr2 || yy2arr2 {
 47675  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47676  				if x.Meta == nil {
 47677  					r.EncodeNil()
 47678  				} else {
 47679  					yym54 := z.EncBinary()
 47680  					_ = yym54
 47681  					if false {
 47682  					} else {
 47683  						z.F.EncMapStringStringV(x.Meta, false, e)
 47684  					}
 47685  				}
 47686  			} else {
 47687  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47688  				r.EncodeString(codecSelferC_UTF8100, string("Meta"))
 47689  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47690  				if x.Meta == nil {
 47691  					r.EncodeNil()
 47692  				} else {
 47693  					yym55 := z.EncBinary()
 47694  					_ = yym55
 47695  					if false {
 47696  					} else {
 47697  						z.F.EncMapStringStringV(x.Meta, false, e)
 47698  					}
 47699  				}
 47700  			}
 47701  			if yyr2 || yy2arr2 {
 47702  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47703  				yym57 := z.EncBinary()
 47704  				_ = yym57
 47705  				if false {
 47706  				} else {
 47707  					r.EncodeString(codecSelferC_UTF8100, string(x.VaultToken))
 47708  				}
 47709  			} else {
 47710  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47711  				r.EncodeString(codecSelferC_UTF8100, string("VaultToken"))
 47712  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47713  				yym58 := z.EncBinary()
 47714  				_ = yym58
 47715  				if false {
 47716  				} else {
 47717  					r.EncodeString(codecSelferC_UTF8100, string(x.VaultToken))
 47718  				}
 47719  			}
 47720  			if yyr2 || yy2arr2 {
 47721  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47722  				yym60 := z.EncBinary()
 47723  				_ = yym60
 47724  				if false {
 47725  				} else {
 47726  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 47727  				}
 47728  			} else {
 47729  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47730  				r.EncodeString(codecSelferC_UTF8100, string("Status"))
 47731  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47732  				yym61 := z.EncBinary()
 47733  				_ = yym61
 47734  				if false {
 47735  				} else {
 47736  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 47737  				}
 47738  			}
 47739  			if yyr2 || yy2arr2 {
 47740  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47741  				yym63 := z.EncBinary()
 47742  				_ = yym63
 47743  				if false {
 47744  				} else {
 47745  					r.EncodeString(codecSelferC_UTF8100, string(x.StatusDescription))
 47746  				}
 47747  			} else {
 47748  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47749  				r.EncodeString(codecSelferC_UTF8100, string("StatusDescription"))
 47750  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47751  				yym64 := z.EncBinary()
 47752  				_ = yym64
 47753  				if false {
 47754  				} else {
 47755  					r.EncodeString(codecSelferC_UTF8100, string(x.StatusDescription))
 47756  				}
 47757  			}
 47758  			if yyr2 || yy2arr2 {
 47759  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47760  				yym66 := z.EncBinary()
 47761  				_ = yym66
 47762  				if false {
 47763  				} else {
 47764  					r.EncodeBool(bool(x.Stable))
 47765  				}
 47766  			} else {
 47767  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47768  				r.EncodeString(codecSelferC_UTF8100, string("Stable"))
 47769  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47770  				yym67 := z.EncBinary()
 47771  				_ = yym67
 47772  				if false {
 47773  				} else {
 47774  					r.EncodeBool(bool(x.Stable))
 47775  				}
 47776  			}
 47777  			if yyr2 || yy2arr2 {
 47778  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47779  				yym69 := z.EncBinary()
 47780  				_ = yym69
 47781  				if false {
 47782  				} else {
 47783  					r.EncodeUint(uint64(x.Version))
 47784  				}
 47785  			} else {
 47786  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47787  				r.EncodeString(codecSelferC_UTF8100, string("Version"))
 47788  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47789  				yym70 := z.EncBinary()
 47790  				_ = yym70
 47791  				if false {
 47792  				} else {
 47793  					r.EncodeUint(uint64(x.Version))
 47794  				}
 47795  			}
 47796  			if yyr2 || yy2arr2 {
 47797  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47798  				yym72 := z.EncBinary()
 47799  				_ = yym72
 47800  				if false {
 47801  				} else {
 47802  					r.EncodeInt(int64(x.SubmitTime))
 47803  				}
 47804  			} else {
 47805  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47806  				r.EncodeString(codecSelferC_UTF8100, string("SubmitTime"))
 47807  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47808  				yym73 := z.EncBinary()
 47809  				_ = yym73
 47810  				if false {
 47811  				} else {
 47812  					r.EncodeInt(int64(x.SubmitTime))
 47813  				}
 47814  			}
 47815  			if yyr2 || yy2arr2 {
 47816  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47817  				yym75 := z.EncBinary()
 47818  				_ = yym75
 47819  				if false {
 47820  				} else {
 47821  					r.EncodeUint(uint64(x.CreateIndex))
 47822  				}
 47823  			} else {
 47824  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47825  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 47826  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47827  				yym76 := z.EncBinary()
 47828  				_ = yym76
 47829  				if false {
 47830  				} else {
 47831  					r.EncodeUint(uint64(x.CreateIndex))
 47832  				}
 47833  			}
 47834  			if yyr2 || yy2arr2 {
 47835  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47836  				yym78 := z.EncBinary()
 47837  				_ = yym78
 47838  				if false {
 47839  				} else {
 47840  					r.EncodeUint(uint64(x.ModifyIndex))
 47841  				}
 47842  			} else {
 47843  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47844  				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
 47845  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47846  				yym79 := z.EncBinary()
 47847  				_ = yym79
 47848  				if false {
 47849  				} else {
 47850  					r.EncodeUint(uint64(x.ModifyIndex))
 47851  				}
 47852  			}
 47853  			if yyr2 || yy2arr2 {
 47854  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 47855  				yym81 := z.EncBinary()
 47856  				_ = yym81
 47857  				if false {
 47858  				} else {
 47859  					r.EncodeUint(uint64(x.JobModifyIndex))
 47860  				}
 47861  			} else {
 47862  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 47863  				r.EncodeString(codecSelferC_UTF8100, string("JobModifyIndex"))
 47864  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 47865  				yym82 := z.EncBinary()
 47866  				_ = yym82
 47867  				if false {
 47868  				} else {
 47869  					r.EncodeUint(uint64(x.JobModifyIndex))
 47870  				}
 47871  			}
 47872  			if yyr2 || yy2arr2 {
 47873  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 47874  			} else {
 47875  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 47876  			}
 47877  		}
 47878  	}
 47879  }
 47880  
 47881  func (x *Job) CodecDecodeSelf(d *codec1978.Decoder) {
 47882  	var h codecSelfer100
 47883  	z, r := codec1978.GenHelperDecoder(d)
 47884  	_, _, _ = h, z, r
 47885  	yym1 := z.DecBinary()
 47886  	_ = yym1
 47887  	if false {
 47888  	} else if z.HasExtensions() && z.DecExt(x) {
 47889  	} else {
 47890  		yyct2 := r.ContainerType()
 47891  		if yyct2 == codecSelferValueTypeMap100 {
 47892  			yyl2 := r.ReadMapStart()
 47893  			if yyl2 == 0 {
 47894  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 47895  			} else {
 47896  				x.codecDecodeSelfFromMap(yyl2, d)
 47897  			}
 47898  		} else if yyct2 == codecSelferValueTypeArray100 {
 47899  			yyl2 := r.ReadArrayStart()
 47900  			if yyl2 == 0 {
 47901  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 47902  			} else {
 47903  				x.codecDecodeSelfFromArray(yyl2, d)
 47904  			}
 47905  		} else {
 47906  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 47907  		}
 47908  	}
 47909  }
 47910  
 47911  func (x *Job) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 47912  	var h codecSelfer100
 47913  	z, r := codec1978.GenHelperDecoder(d)
 47914  	_, _, _ = h, z, r
 47915  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 47916  	_ = yys3Slc
 47917  	var yyhl3 bool = l >= 0
 47918  	for yyj3 := 0; ; yyj3++ {
 47919  		if yyhl3 {
 47920  			if yyj3 >= l {
 47921  				break
 47922  			}
 47923  		} else {
 47924  			if r.CheckBreak() {
 47925  				break
 47926  			}
 47927  		}
 47928  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 47929  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 47930  		yys3 := string(yys3Slc)
 47931  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 47932  		switch yys3 {
 47933  		case "Stop":
 47934  			if r.TryDecodeAsNil() {
 47935  				x.Stop = false
 47936  			} else {
 47937  				yyv4 := &x.Stop
 47938  				yym5 := z.DecBinary()
 47939  				_ = yym5
 47940  				if false {
 47941  				} else {
 47942  					*((*bool)(yyv4)) = r.DecodeBool()
 47943  				}
 47944  			}
 47945  		case "Region":
 47946  			if r.TryDecodeAsNil() {
 47947  				x.Region = ""
 47948  			} else {
 47949  				yyv6 := &x.Region
 47950  				yym7 := z.DecBinary()
 47951  				_ = yym7
 47952  				if false {
 47953  				} else {
 47954  					*((*string)(yyv6)) = r.DecodeString()
 47955  				}
 47956  			}
 47957  		case "Namespace":
 47958  			if r.TryDecodeAsNil() {
 47959  				x.Namespace = ""
 47960  			} else {
 47961  				yyv8 := &x.Namespace
 47962  				yym9 := z.DecBinary()
 47963  				_ = yym9
 47964  				if false {
 47965  				} else {
 47966  					*((*string)(yyv8)) = r.DecodeString()
 47967  				}
 47968  			}
 47969  		case "ID":
 47970  			if r.TryDecodeAsNil() {
 47971  				x.ID = ""
 47972  			} else {
 47973  				yyv10 := &x.ID
 47974  				yym11 := z.DecBinary()
 47975  				_ = yym11
 47976  				if false {
 47977  				} else {
 47978  					*((*string)(yyv10)) = r.DecodeString()
 47979  				}
 47980  			}
 47981  		case "ParentID":
 47982  			if r.TryDecodeAsNil() {
 47983  				x.ParentID = ""
 47984  			} else {
 47985  				yyv12 := &x.ParentID
 47986  				yym13 := z.DecBinary()
 47987  				_ = yym13
 47988  				if false {
 47989  				} else {
 47990  					*((*string)(yyv12)) = r.DecodeString()
 47991  				}
 47992  			}
 47993  		case "Name":
 47994  			if r.TryDecodeAsNil() {
 47995  				x.Name = ""
 47996  			} else {
 47997  				yyv14 := &x.Name
 47998  				yym15 := z.DecBinary()
 47999  				_ = yym15
 48000  				if false {
 48001  				} else {
 48002  					*((*string)(yyv14)) = r.DecodeString()
 48003  				}
 48004  			}
 48005  		case "Type":
 48006  			if r.TryDecodeAsNil() {
 48007  				x.Type = ""
 48008  			} else {
 48009  				yyv16 := &x.Type
 48010  				yym17 := z.DecBinary()
 48011  				_ = yym17
 48012  				if false {
 48013  				} else {
 48014  					*((*string)(yyv16)) = r.DecodeString()
 48015  				}
 48016  			}
 48017  		case "Priority":
 48018  			if r.TryDecodeAsNil() {
 48019  				x.Priority = 0
 48020  			} else {
 48021  				yyv18 := &x.Priority
 48022  				yym19 := z.DecBinary()
 48023  				_ = yym19
 48024  				if false {
 48025  				} else {
 48026  					*((*int)(yyv18)) = int(r.DecodeInt(codecSelferBitsize100))
 48027  				}
 48028  			}
 48029  		case "AllAtOnce":
 48030  			if r.TryDecodeAsNil() {
 48031  				x.AllAtOnce = false
 48032  			} else {
 48033  				yyv20 := &x.AllAtOnce
 48034  				yym21 := z.DecBinary()
 48035  				_ = yym21
 48036  				if false {
 48037  				} else {
 48038  					*((*bool)(yyv20)) = r.DecodeBool()
 48039  				}
 48040  			}
 48041  		case "Datacenters":
 48042  			if r.TryDecodeAsNil() {
 48043  				x.Datacenters = nil
 48044  			} else {
 48045  				yyv22 := &x.Datacenters
 48046  				yym23 := z.DecBinary()
 48047  				_ = yym23
 48048  				if false {
 48049  				} else {
 48050  					z.F.DecSliceStringX(yyv22, false, d)
 48051  				}
 48052  			}
 48053  		case "Constraints":
 48054  			if r.TryDecodeAsNil() {
 48055  				x.Constraints = nil
 48056  			} else {
 48057  				yyv24 := &x.Constraints
 48058  				yym25 := z.DecBinary()
 48059  				_ = yym25
 48060  				if false {
 48061  				} else {
 48062  					h.decSlicePtrtoConstraint((*[]*Constraint)(yyv24), d)
 48063  				}
 48064  			}
 48065  		case "TaskGroups":
 48066  			if r.TryDecodeAsNil() {
 48067  				x.TaskGroups = nil
 48068  			} else {
 48069  				yyv26 := &x.TaskGroups
 48070  				yym27 := z.DecBinary()
 48071  				_ = yym27
 48072  				if false {
 48073  				} else {
 48074  					h.decSlicePtrtoTaskGroup((*[]*TaskGroup)(yyv26), d)
 48075  				}
 48076  			}
 48077  		case "Update":
 48078  			if r.TryDecodeAsNil() {
 48079  				x.Update = UpdateStrategy{}
 48080  			} else {
 48081  				yyv28 := &x.Update
 48082  				yyv28.CodecDecodeSelf(d)
 48083  			}
 48084  		case "Periodic":
 48085  			if r.TryDecodeAsNil() {
 48086  				if x.Periodic != nil {
 48087  					x.Periodic = nil
 48088  				}
 48089  			} else {
 48090  				if x.Periodic == nil {
 48091  					x.Periodic = new(PeriodicConfig)
 48092  				}
 48093  				x.Periodic.CodecDecodeSelf(d)
 48094  			}
 48095  		case "ParameterizedJob":
 48096  			if r.TryDecodeAsNil() {
 48097  				if x.ParameterizedJob != nil {
 48098  					x.ParameterizedJob = nil
 48099  				}
 48100  			} else {
 48101  				if x.ParameterizedJob == nil {
 48102  					x.ParameterizedJob = new(ParameterizedJobConfig)
 48103  				}
 48104  				x.ParameterizedJob.CodecDecodeSelf(d)
 48105  			}
 48106  		case "Payload":
 48107  			if r.TryDecodeAsNil() {
 48108  				x.Payload = nil
 48109  			} else {
 48110  				yyv31 := &x.Payload
 48111  				yym32 := z.DecBinary()
 48112  				_ = yym32
 48113  				if false {
 48114  				} else {
 48115  					*yyv31 = r.DecodeBytes(*(*[]byte)(yyv31), false, false)
 48116  				}
 48117  			}
 48118  		case "Meta":
 48119  			if r.TryDecodeAsNil() {
 48120  				x.Meta = nil
 48121  			} else {
 48122  				yyv33 := &x.Meta
 48123  				yym34 := z.DecBinary()
 48124  				_ = yym34
 48125  				if false {
 48126  				} else {
 48127  					z.F.DecMapStringStringX(yyv33, false, d)
 48128  				}
 48129  			}
 48130  		case "VaultToken":
 48131  			if r.TryDecodeAsNil() {
 48132  				x.VaultToken = ""
 48133  			} else {
 48134  				yyv35 := &x.VaultToken
 48135  				yym36 := z.DecBinary()
 48136  				_ = yym36
 48137  				if false {
 48138  				} else {
 48139  					*((*string)(yyv35)) = r.DecodeString()
 48140  				}
 48141  			}
 48142  		case "Status":
 48143  			if r.TryDecodeAsNil() {
 48144  				x.Status = ""
 48145  			} else {
 48146  				yyv37 := &x.Status
 48147  				yym38 := z.DecBinary()
 48148  				_ = yym38
 48149  				if false {
 48150  				} else {
 48151  					*((*string)(yyv37)) = r.DecodeString()
 48152  				}
 48153  			}
 48154  		case "StatusDescription":
 48155  			if r.TryDecodeAsNil() {
 48156  				x.StatusDescription = ""
 48157  			} else {
 48158  				yyv39 := &x.StatusDescription
 48159  				yym40 := z.DecBinary()
 48160  				_ = yym40
 48161  				if false {
 48162  				} else {
 48163  					*((*string)(yyv39)) = r.DecodeString()
 48164  				}
 48165  			}
 48166  		case "Stable":
 48167  			if r.TryDecodeAsNil() {
 48168  				x.Stable = false
 48169  			} else {
 48170  				yyv41 := &x.Stable
 48171  				yym42 := z.DecBinary()
 48172  				_ = yym42
 48173  				if false {
 48174  				} else {
 48175  					*((*bool)(yyv41)) = r.DecodeBool()
 48176  				}
 48177  			}
 48178  		case "Version":
 48179  			if r.TryDecodeAsNil() {
 48180  				x.Version = 0
 48181  			} else {
 48182  				yyv43 := &x.Version
 48183  				yym44 := z.DecBinary()
 48184  				_ = yym44
 48185  				if false {
 48186  				} else {
 48187  					*((*uint64)(yyv43)) = uint64(r.DecodeUint(64))
 48188  				}
 48189  			}
 48190  		case "SubmitTime":
 48191  			if r.TryDecodeAsNil() {
 48192  				x.SubmitTime = 0
 48193  			} else {
 48194  				yyv45 := &x.SubmitTime
 48195  				yym46 := z.DecBinary()
 48196  				_ = yym46
 48197  				if false {
 48198  				} else {
 48199  					*((*int64)(yyv45)) = int64(r.DecodeInt(64))
 48200  				}
 48201  			}
 48202  		case "CreateIndex":
 48203  			if r.TryDecodeAsNil() {
 48204  				x.CreateIndex = 0
 48205  			} else {
 48206  				yyv47 := &x.CreateIndex
 48207  				yym48 := z.DecBinary()
 48208  				_ = yym48
 48209  				if false {
 48210  				} else {
 48211  					*((*uint64)(yyv47)) = uint64(r.DecodeUint(64))
 48212  				}
 48213  			}
 48214  		case "ModifyIndex":
 48215  			if r.TryDecodeAsNil() {
 48216  				x.ModifyIndex = 0
 48217  			} else {
 48218  				yyv49 := &x.ModifyIndex
 48219  				yym50 := z.DecBinary()
 48220  				_ = yym50
 48221  				if false {
 48222  				} else {
 48223  					*((*uint64)(yyv49)) = uint64(r.DecodeUint(64))
 48224  				}
 48225  			}
 48226  		case "JobModifyIndex":
 48227  			if r.TryDecodeAsNil() {
 48228  				x.JobModifyIndex = 0
 48229  			} else {
 48230  				yyv51 := &x.JobModifyIndex
 48231  				yym52 := z.DecBinary()
 48232  				_ = yym52
 48233  				if false {
 48234  				} else {
 48235  					*((*uint64)(yyv51)) = uint64(r.DecodeUint(64))
 48236  				}
 48237  			}
 48238  		default:
 48239  			z.DecStructFieldNotFound(-1, yys3)
 48240  		} // end switch yys3
 48241  	} // end for yyj3
 48242  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 48243  }
 48244  
 48245  func (x *Job) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 48246  	var h codecSelfer100
 48247  	z, r := codec1978.GenHelperDecoder(d)
 48248  	_, _, _ = h, z, r
 48249  	var yyj53 int
 48250  	var yyb53 bool
 48251  	var yyhl53 bool = l >= 0
 48252  	yyj53++
 48253  	if yyhl53 {
 48254  		yyb53 = yyj53 > l
 48255  	} else {
 48256  		yyb53 = r.CheckBreak()
 48257  	}
 48258  	if yyb53 {
 48259  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48260  		return
 48261  	}
 48262  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48263  	if r.TryDecodeAsNil() {
 48264  		x.Stop = false
 48265  	} else {
 48266  		yyv54 := &x.Stop
 48267  		yym55 := z.DecBinary()
 48268  		_ = yym55
 48269  		if false {
 48270  		} else {
 48271  			*((*bool)(yyv54)) = r.DecodeBool()
 48272  		}
 48273  	}
 48274  	yyj53++
 48275  	if yyhl53 {
 48276  		yyb53 = yyj53 > l
 48277  	} else {
 48278  		yyb53 = r.CheckBreak()
 48279  	}
 48280  	if yyb53 {
 48281  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48282  		return
 48283  	}
 48284  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48285  	if r.TryDecodeAsNil() {
 48286  		x.Region = ""
 48287  	} else {
 48288  		yyv56 := &x.Region
 48289  		yym57 := z.DecBinary()
 48290  		_ = yym57
 48291  		if false {
 48292  		} else {
 48293  			*((*string)(yyv56)) = r.DecodeString()
 48294  		}
 48295  	}
 48296  	yyj53++
 48297  	if yyhl53 {
 48298  		yyb53 = yyj53 > l
 48299  	} else {
 48300  		yyb53 = r.CheckBreak()
 48301  	}
 48302  	if yyb53 {
 48303  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48304  		return
 48305  	}
 48306  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48307  	if r.TryDecodeAsNil() {
 48308  		x.Namespace = ""
 48309  	} else {
 48310  		yyv58 := &x.Namespace
 48311  		yym59 := z.DecBinary()
 48312  		_ = yym59
 48313  		if false {
 48314  		} else {
 48315  			*((*string)(yyv58)) = r.DecodeString()
 48316  		}
 48317  	}
 48318  	yyj53++
 48319  	if yyhl53 {
 48320  		yyb53 = yyj53 > l
 48321  	} else {
 48322  		yyb53 = r.CheckBreak()
 48323  	}
 48324  	if yyb53 {
 48325  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48326  		return
 48327  	}
 48328  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48329  	if r.TryDecodeAsNil() {
 48330  		x.ID = ""
 48331  	} else {
 48332  		yyv60 := &x.ID
 48333  		yym61 := z.DecBinary()
 48334  		_ = yym61
 48335  		if false {
 48336  		} else {
 48337  			*((*string)(yyv60)) = r.DecodeString()
 48338  		}
 48339  	}
 48340  	yyj53++
 48341  	if yyhl53 {
 48342  		yyb53 = yyj53 > l
 48343  	} else {
 48344  		yyb53 = r.CheckBreak()
 48345  	}
 48346  	if yyb53 {
 48347  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48348  		return
 48349  	}
 48350  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48351  	if r.TryDecodeAsNil() {
 48352  		x.ParentID = ""
 48353  	} else {
 48354  		yyv62 := &x.ParentID
 48355  		yym63 := z.DecBinary()
 48356  		_ = yym63
 48357  		if false {
 48358  		} else {
 48359  			*((*string)(yyv62)) = r.DecodeString()
 48360  		}
 48361  	}
 48362  	yyj53++
 48363  	if yyhl53 {
 48364  		yyb53 = yyj53 > l
 48365  	} else {
 48366  		yyb53 = r.CheckBreak()
 48367  	}
 48368  	if yyb53 {
 48369  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48370  		return
 48371  	}
 48372  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48373  	if r.TryDecodeAsNil() {
 48374  		x.Name = ""
 48375  	} else {
 48376  		yyv64 := &x.Name
 48377  		yym65 := z.DecBinary()
 48378  		_ = yym65
 48379  		if false {
 48380  		} else {
 48381  			*((*string)(yyv64)) = r.DecodeString()
 48382  		}
 48383  	}
 48384  	yyj53++
 48385  	if yyhl53 {
 48386  		yyb53 = yyj53 > l
 48387  	} else {
 48388  		yyb53 = r.CheckBreak()
 48389  	}
 48390  	if yyb53 {
 48391  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48392  		return
 48393  	}
 48394  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48395  	if r.TryDecodeAsNil() {
 48396  		x.Type = ""
 48397  	} else {
 48398  		yyv66 := &x.Type
 48399  		yym67 := z.DecBinary()
 48400  		_ = yym67
 48401  		if false {
 48402  		} else {
 48403  			*((*string)(yyv66)) = r.DecodeString()
 48404  		}
 48405  	}
 48406  	yyj53++
 48407  	if yyhl53 {
 48408  		yyb53 = yyj53 > l
 48409  	} else {
 48410  		yyb53 = r.CheckBreak()
 48411  	}
 48412  	if yyb53 {
 48413  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48414  		return
 48415  	}
 48416  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48417  	if r.TryDecodeAsNil() {
 48418  		x.Priority = 0
 48419  	} else {
 48420  		yyv68 := &x.Priority
 48421  		yym69 := z.DecBinary()
 48422  		_ = yym69
 48423  		if false {
 48424  		} else {
 48425  			*((*int)(yyv68)) = int(r.DecodeInt(codecSelferBitsize100))
 48426  		}
 48427  	}
 48428  	yyj53++
 48429  	if yyhl53 {
 48430  		yyb53 = yyj53 > l
 48431  	} else {
 48432  		yyb53 = r.CheckBreak()
 48433  	}
 48434  	if yyb53 {
 48435  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48436  		return
 48437  	}
 48438  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48439  	if r.TryDecodeAsNil() {
 48440  		x.AllAtOnce = false
 48441  	} else {
 48442  		yyv70 := &x.AllAtOnce
 48443  		yym71 := z.DecBinary()
 48444  		_ = yym71
 48445  		if false {
 48446  		} else {
 48447  			*((*bool)(yyv70)) = r.DecodeBool()
 48448  		}
 48449  	}
 48450  	yyj53++
 48451  	if yyhl53 {
 48452  		yyb53 = yyj53 > l
 48453  	} else {
 48454  		yyb53 = r.CheckBreak()
 48455  	}
 48456  	if yyb53 {
 48457  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48458  		return
 48459  	}
 48460  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48461  	if r.TryDecodeAsNil() {
 48462  		x.Datacenters = nil
 48463  	} else {
 48464  		yyv72 := &x.Datacenters
 48465  		yym73 := z.DecBinary()
 48466  		_ = yym73
 48467  		if false {
 48468  		} else {
 48469  			z.F.DecSliceStringX(yyv72, false, d)
 48470  		}
 48471  	}
 48472  	yyj53++
 48473  	if yyhl53 {
 48474  		yyb53 = yyj53 > l
 48475  	} else {
 48476  		yyb53 = r.CheckBreak()
 48477  	}
 48478  	if yyb53 {
 48479  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48480  		return
 48481  	}
 48482  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48483  	if r.TryDecodeAsNil() {
 48484  		x.Constraints = nil
 48485  	} else {
 48486  		yyv74 := &x.Constraints
 48487  		yym75 := z.DecBinary()
 48488  		_ = yym75
 48489  		if false {
 48490  		} else {
 48491  			h.decSlicePtrtoConstraint((*[]*Constraint)(yyv74), d)
 48492  		}
 48493  	}
 48494  	yyj53++
 48495  	if yyhl53 {
 48496  		yyb53 = yyj53 > l
 48497  	} else {
 48498  		yyb53 = r.CheckBreak()
 48499  	}
 48500  	if yyb53 {
 48501  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48502  		return
 48503  	}
 48504  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48505  	if r.TryDecodeAsNil() {
 48506  		x.TaskGroups = nil
 48507  	} else {
 48508  		yyv76 := &x.TaskGroups
 48509  		yym77 := z.DecBinary()
 48510  		_ = yym77
 48511  		if false {
 48512  		} else {
 48513  			h.decSlicePtrtoTaskGroup((*[]*TaskGroup)(yyv76), d)
 48514  		}
 48515  	}
 48516  	yyj53++
 48517  	if yyhl53 {
 48518  		yyb53 = yyj53 > l
 48519  	} else {
 48520  		yyb53 = r.CheckBreak()
 48521  	}
 48522  	if yyb53 {
 48523  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48524  		return
 48525  	}
 48526  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48527  	if r.TryDecodeAsNil() {
 48528  		x.Update = UpdateStrategy{}
 48529  	} else {
 48530  		yyv78 := &x.Update
 48531  		yyv78.CodecDecodeSelf(d)
 48532  	}
 48533  	yyj53++
 48534  	if yyhl53 {
 48535  		yyb53 = yyj53 > l
 48536  	} else {
 48537  		yyb53 = r.CheckBreak()
 48538  	}
 48539  	if yyb53 {
 48540  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48541  		return
 48542  	}
 48543  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48544  	if r.TryDecodeAsNil() {
 48545  		if x.Periodic != nil {
 48546  			x.Periodic = nil
 48547  		}
 48548  	} else {
 48549  		if x.Periodic == nil {
 48550  			x.Periodic = new(PeriodicConfig)
 48551  		}
 48552  		x.Periodic.CodecDecodeSelf(d)
 48553  	}
 48554  	yyj53++
 48555  	if yyhl53 {
 48556  		yyb53 = yyj53 > l
 48557  	} else {
 48558  		yyb53 = r.CheckBreak()
 48559  	}
 48560  	if yyb53 {
 48561  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48562  		return
 48563  	}
 48564  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48565  	if r.TryDecodeAsNil() {
 48566  		if x.ParameterizedJob != nil {
 48567  			x.ParameterizedJob = nil
 48568  		}
 48569  	} else {
 48570  		if x.ParameterizedJob == nil {
 48571  			x.ParameterizedJob = new(ParameterizedJobConfig)
 48572  		}
 48573  		x.ParameterizedJob.CodecDecodeSelf(d)
 48574  	}
 48575  	yyj53++
 48576  	if yyhl53 {
 48577  		yyb53 = yyj53 > l
 48578  	} else {
 48579  		yyb53 = r.CheckBreak()
 48580  	}
 48581  	if yyb53 {
 48582  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48583  		return
 48584  	}
 48585  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48586  	if r.TryDecodeAsNil() {
 48587  		x.Payload = nil
 48588  	} else {
 48589  		yyv81 := &x.Payload
 48590  		yym82 := z.DecBinary()
 48591  		_ = yym82
 48592  		if false {
 48593  		} else {
 48594  			*yyv81 = r.DecodeBytes(*(*[]byte)(yyv81), false, false)
 48595  		}
 48596  	}
 48597  	yyj53++
 48598  	if yyhl53 {
 48599  		yyb53 = yyj53 > l
 48600  	} else {
 48601  		yyb53 = r.CheckBreak()
 48602  	}
 48603  	if yyb53 {
 48604  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48605  		return
 48606  	}
 48607  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48608  	if r.TryDecodeAsNil() {
 48609  		x.Meta = nil
 48610  	} else {
 48611  		yyv83 := &x.Meta
 48612  		yym84 := z.DecBinary()
 48613  		_ = yym84
 48614  		if false {
 48615  		} else {
 48616  			z.F.DecMapStringStringX(yyv83, false, d)
 48617  		}
 48618  	}
 48619  	yyj53++
 48620  	if yyhl53 {
 48621  		yyb53 = yyj53 > l
 48622  	} else {
 48623  		yyb53 = r.CheckBreak()
 48624  	}
 48625  	if yyb53 {
 48626  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48627  		return
 48628  	}
 48629  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48630  	if r.TryDecodeAsNil() {
 48631  		x.VaultToken = ""
 48632  	} else {
 48633  		yyv85 := &x.VaultToken
 48634  		yym86 := z.DecBinary()
 48635  		_ = yym86
 48636  		if false {
 48637  		} else {
 48638  			*((*string)(yyv85)) = r.DecodeString()
 48639  		}
 48640  	}
 48641  	yyj53++
 48642  	if yyhl53 {
 48643  		yyb53 = yyj53 > l
 48644  	} else {
 48645  		yyb53 = r.CheckBreak()
 48646  	}
 48647  	if yyb53 {
 48648  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48649  		return
 48650  	}
 48651  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48652  	if r.TryDecodeAsNil() {
 48653  		x.Status = ""
 48654  	} else {
 48655  		yyv87 := &x.Status
 48656  		yym88 := z.DecBinary()
 48657  		_ = yym88
 48658  		if false {
 48659  		} else {
 48660  			*((*string)(yyv87)) = r.DecodeString()
 48661  		}
 48662  	}
 48663  	yyj53++
 48664  	if yyhl53 {
 48665  		yyb53 = yyj53 > l
 48666  	} else {
 48667  		yyb53 = r.CheckBreak()
 48668  	}
 48669  	if yyb53 {
 48670  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48671  		return
 48672  	}
 48673  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48674  	if r.TryDecodeAsNil() {
 48675  		x.StatusDescription = ""
 48676  	} else {
 48677  		yyv89 := &x.StatusDescription
 48678  		yym90 := z.DecBinary()
 48679  		_ = yym90
 48680  		if false {
 48681  		} else {
 48682  			*((*string)(yyv89)) = r.DecodeString()
 48683  		}
 48684  	}
 48685  	yyj53++
 48686  	if yyhl53 {
 48687  		yyb53 = yyj53 > l
 48688  	} else {
 48689  		yyb53 = r.CheckBreak()
 48690  	}
 48691  	if yyb53 {
 48692  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48693  		return
 48694  	}
 48695  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48696  	if r.TryDecodeAsNil() {
 48697  		x.Stable = false
 48698  	} else {
 48699  		yyv91 := &x.Stable
 48700  		yym92 := z.DecBinary()
 48701  		_ = yym92
 48702  		if false {
 48703  		} else {
 48704  			*((*bool)(yyv91)) = r.DecodeBool()
 48705  		}
 48706  	}
 48707  	yyj53++
 48708  	if yyhl53 {
 48709  		yyb53 = yyj53 > l
 48710  	} else {
 48711  		yyb53 = r.CheckBreak()
 48712  	}
 48713  	if yyb53 {
 48714  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48715  		return
 48716  	}
 48717  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48718  	if r.TryDecodeAsNil() {
 48719  		x.Version = 0
 48720  	} else {
 48721  		yyv93 := &x.Version
 48722  		yym94 := z.DecBinary()
 48723  		_ = yym94
 48724  		if false {
 48725  		} else {
 48726  			*((*uint64)(yyv93)) = uint64(r.DecodeUint(64))
 48727  		}
 48728  	}
 48729  	yyj53++
 48730  	if yyhl53 {
 48731  		yyb53 = yyj53 > l
 48732  	} else {
 48733  		yyb53 = r.CheckBreak()
 48734  	}
 48735  	if yyb53 {
 48736  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48737  		return
 48738  	}
 48739  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48740  	if r.TryDecodeAsNil() {
 48741  		x.SubmitTime = 0
 48742  	} else {
 48743  		yyv95 := &x.SubmitTime
 48744  		yym96 := z.DecBinary()
 48745  		_ = yym96
 48746  		if false {
 48747  		} else {
 48748  			*((*int64)(yyv95)) = int64(r.DecodeInt(64))
 48749  		}
 48750  	}
 48751  	yyj53++
 48752  	if yyhl53 {
 48753  		yyb53 = yyj53 > l
 48754  	} else {
 48755  		yyb53 = r.CheckBreak()
 48756  	}
 48757  	if yyb53 {
 48758  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48759  		return
 48760  	}
 48761  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48762  	if r.TryDecodeAsNil() {
 48763  		x.CreateIndex = 0
 48764  	} else {
 48765  		yyv97 := &x.CreateIndex
 48766  		yym98 := z.DecBinary()
 48767  		_ = yym98
 48768  		if false {
 48769  		} else {
 48770  			*((*uint64)(yyv97)) = uint64(r.DecodeUint(64))
 48771  		}
 48772  	}
 48773  	yyj53++
 48774  	if yyhl53 {
 48775  		yyb53 = yyj53 > l
 48776  	} else {
 48777  		yyb53 = r.CheckBreak()
 48778  	}
 48779  	if yyb53 {
 48780  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48781  		return
 48782  	}
 48783  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48784  	if r.TryDecodeAsNil() {
 48785  		x.ModifyIndex = 0
 48786  	} else {
 48787  		yyv99 := &x.ModifyIndex
 48788  		yym100 := z.DecBinary()
 48789  		_ = yym100
 48790  		if false {
 48791  		} else {
 48792  			*((*uint64)(yyv99)) = uint64(r.DecodeUint(64))
 48793  		}
 48794  	}
 48795  	yyj53++
 48796  	if yyhl53 {
 48797  		yyb53 = yyj53 > l
 48798  	} else {
 48799  		yyb53 = r.CheckBreak()
 48800  	}
 48801  	if yyb53 {
 48802  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48803  		return
 48804  	}
 48805  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48806  	if r.TryDecodeAsNil() {
 48807  		x.JobModifyIndex = 0
 48808  	} else {
 48809  		yyv101 := &x.JobModifyIndex
 48810  		yym102 := z.DecBinary()
 48811  		_ = yym102
 48812  		if false {
 48813  		} else {
 48814  			*((*uint64)(yyv101)) = uint64(r.DecodeUint(64))
 48815  		}
 48816  	}
 48817  	for {
 48818  		yyj53++
 48819  		if yyhl53 {
 48820  			yyb53 = yyj53 > l
 48821  		} else {
 48822  			yyb53 = r.CheckBreak()
 48823  		}
 48824  		if yyb53 {
 48825  			break
 48826  		}
 48827  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 48828  		z.DecStructFieldNotFound(yyj53-1, "")
 48829  	}
 48830  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 48831  }
 48832  
 48833  func (x *JobListStub) CodecEncodeSelf(e *codec1978.Encoder) {
 48834  	var h codecSelfer100
 48835  	z, r := codec1978.GenHelperEncoder(e)
 48836  	_, _, _ = h, z, r
 48837  	if x == nil {
 48838  		r.EncodeNil()
 48839  	} else {
 48840  		yym1 := z.EncBinary()
 48841  		_ = yym1
 48842  		if false {
 48843  		} else if z.HasExtensions() && z.EncExt(x) {
 48844  		} else {
 48845  			yysep2 := !z.EncBinary()
 48846  			yy2arr2 := z.EncBasicHandle().StructToArray
 48847  			var yyq2 [15]bool
 48848  			_, _, _ = yysep2, yyq2, yy2arr2
 48849  			const yyr2 bool = false
 48850  			var yynn2 int
 48851  			if yyr2 || yy2arr2 {
 48852  				r.EncodeArrayStart(15)
 48853  			} else {
 48854  				yynn2 = 15
 48855  				for _, b := range yyq2 {
 48856  					if b {
 48857  						yynn2++
 48858  					}
 48859  				}
 48860  				r.EncodeMapStart(yynn2)
 48861  				yynn2 = 0
 48862  			}
 48863  			if yyr2 || yy2arr2 {
 48864  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 48865  				yym4 := z.EncBinary()
 48866  				_ = yym4
 48867  				if false {
 48868  				} else {
 48869  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 48870  				}
 48871  			} else {
 48872  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 48873  				r.EncodeString(codecSelferC_UTF8100, string("ID"))
 48874  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 48875  				yym5 := z.EncBinary()
 48876  				_ = yym5
 48877  				if false {
 48878  				} else {
 48879  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 48880  				}
 48881  			}
 48882  			if yyr2 || yy2arr2 {
 48883  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 48884  				yym7 := z.EncBinary()
 48885  				_ = yym7
 48886  				if false {
 48887  				} else {
 48888  					r.EncodeString(codecSelferC_UTF8100, string(x.ParentID))
 48889  				}
 48890  			} else {
 48891  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 48892  				r.EncodeString(codecSelferC_UTF8100, string("ParentID"))
 48893  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 48894  				yym8 := z.EncBinary()
 48895  				_ = yym8
 48896  				if false {
 48897  				} else {
 48898  					r.EncodeString(codecSelferC_UTF8100, string(x.ParentID))
 48899  				}
 48900  			}
 48901  			if yyr2 || yy2arr2 {
 48902  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 48903  				yym10 := z.EncBinary()
 48904  				_ = yym10
 48905  				if false {
 48906  				} else {
 48907  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 48908  				}
 48909  			} else {
 48910  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 48911  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 48912  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 48913  				yym11 := z.EncBinary()
 48914  				_ = yym11
 48915  				if false {
 48916  				} else {
 48917  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 48918  				}
 48919  			}
 48920  			if yyr2 || yy2arr2 {
 48921  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 48922  				yym13 := z.EncBinary()
 48923  				_ = yym13
 48924  				if false {
 48925  				} else {
 48926  					r.EncodeString(codecSelferC_UTF8100, string(x.Type))
 48927  				}
 48928  			} else {
 48929  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 48930  				r.EncodeString(codecSelferC_UTF8100, string("Type"))
 48931  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 48932  				yym14 := z.EncBinary()
 48933  				_ = yym14
 48934  				if false {
 48935  				} else {
 48936  					r.EncodeString(codecSelferC_UTF8100, string(x.Type))
 48937  				}
 48938  			}
 48939  			if yyr2 || yy2arr2 {
 48940  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 48941  				yym16 := z.EncBinary()
 48942  				_ = yym16
 48943  				if false {
 48944  				} else {
 48945  					r.EncodeInt(int64(x.Priority))
 48946  				}
 48947  			} else {
 48948  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 48949  				r.EncodeString(codecSelferC_UTF8100, string("Priority"))
 48950  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 48951  				yym17 := z.EncBinary()
 48952  				_ = yym17
 48953  				if false {
 48954  				} else {
 48955  					r.EncodeInt(int64(x.Priority))
 48956  				}
 48957  			}
 48958  			if yyr2 || yy2arr2 {
 48959  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 48960  				yym19 := z.EncBinary()
 48961  				_ = yym19
 48962  				if false {
 48963  				} else {
 48964  					r.EncodeBool(bool(x.Periodic))
 48965  				}
 48966  			} else {
 48967  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 48968  				r.EncodeString(codecSelferC_UTF8100, string("Periodic"))
 48969  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 48970  				yym20 := z.EncBinary()
 48971  				_ = yym20
 48972  				if false {
 48973  				} else {
 48974  					r.EncodeBool(bool(x.Periodic))
 48975  				}
 48976  			}
 48977  			if yyr2 || yy2arr2 {
 48978  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 48979  				yym22 := z.EncBinary()
 48980  				_ = yym22
 48981  				if false {
 48982  				} else {
 48983  					r.EncodeBool(bool(x.ParameterizedJob))
 48984  				}
 48985  			} else {
 48986  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 48987  				r.EncodeString(codecSelferC_UTF8100, string("ParameterizedJob"))
 48988  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 48989  				yym23 := z.EncBinary()
 48990  				_ = yym23
 48991  				if false {
 48992  				} else {
 48993  					r.EncodeBool(bool(x.ParameterizedJob))
 48994  				}
 48995  			}
 48996  			if yyr2 || yy2arr2 {
 48997  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 48998  				yym25 := z.EncBinary()
 48999  				_ = yym25
 49000  				if false {
 49001  				} else {
 49002  					r.EncodeBool(bool(x.Stop))
 49003  				}
 49004  			} else {
 49005  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 49006  				r.EncodeString(codecSelferC_UTF8100, string("Stop"))
 49007  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 49008  				yym26 := z.EncBinary()
 49009  				_ = yym26
 49010  				if false {
 49011  				} else {
 49012  					r.EncodeBool(bool(x.Stop))
 49013  				}
 49014  			}
 49015  			if yyr2 || yy2arr2 {
 49016  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 49017  				yym28 := z.EncBinary()
 49018  				_ = yym28
 49019  				if false {
 49020  				} else {
 49021  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 49022  				}
 49023  			} else {
 49024  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 49025  				r.EncodeString(codecSelferC_UTF8100, string("Status"))
 49026  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 49027  				yym29 := z.EncBinary()
 49028  				_ = yym29
 49029  				if false {
 49030  				} else {
 49031  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 49032  				}
 49033  			}
 49034  			if yyr2 || yy2arr2 {
 49035  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 49036  				yym31 := z.EncBinary()
 49037  				_ = yym31
 49038  				if false {
 49039  				} else {
 49040  					r.EncodeString(codecSelferC_UTF8100, string(x.StatusDescription))
 49041  				}
 49042  			} else {
 49043  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 49044  				r.EncodeString(codecSelferC_UTF8100, string("StatusDescription"))
 49045  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 49046  				yym32 := z.EncBinary()
 49047  				_ = yym32
 49048  				if false {
 49049  				} else {
 49050  					r.EncodeString(codecSelferC_UTF8100, string(x.StatusDescription))
 49051  				}
 49052  			}
 49053  			if yyr2 || yy2arr2 {
 49054  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 49055  				if x.JobSummary == nil {
 49056  					r.EncodeNil()
 49057  				} else {
 49058  					x.JobSummary.CodecEncodeSelf(e)
 49059  				}
 49060  			} else {
 49061  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 49062  				r.EncodeString(codecSelferC_UTF8100, string("JobSummary"))
 49063  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 49064  				if x.JobSummary == nil {
 49065  					r.EncodeNil()
 49066  				} else {
 49067  					x.JobSummary.CodecEncodeSelf(e)
 49068  				}
 49069  			}
 49070  			if yyr2 || yy2arr2 {
 49071  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 49072  				yym37 := z.EncBinary()
 49073  				_ = yym37
 49074  				if false {
 49075  				} else {
 49076  					r.EncodeUint(uint64(x.CreateIndex))
 49077  				}
 49078  			} else {
 49079  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 49080  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 49081  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 49082  				yym38 := z.EncBinary()
 49083  				_ = yym38
 49084  				if false {
 49085  				} else {
 49086  					r.EncodeUint(uint64(x.CreateIndex))
 49087  				}
 49088  			}
 49089  			if yyr2 || yy2arr2 {
 49090  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 49091  				yym40 := z.EncBinary()
 49092  				_ = yym40
 49093  				if false {
 49094  				} else {
 49095  					r.EncodeUint(uint64(x.ModifyIndex))
 49096  				}
 49097  			} else {
 49098  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 49099  				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
 49100  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 49101  				yym41 := z.EncBinary()
 49102  				_ = yym41
 49103  				if false {
 49104  				} else {
 49105  					r.EncodeUint(uint64(x.ModifyIndex))
 49106  				}
 49107  			}
 49108  			if yyr2 || yy2arr2 {
 49109  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 49110  				yym43 := z.EncBinary()
 49111  				_ = yym43
 49112  				if false {
 49113  				} else {
 49114  					r.EncodeUint(uint64(x.JobModifyIndex))
 49115  				}
 49116  			} else {
 49117  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 49118  				r.EncodeString(codecSelferC_UTF8100, string("JobModifyIndex"))
 49119  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 49120  				yym44 := z.EncBinary()
 49121  				_ = yym44
 49122  				if false {
 49123  				} else {
 49124  					r.EncodeUint(uint64(x.JobModifyIndex))
 49125  				}
 49126  			}
 49127  			if yyr2 || yy2arr2 {
 49128  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 49129  				yym46 := z.EncBinary()
 49130  				_ = yym46
 49131  				if false {
 49132  				} else {
 49133  					r.EncodeInt(int64(x.SubmitTime))
 49134  				}
 49135  			} else {
 49136  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 49137  				r.EncodeString(codecSelferC_UTF8100, string("SubmitTime"))
 49138  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 49139  				yym47 := z.EncBinary()
 49140  				_ = yym47
 49141  				if false {
 49142  				} else {
 49143  					r.EncodeInt(int64(x.SubmitTime))
 49144  				}
 49145  			}
 49146  			if yyr2 || yy2arr2 {
 49147  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 49148  			} else {
 49149  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 49150  			}
 49151  		}
 49152  	}
 49153  }
 49154  
 49155  func (x *JobListStub) CodecDecodeSelf(d *codec1978.Decoder) {
 49156  	var h codecSelfer100
 49157  	z, r := codec1978.GenHelperDecoder(d)
 49158  	_, _, _ = h, z, r
 49159  	yym1 := z.DecBinary()
 49160  	_ = yym1
 49161  	if false {
 49162  	} else if z.HasExtensions() && z.DecExt(x) {
 49163  	} else {
 49164  		yyct2 := r.ContainerType()
 49165  		if yyct2 == codecSelferValueTypeMap100 {
 49166  			yyl2 := r.ReadMapStart()
 49167  			if yyl2 == 0 {
 49168  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 49169  			} else {
 49170  				x.codecDecodeSelfFromMap(yyl2, d)
 49171  			}
 49172  		} else if yyct2 == codecSelferValueTypeArray100 {
 49173  			yyl2 := r.ReadArrayStart()
 49174  			if yyl2 == 0 {
 49175  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49176  			} else {
 49177  				x.codecDecodeSelfFromArray(yyl2, d)
 49178  			}
 49179  		} else {
 49180  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 49181  		}
 49182  	}
 49183  }
 49184  
 49185  func (x *JobListStub) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 49186  	var h codecSelfer100
 49187  	z, r := codec1978.GenHelperDecoder(d)
 49188  	_, _, _ = h, z, r
 49189  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 49190  	_ = yys3Slc
 49191  	var yyhl3 bool = l >= 0
 49192  	for yyj3 := 0; ; yyj3++ {
 49193  		if yyhl3 {
 49194  			if yyj3 >= l {
 49195  				break
 49196  			}
 49197  		} else {
 49198  			if r.CheckBreak() {
 49199  				break
 49200  			}
 49201  		}
 49202  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 49203  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 49204  		yys3 := string(yys3Slc)
 49205  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 49206  		switch yys3 {
 49207  		case "ID":
 49208  			if r.TryDecodeAsNil() {
 49209  				x.ID = ""
 49210  			} else {
 49211  				yyv4 := &x.ID
 49212  				yym5 := z.DecBinary()
 49213  				_ = yym5
 49214  				if false {
 49215  				} else {
 49216  					*((*string)(yyv4)) = r.DecodeString()
 49217  				}
 49218  			}
 49219  		case "ParentID":
 49220  			if r.TryDecodeAsNil() {
 49221  				x.ParentID = ""
 49222  			} else {
 49223  				yyv6 := &x.ParentID
 49224  				yym7 := z.DecBinary()
 49225  				_ = yym7
 49226  				if false {
 49227  				} else {
 49228  					*((*string)(yyv6)) = r.DecodeString()
 49229  				}
 49230  			}
 49231  		case "Name":
 49232  			if r.TryDecodeAsNil() {
 49233  				x.Name = ""
 49234  			} else {
 49235  				yyv8 := &x.Name
 49236  				yym9 := z.DecBinary()
 49237  				_ = yym9
 49238  				if false {
 49239  				} else {
 49240  					*((*string)(yyv8)) = r.DecodeString()
 49241  				}
 49242  			}
 49243  		case "Type":
 49244  			if r.TryDecodeAsNil() {
 49245  				x.Type = ""
 49246  			} else {
 49247  				yyv10 := &x.Type
 49248  				yym11 := z.DecBinary()
 49249  				_ = yym11
 49250  				if false {
 49251  				} else {
 49252  					*((*string)(yyv10)) = r.DecodeString()
 49253  				}
 49254  			}
 49255  		case "Priority":
 49256  			if r.TryDecodeAsNil() {
 49257  				x.Priority = 0
 49258  			} else {
 49259  				yyv12 := &x.Priority
 49260  				yym13 := z.DecBinary()
 49261  				_ = yym13
 49262  				if false {
 49263  				} else {
 49264  					*((*int)(yyv12)) = int(r.DecodeInt(codecSelferBitsize100))
 49265  				}
 49266  			}
 49267  		case "Periodic":
 49268  			if r.TryDecodeAsNil() {
 49269  				x.Periodic = false
 49270  			} else {
 49271  				yyv14 := &x.Periodic
 49272  				yym15 := z.DecBinary()
 49273  				_ = yym15
 49274  				if false {
 49275  				} else {
 49276  					*((*bool)(yyv14)) = r.DecodeBool()
 49277  				}
 49278  			}
 49279  		case "ParameterizedJob":
 49280  			if r.TryDecodeAsNil() {
 49281  				x.ParameterizedJob = false
 49282  			} else {
 49283  				yyv16 := &x.ParameterizedJob
 49284  				yym17 := z.DecBinary()
 49285  				_ = yym17
 49286  				if false {
 49287  				} else {
 49288  					*((*bool)(yyv16)) = r.DecodeBool()
 49289  				}
 49290  			}
 49291  		case "Stop":
 49292  			if r.TryDecodeAsNil() {
 49293  				x.Stop = false
 49294  			} else {
 49295  				yyv18 := &x.Stop
 49296  				yym19 := z.DecBinary()
 49297  				_ = yym19
 49298  				if false {
 49299  				} else {
 49300  					*((*bool)(yyv18)) = r.DecodeBool()
 49301  				}
 49302  			}
 49303  		case "Status":
 49304  			if r.TryDecodeAsNil() {
 49305  				x.Status = ""
 49306  			} else {
 49307  				yyv20 := &x.Status
 49308  				yym21 := z.DecBinary()
 49309  				_ = yym21
 49310  				if false {
 49311  				} else {
 49312  					*((*string)(yyv20)) = r.DecodeString()
 49313  				}
 49314  			}
 49315  		case "StatusDescription":
 49316  			if r.TryDecodeAsNil() {
 49317  				x.StatusDescription = ""
 49318  			} else {
 49319  				yyv22 := &x.StatusDescription
 49320  				yym23 := z.DecBinary()
 49321  				_ = yym23
 49322  				if false {
 49323  				} else {
 49324  					*((*string)(yyv22)) = r.DecodeString()
 49325  				}
 49326  			}
 49327  		case "JobSummary":
 49328  			if r.TryDecodeAsNil() {
 49329  				if x.JobSummary != nil {
 49330  					x.JobSummary = nil
 49331  				}
 49332  			} else {
 49333  				if x.JobSummary == nil {
 49334  					x.JobSummary = new(JobSummary)
 49335  				}
 49336  				x.JobSummary.CodecDecodeSelf(d)
 49337  			}
 49338  		case "CreateIndex":
 49339  			if r.TryDecodeAsNil() {
 49340  				x.CreateIndex = 0
 49341  			} else {
 49342  				yyv25 := &x.CreateIndex
 49343  				yym26 := z.DecBinary()
 49344  				_ = yym26
 49345  				if false {
 49346  				} else {
 49347  					*((*uint64)(yyv25)) = uint64(r.DecodeUint(64))
 49348  				}
 49349  			}
 49350  		case "ModifyIndex":
 49351  			if r.TryDecodeAsNil() {
 49352  				x.ModifyIndex = 0
 49353  			} else {
 49354  				yyv27 := &x.ModifyIndex
 49355  				yym28 := z.DecBinary()
 49356  				_ = yym28
 49357  				if false {
 49358  				} else {
 49359  					*((*uint64)(yyv27)) = uint64(r.DecodeUint(64))
 49360  				}
 49361  			}
 49362  		case "JobModifyIndex":
 49363  			if r.TryDecodeAsNil() {
 49364  				x.JobModifyIndex = 0
 49365  			} else {
 49366  				yyv29 := &x.JobModifyIndex
 49367  				yym30 := z.DecBinary()
 49368  				_ = yym30
 49369  				if false {
 49370  				} else {
 49371  					*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
 49372  				}
 49373  			}
 49374  		case "SubmitTime":
 49375  			if r.TryDecodeAsNil() {
 49376  				x.SubmitTime = 0
 49377  			} else {
 49378  				yyv31 := &x.SubmitTime
 49379  				yym32 := z.DecBinary()
 49380  				_ = yym32
 49381  				if false {
 49382  				} else {
 49383  					*((*int64)(yyv31)) = int64(r.DecodeInt(64))
 49384  				}
 49385  			}
 49386  		default:
 49387  			z.DecStructFieldNotFound(-1, yys3)
 49388  		} // end switch yys3
 49389  	} // end for yyj3
 49390  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 49391  }
 49392  
 49393  func (x *JobListStub) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 49394  	var h codecSelfer100
 49395  	z, r := codec1978.GenHelperDecoder(d)
 49396  	_, _, _ = h, z, r
 49397  	var yyj33 int
 49398  	var yyb33 bool
 49399  	var yyhl33 bool = l >= 0
 49400  	yyj33++
 49401  	if yyhl33 {
 49402  		yyb33 = yyj33 > l
 49403  	} else {
 49404  		yyb33 = r.CheckBreak()
 49405  	}
 49406  	if yyb33 {
 49407  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49408  		return
 49409  	}
 49410  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49411  	if r.TryDecodeAsNil() {
 49412  		x.ID = ""
 49413  	} else {
 49414  		yyv34 := &x.ID
 49415  		yym35 := z.DecBinary()
 49416  		_ = yym35
 49417  		if false {
 49418  		} else {
 49419  			*((*string)(yyv34)) = r.DecodeString()
 49420  		}
 49421  	}
 49422  	yyj33++
 49423  	if yyhl33 {
 49424  		yyb33 = yyj33 > l
 49425  	} else {
 49426  		yyb33 = r.CheckBreak()
 49427  	}
 49428  	if yyb33 {
 49429  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49430  		return
 49431  	}
 49432  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49433  	if r.TryDecodeAsNil() {
 49434  		x.ParentID = ""
 49435  	} else {
 49436  		yyv36 := &x.ParentID
 49437  		yym37 := z.DecBinary()
 49438  		_ = yym37
 49439  		if false {
 49440  		} else {
 49441  			*((*string)(yyv36)) = r.DecodeString()
 49442  		}
 49443  	}
 49444  	yyj33++
 49445  	if yyhl33 {
 49446  		yyb33 = yyj33 > l
 49447  	} else {
 49448  		yyb33 = r.CheckBreak()
 49449  	}
 49450  	if yyb33 {
 49451  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49452  		return
 49453  	}
 49454  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49455  	if r.TryDecodeAsNil() {
 49456  		x.Name = ""
 49457  	} else {
 49458  		yyv38 := &x.Name
 49459  		yym39 := z.DecBinary()
 49460  		_ = yym39
 49461  		if false {
 49462  		} else {
 49463  			*((*string)(yyv38)) = r.DecodeString()
 49464  		}
 49465  	}
 49466  	yyj33++
 49467  	if yyhl33 {
 49468  		yyb33 = yyj33 > l
 49469  	} else {
 49470  		yyb33 = r.CheckBreak()
 49471  	}
 49472  	if yyb33 {
 49473  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49474  		return
 49475  	}
 49476  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49477  	if r.TryDecodeAsNil() {
 49478  		x.Type = ""
 49479  	} else {
 49480  		yyv40 := &x.Type
 49481  		yym41 := z.DecBinary()
 49482  		_ = yym41
 49483  		if false {
 49484  		} else {
 49485  			*((*string)(yyv40)) = r.DecodeString()
 49486  		}
 49487  	}
 49488  	yyj33++
 49489  	if yyhl33 {
 49490  		yyb33 = yyj33 > l
 49491  	} else {
 49492  		yyb33 = r.CheckBreak()
 49493  	}
 49494  	if yyb33 {
 49495  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49496  		return
 49497  	}
 49498  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49499  	if r.TryDecodeAsNil() {
 49500  		x.Priority = 0
 49501  	} else {
 49502  		yyv42 := &x.Priority
 49503  		yym43 := z.DecBinary()
 49504  		_ = yym43
 49505  		if false {
 49506  		} else {
 49507  			*((*int)(yyv42)) = int(r.DecodeInt(codecSelferBitsize100))
 49508  		}
 49509  	}
 49510  	yyj33++
 49511  	if yyhl33 {
 49512  		yyb33 = yyj33 > l
 49513  	} else {
 49514  		yyb33 = r.CheckBreak()
 49515  	}
 49516  	if yyb33 {
 49517  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49518  		return
 49519  	}
 49520  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49521  	if r.TryDecodeAsNil() {
 49522  		x.Periodic = false
 49523  	} else {
 49524  		yyv44 := &x.Periodic
 49525  		yym45 := z.DecBinary()
 49526  		_ = yym45
 49527  		if false {
 49528  		} else {
 49529  			*((*bool)(yyv44)) = r.DecodeBool()
 49530  		}
 49531  	}
 49532  	yyj33++
 49533  	if yyhl33 {
 49534  		yyb33 = yyj33 > l
 49535  	} else {
 49536  		yyb33 = r.CheckBreak()
 49537  	}
 49538  	if yyb33 {
 49539  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49540  		return
 49541  	}
 49542  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49543  	if r.TryDecodeAsNil() {
 49544  		x.ParameterizedJob = false
 49545  	} else {
 49546  		yyv46 := &x.ParameterizedJob
 49547  		yym47 := z.DecBinary()
 49548  		_ = yym47
 49549  		if false {
 49550  		} else {
 49551  			*((*bool)(yyv46)) = r.DecodeBool()
 49552  		}
 49553  	}
 49554  	yyj33++
 49555  	if yyhl33 {
 49556  		yyb33 = yyj33 > l
 49557  	} else {
 49558  		yyb33 = r.CheckBreak()
 49559  	}
 49560  	if yyb33 {
 49561  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49562  		return
 49563  	}
 49564  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49565  	if r.TryDecodeAsNil() {
 49566  		x.Stop = false
 49567  	} else {
 49568  		yyv48 := &x.Stop
 49569  		yym49 := z.DecBinary()
 49570  		_ = yym49
 49571  		if false {
 49572  		} else {
 49573  			*((*bool)(yyv48)) = r.DecodeBool()
 49574  		}
 49575  	}
 49576  	yyj33++
 49577  	if yyhl33 {
 49578  		yyb33 = yyj33 > l
 49579  	} else {
 49580  		yyb33 = r.CheckBreak()
 49581  	}
 49582  	if yyb33 {
 49583  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49584  		return
 49585  	}
 49586  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49587  	if r.TryDecodeAsNil() {
 49588  		x.Status = ""
 49589  	} else {
 49590  		yyv50 := &x.Status
 49591  		yym51 := z.DecBinary()
 49592  		_ = yym51
 49593  		if false {
 49594  		} else {
 49595  			*((*string)(yyv50)) = r.DecodeString()
 49596  		}
 49597  	}
 49598  	yyj33++
 49599  	if yyhl33 {
 49600  		yyb33 = yyj33 > l
 49601  	} else {
 49602  		yyb33 = r.CheckBreak()
 49603  	}
 49604  	if yyb33 {
 49605  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49606  		return
 49607  	}
 49608  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49609  	if r.TryDecodeAsNil() {
 49610  		x.StatusDescription = ""
 49611  	} else {
 49612  		yyv52 := &x.StatusDescription
 49613  		yym53 := z.DecBinary()
 49614  		_ = yym53
 49615  		if false {
 49616  		} else {
 49617  			*((*string)(yyv52)) = r.DecodeString()
 49618  		}
 49619  	}
 49620  	yyj33++
 49621  	if yyhl33 {
 49622  		yyb33 = yyj33 > l
 49623  	} else {
 49624  		yyb33 = r.CheckBreak()
 49625  	}
 49626  	if yyb33 {
 49627  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49628  		return
 49629  	}
 49630  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49631  	if r.TryDecodeAsNil() {
 49632  		if x.JobSummary != nil {
 49633  			x.JobSummary = nil
 49634  		}
 49635  	} else {
 49636  		if x.JobSummary == nil {
 49637  			x.JobSummary = new(JobSummary)
 49638  		}
 49639  		x.JobSummary.CodecDecodeSelf(d)
 49640  	}
 49641  	yyj33++
 49642  	if yyhl33 {
 49643  		yyb33 = yyj33 > l
 49644  	} else {
 49645  		yyb33 = r.CheckBreak()
 49646  	}
 49647  	if yyb33 {
 49648  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49649  		return
 49650  	}
 49651  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49652  	if r.TryDecodeAsNil() {
 49653  		x.CreateIndex = 0
 49654  	} else {
 49655  		yyv55 := &x.CreateIndex
 49656  		yym56 := z.DecBinary()
 49657  		_ = yym56
 49658  		if false {
 49659  		} else {
 49660  			*((*uint64)(yyv55)) = uint64(r.DecodeUint(64))
 49661  		}
 49662  	}
 49663  	yyj33++
 49664  	if yyhl33 {
 49665  		yyb33 = yyj33 > l
 49666  	} else {
 49667  		yyb33 = r.CheckBreak()
 49668  	}
 49669  	if yyb33 {
 49670  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49671  		return
 49672  	}
 49673  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49674  	if r.TryDecodeAsNil() {
 49675  		x.ModifyIndex = 0
 49676  	} else {
 49677  		yyv57 := &x.ModifyIndex
 49678  		yym58 := z.DecBinary()
 49679  		_ = yym58
 49680  		if false {
 49681  		} else {
 49682  			*((*uint64)(yyv57)) = uint64(r.DecodeUint(64))
 49683  		}
 49684  	}
 49685  	yyj33++
 49686  	if yyhl33 {
 49687  		yyb33 = yyj33 > l
 49688  	} else {
 49689  		yyb33 = r.CheckBreak()
 49690  	}
 49691  	if yyb33 {
 49692  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49693  		return
 49694  	}
 49695  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49696  	if r.TryDecodeAsNil() {
 49697  		x.JobModifyIndex = 0
 49698  	} else {
 49699  		yyv59 := &x.JobModifyIndex
 49700  		yym60 := z.DecBinary()
 49701  		_ = yym60
 49702  		if false {
 49703  		} else {
 49704  			*((*uint64)(yyv59)) = uint64(r.DecodeUint(64))
 49705  		}
 49706  	}
 49707  	yyj33++
 49708  	if yyhl33 {
 49709  		yyb33 = yyj33 > l
 49710  	} else {
 49711  		yyb33 = r.CheckBreak()
 49712  	}
 49713  	if yyb33 {
 49714  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49715  		return
 49716  	}
 49717  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49718  	if r.TryDecodeAsNil() {
 49719  		x.SubmitTime = 0
 49720  	} else {
 49721  		yyv61 := &x.SubmitTime
 49722  		yym62 := z.DecBinary()
 49723  		_ = yym62
 49724  		if false {
 49725  		} else {
 49726  			*((*int64)(yyv61)) = int64(r.DecodeInt(64))
 49727  		}
 49728  	}
 49729  	for {
 49730  		yyj33++
 49731  		if yyhl33 {
 49732  			yyb33 = yyj33 > l
 49733  		} else {
 49734  			yyb33 = r.CheckBreak()
 49735  		}
 49736  		if yyb33 {
 49737  			break
 49738  		}
 49739  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 49740  		z.DecStructFieldNotFound(yyj33-1, "")
 49741  	}
 49742  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49743  }
 49744  
 49745  func (x *JobSummary) CodecEncodeSelf(e *codec1978.Encoder) {
 49746  	var h codecSelfer100
 49747  	z, r := codec1978.GenHelperEncoder(e)
 49748  	_, _, _ = h, z, r
 49749  	if x == nil {
 49750  		r.EncodeNil()
 49751  	} else {
 49752  		yym1 := z.EncBinary()
 49753  		_ = yym1
 49754  		if false {
 49755  		} else if z.HasExtensions() && z.EncExt(x) {
 49756  		} else {
 49757  			yysep2 := !z.EncBinary()
 49758  			yy2arr2 := z.EncBasicHandle().StructToArray
 49759  			var yyq2 [6]bool
 49760  			_, _, _ = yysep2, yyq2, yy2arr2
 49761  			const yyr2 bool = false
 49762  			var yynn2 int
 49763  			if yyr2 || yy2arr2 {
 49764  				r.EncodeArrayStart(6)
 49765  			} else {
 49766  				yynn2 = 6
 49767  				for _, b := range yyq2 {
 49768  					if b {
 49769  						yynn2++
 49770  					}
 49771  				}
 49772  				r.EncodeMapStart(yynn2)
 49773  				yynn2 = 0
 49774  			}
 49775  			if yyr2 || yy2arr2 {
 49776  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 49777  				yym4 := z.EncBinary()
 49778  				_ = yym4
 49779  				if false {
 49780  				} else {
 49781  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 49782  				}
 49783  			} else {
 49784  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 49785  				r.EncodeString(codecSelferC_UTF8100, string("JobID"))
 49786  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 49787  				yym5 := z.EncBinary()
 49788  				_ = yym5
 49789  				if false {
 49790  				} else {
 49791  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 49792  				}
 49793  			}
 49794  			if yyr2 || yy2arr2 {
 49795  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 49796  				yym7 := z.EncBinary()
 49797  				_ = yym7
 49798  				if false {
 49799  				} else {
 49800  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 49801  				}
 49802  			} else {
 49803  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 49804  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 49805  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 49806  				yym8 := z.EncBinary()
 49807  				_ = yym8
 49808  				if false {
 49809  				} else {
 49810  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 49811  				}
 49812  			}
 49813  			if yyr2 || yy2arr2 {
 49814  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 49815  				if x.Summary == nil {
 49816  					r.EncodeNil()
 49817  				} else {
 49818  					yym10 := z.EncBinary()
 49819  					_ = yym10
 49820  					if false {
 49821  					} else {
 49822  						h.encMapstringTaskGroupSummary((map[string]TaskGroupSummary)(x.Summary), e)
 49823  					}
 49824  				}
 49825  			} else {
 49826  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 49827  				r.EncodeString(codecSelferC_UTF8100, string("Summary"))
 49828  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 49829  				if x.Summary == nil {
 49830  					r.EncodeNil()
 49831  				} else {
 49832  					yym11 := z.EncBinary()
 49833  					_ = yym11
 49834  					if false {
 49835  					} else {
 49836  						h.encMapstringTaskGroupSummary((map[string]TaskGroupSummary)(x.Summary), e)
 49837  					}
 49838  				}
 49839  			}
 49840  			if yyr2 || yy2arr2 {
 49841  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 49842  				if x.Children == nil {
 49843  					r.EncodeNil()
 49844  				} else {
 49845  					x.Children.CodecEncodeSelf(e)
 49846  				}
 49847  			} else {
 49848  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 49849  				r.EncodeString(codecSelferC_UTF8100, string("Children"))
 49850  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 49851  				if x.Children == nil {
 49852  					r.EncodeNil()
 49853  				} else {
 49854  					x.Children.CodecEncodeSelf(e)
 49855  				}
 49856  			}
 49857  			if yyr2 || yy2arr2 {
 49858  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 49859  				yym16 := z.EncBinary()
 49860  				_ = yym16
 49861  				if false {
 49862  				} else {
 49863  					r.EncodeUint(uint64(x.CreateIndex))
 49864  				}
 49865  			} else {
 49866  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 49867  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 49868  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 49869  				yym17 := z.EncBinary()
 49870  				_ = yym17
 49871  				if false {
 49872  				} else {
 49873  					r.EncodeUint(uint64(x.CreateIndex))
 49874  				}
 49875  			}
 49876  			if yyr2 || yy2arr2 {
 49877  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 49878  				yym19 := z.EncBinary()
 49879  				_ = yym19
 49880  				if false {
 49881  				} else {
 49882  					r.EncodeUint(uint64(x.ModifyIndex))
 49883  				}
 49884  			} else {
 49885  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 49886  				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
 49887  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 49888  				yym20 := z.EncBinary()
 49889  				_ = yym20
 49890  				if false {
 49891  				} else {
 49892  					r.EncodeUint(uint64(x.ModifyIndex))
 49893  				}
 49894  			}
 49895  			if yyr2 || yy2arr2 {
 49896  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 49897  			} else {
 49898  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 49899  			}
 49900  		}
 49901  	}
 49902  }
 49903  
 49904  func (x *JobSummary) CodecDecodeSelf(d *codec1978.Decoder) {
 49905  	var h codecSelfer100
 49906  	z, r := codec1978.GenHelperDecoder(d)
 49907  	_, _, _ = h, z, r
 49908  	yym1 := z.DecBinary()
 49909  	_ = yym1
 49910  	if false {
 49911  	} else if z.HasExtensions() && z.DecExt(x) {
 49912  	} else {
 49913  		yyct2 := r.ContainerType()
 49914  		if yyct2 == codecSelferValueTypeMap100 {
 49915  			yyl2 := r.ReadMapStart()
 49916  			if yyl2 == 0 {
 49917  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 49918  			} else {
 49919  				x.codecDecodeSelfFromMap(yyl2, d)
 49920  			}
 49921  		} else if yyct2 == codecSelferValueTypeArray100 {
 49922  			yyl2 := r.ReadArrayStart()
 49923  			if yyl2 == 0 {
 49924  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 49925  			} else {
 49926  				x.codecDecodeSelfFromArray(yyl2, d)
 49927  			}
 49928  		} else {
 49929  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 49930  		}
 49931  	}
 49932  }
 49933  
 49934  func (x *JobSummary) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 49935  	var h codecSelfer100
 49936  	z, r := codec1978.GenHelperDecoder(d)
 49937  	_, _, _ = h, z, r
 49938  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 49939  	_ = yys3Slc
 49940  	var yyhl3 bool = l >= 0
 49941  	for yyj3 := 0; ; yyj3++ {
 49942  		if yyhl3 {
 49943  			if yyj3 >= l {
 49944  				break
 49945  			}
 49946  		} else {
 49947  			if r.CheckBreak() {
 49948  				break
 49949  			}
 49950  		}
 49951  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 49952  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 49953  		yys3 := string(yys3Slc)
 49954  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 49955  		switch yys3 {
 49956  		case "JobID":
 49957  			if r.TryDecodeAsNil() {
 49958  				x.JobID = ""
 49959  			} else {
 49960  				yyv4 := &x.JobID
 49961  				yym5 := z.DecBinary()
 49962  				_ = yym5
 49963  				if false {
 49964  				} else {
 49965  					*((*string)(yyv4)) = r.DecodeString()
 49966  				}
 49967  			}
 49968  		case "Namespace":
 49969  			if r.TryDecodeAsNil() {
 49970  				x.Namespace = ""
 49971  			} else {
 49972  				yyv6 := &x.Namespace
 49973  				yym7 := z.DecBinary()
 49974  				_ = yym7
 49975  				if false {
 49976  				} else {
 49977  					*((*string)(yyv6)) = r.DecodeString()
 49978  				}
 49979  			}
 49980  		case "Summary":
 49981  			if r.TryDecodeAsNil() {
 49982  				x.Summary = nil
 49983  			} else {
 49984  				yyv8 := &x.Summary
 49985  				yym9 := z.DecBinary()
 49986  				_ = yym9
 49987  				if false {
 49988  				} else {
 49989  					h.decMapstringTaskGroupSummary((*map[string]TaskGroupSummary)(yyv8), d)
 49990  				}
 49991  			}
 49992  		case "Children":
 49993  			if r.TryDecodeAsNil() {
 49994  				if x.Children != nil {
 49995  					x.Children = nil
 49996  				}
 49997  			} else {
 49998  				if x.Children == nil {
 49999  					x.Children = new(JobChildrenSummary)
 50000  				}
 50001  				x.Children.CodecDecodeSelf(d)
 50002  			}
 50003  		case "CreateIndex":
 50004  			if r.TryDecodeAsNil() {
 50005  				x.CreateIndex = 0
 50006  			} else {
 50007  				yyv11 := &x.CreateIndex
 50008  				yym12 := z.DecBinary()
 50009  				_ = yym12
 50010  				if false {
 50011  				} else {
 50012  					*((*uint64)(yyv11)) = uint64(r.DecodeUint(64))
 50013  				}
 50014  			}
 50015  		case "ModifyIndex":
 50016  			if r.TryDecodeAsNil() {
 50017  				x.ModifyIndex = 0
 50018  			} else {
 50019  				yyv13 := &x.ModifyIndex
 50020  				yym14 := z.DecBinary()
 50021  				_ = yym14
 50022  				if false {
 50023  				} else {
 50024  					*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 50025  				}
 50026  			}
 50027  		default:
 50028  			z.DecStructFieldNotFound(-1, yys3)
 50029  		} // end switch yys3
 50030  	} // end for yyj3
 50031  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 50032  }
 50033  
 50034  func (x *JobSummary) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 50035  	var h codecSelfer100
 50036  	z, r := codec1978.GenHelperDecoder(d)
 50037  	_, _, _ = h, z, r
 50038  	var yyj15 int
 50039  	var yyb15 bool
 50040  	var yyhl15 bool = l >= 0
 50041  	yyj15++
 50042  	if yyhl15 {
 50043  		yyb15 = yyj15 > l
 50044  	} else {
 50045  		yyb15 = r.CheckBreak()
 50046  	}
 50047  	if yyb15 {
 50048  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50049  		return
 50050  	}
 50051  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50052  	if r.TryDecodeAsNil() {
 50053  		x.JobID = ""
 50054  	} else {
 50055  		yyv16 := &x.JobID
 50056  		yym17 := z.DecBinary()
 50057  		_ = yym17
 50058  		if false {
 50059  		} else {
 50060  			*((*string)(yyv16)) = r.DecodeString()
 50061  		}
 50062  	}
 50063  	yyj15++
 50064  	if yyhl15 {
 50065  		yyb15 = yyj15 > l
 50066  	} else {
 50067  		yyb15 = r.CheckBreak()
 50068  	}
 50069  	if yyb15 {
 50070  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50071  		return
 50072  	}
 50073  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50074  	if r.TryDecodeAsNil() {
 50075  		x.Namespace = ""
 50076  	} else {
 50077  		yyv18 := &x.Namespace
 50078  		yym19 := z.DecBinary()
 50079  		_ = yym19
 50080  		if false {
 50081  		} else {
 50082  			*((*string)(yyv18)) = r.DecodeString()
 50083  		}
 50084  	}
 50085  	yyj15++
 50086  	if yyhl15 {
 50087  		yyb15 = yyj15 > l
 50088  	} else {
 50089  		yyb15 = r.CheckBreak()
 50090  	}
 50091  	if yyb15 {
 50092  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50093  		return
 50094  	}
 50095  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50096  	if r.TryDecodeAsNil() {
 50097  		x.Summary = nil
 50098  	} else {
 50099  		yyv20 := &x.Summary
 50100  		yym21 := z.DecBinary()
 50101  		_ = yym21
 50102  		if false {
 50103  		} else {
 50104  			h.decMapstringTaskGroupSummary((*map[string]TaskGroupSummary)(yyv20), d)
 50105  		}
 50106  	}
 50107  	yyj15++
 50108  	if yyhl15 {
 50109  		yyb15 = yyj15 > l
 50110  	} else {
 50111  		yyb15 = r.CheckBreak()
 50112  	}
 50113  	if yyb15 {
 50114  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50115  		return
 50116  	}
 50117  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50118  	if r.TryDecodeAsNil() {
 50119  		if x.Children != nil {
 50120  			x.Children = nil
 50121  		}
 50122  	} else {
 50123  		if x.Children == nil {
 50124  			x.Children = new(JobChildrenSummary)
 50125  		}
 50126  		x.Children.CodecDecodeSelf(d)
 50127  	}
 50128  	yyj15++
 50129  	if yyhl15 {
 50130  		yyb15 = yyj15 > l
 50131  	} else {
 50132  		yyb15 = r.CheckBreak()
 50133  	}
 50134  	if yyb15 {
 50135  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50136  		return
 50137  	}
 50138  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50139  	if r.TryDecodeAsNil() {
 50140  		x.CreateIndex = 0
 50141  	} else {
 50142  		yyv23 := &x.CreateIndex
 50143  		yym24 := z.DecBinary()
 50144  		_ = yym24
 50145  		if false {
 50146  		} else {
 50147  			*((*uint64)(yyv23)) = uint64(r.DecodeUint(64))
 50148  		}
 50149  	}
 50150  	yyj15++
 50151  	if yyhl15 {
 50152  		yyb15 = yyj15 > l
 50153  	} else {
 50154  		yyb15 = r.CheckBreak()
 50155  	}
 50156  	if yyb15 {
 50157  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50158  		return
 50159  	}
 50160  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50161  	if r.TryDecodeAsNil() {
 50162  		x.ModifyIndex = 0
 50163  	} else {
 50164  		yyv25 := &x.ModifyIndex
 50165  		yym26 := z.DecBinary()
 50166  		_ = yym26
 50167  		if false {
 50168  		} else {
 50169  			*((*uint64)(yyv25)) = uint64(r.DecodeUint(64))
 50170  		}
 50171  	}
 50172  	for {
 50173  		yyj15++
 50174  		if yyhl15 {
 50175  			yyb15 = yyj15 > l
 50176  		} else {
 50177  			yyb15 = r.CheckBreak()
 50178  		}
 50179  		if yyb15 {
 50180  			break
 50181  		}
 50182  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50183  		z.DecStructFieldNotFound(yyj15-1, "")
 50184  	}
 50185  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50186  }
 50187  
 50188  func (x *JobChildrenSummary) CodecEncodeSelf(e *codec1978.Encoder) {
 50189  	var h codecSelfer100
 50190  	z, r := codec1978.GenHelperEncoder(e)
 50191  	_, _, _ = h, z, r
 50192  	if x == nil {
 50193  		r.EncodeNil()
 50194  	} else {
 50195  		yym1 := z.EncBinary()
 50196  		_ = yym1
 50197  		if false {
 50198  		} else if z.HasExtensions() && z.EncExt(x) {
 50199  		} else {
 50200  			yysep2 := !z.EncBinary()
 50201  			yy2arr2 := z.EncBasicHandle().StructToArray
 50202  			var yyq2 [3]bool
 50203  			_, _, _ = yysep2, yyq2, yy2arr2
 50204  			const yyr2 bool = false
 50205  			var yynn2 int
 50206  			if yyr2 || yy2arr2 {
 50207  				r.EncodeArrayStart(3)
 50208  			} else {
 50209  				yynn2 = 3
 50210  				for _, b := range yyq2 {
 50211  					if b {
 50212  						yynn2++
 50213  					}
 50214  				}
 50215  				r.EncodeMapStart(yynn2)
 50216  				yynn2 = 0
 50217  			}
 50218  			if yyr2 || yy2arr2 {
 50219  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 50220  				yym4 := z.EncBinary()
 50221  				_ = yym4
 50222  				if false {
 50223  				} else {
 50224  					r.EncodeInt(int64(x.Pending))
 50225  				}
 50226  			} else {
 50227  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 50228  				r.EncodeString(codecSelferC_UTF8100, string("Pending"))
 50229  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 50230  				yym5 := z.EncBinary()
 50231  				_ = yym5
 50232  				if false {
 50233  				} else {
 50234  					r.EncodeInt(int64(x.Pending))
 50235  				}
 50236  			}
 50237  			if yyr2 || yy2arr2 {
 50238  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 50239  				yym7 := z.EncBinary()
 50240  				_ = yym7
 50241  				if false {
 50242  				} else {
 50243  					r.EncodeInt(int64(x.Running))
 50244  				}
 50245  			} else {
 50246  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 50247  				r.EncodeString(codecSelferC_UTF8100, string("Running"))
 50248  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 50249  				yym8 := z.EncBinary()
 50250  				_ = yym8
 50251  				if false {
 50252  				} else {
 50253  					r.EncodeInt(int64(x.Running))
 50254  				}
 50255  			}
 50256  			if yyr2 || yy2arr2 {
 50257  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 50258  				yym10 := z.EncBinary()
 50259  				_ = yym10
 50260  				if false {
 50261  				} else {
 50262  					r.EncodeInt(int64(x.Dead))
 50263  				}
 50264  			} else {
 50265  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 50266  				r.EncodeString(codecSelferC_UTF8100, string("Dead"))
 50267  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 50268  				yym11 := z.EncBinary()
 50269  				_ = yym11
 50270  				if false {
 50271  				} else {
 50272  					r.EncodeInt(int64(x.Dead))
 50273  				}
 50274  			}
 50275  			if yyr2 || yy2arr2 {
 50276  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 50277  			} else {
 50278  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 50279  			}
 50280  		}
 50281  	}
 50282  }
 50283  
 50284  func (x *JobChildrenSummary) CodecDecodeSelf(d *codec1978.Decoder) {
 50285  	var h codecSelfer100
 50286  	z, r := codec1978.GenHelperDecoder(d)
 50287  	_, _, _ = h, z, r
 50288  	yym1 := z.DecBinary()
 50289  	_ = yym1
 50290  	if false {
 50291  	} else if z.HasExtensions() && z.DecExt(x) {
 50292  	} else {
 50293  		yyct2 := r.ContainerType()
 50294  		if yyct2 == codecSelferValueTypeMap100 {
 50295  			yyl2 := r.ReadMapStart()
 50296  			if yyl2 == 0 {
 50297  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 50298  			} else {
 50299  				x.codecDecodeSelfFromMap(yyl2, d)
 50300  			}
 50301  		} else if yyct2 == codecSelferValueTypeArray100 {
 50302  			yyl2 := r.ReadArrayStart()
 50303  			if yyl2 == 0 {
 50304  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50305  			} else {
 50306  				x.codecDecodeSelfFromArray(yyl2, d)
 50307  			}
 50308  		} else {
 50309  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 50310  		}
 50311  	}
 50312  }
 50313  
 50314  func (x *JobChildrenSummary) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 50315  	var h codecSelfer100
 50316  	z, r := codec1978.GenHelperDecoder(d)
 50317  	_, _, _ = h, z, r
 50318  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 50319  	_ = yys3Slc
 50320  	var yyhl3 bool = l >= 0
 50321  	for yyj3 := 0; ; yyj3++ {
 50322  		if yyhl3 {
 50323  			if yyj3 >= l {
 50324  				break
 50325  			}
 50326  		} else {
 50327  			if r.CheckBreak() {
 50328  				break
 50329  			}
 50330  		}
 50331  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 50332  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 50333  		yys3 := string(yys3Slc)
 50334  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 50335  		switch yys3 {
 50336  		case "Pending":
 50337  			if r.TryDecodeAsNil() {
 50338  				x.Pending = 0
 50339  			} else {
 50340  				yyv4 := &x.Pending
 50341  				yym5 := z.DecBinary()
 50342  				_ = yym5
 50343  				if false {
 50344  				} else {
 50345  					*((*int64)(yyv4)) = int64(r.DecodeInt(64))
 50346  				}
 50347  			}
 50348  		case "Running":
 50349  			if r.TryDecodeAsNil() {
 50350  				x.Running = 0
 50351  			} else {
 50352  				yyv6 := &x.Running
 50353  				yym7 := z.DecBinary()
 50354  				_ = yym7
 50355  				if false {
 50356  				} else {
 50357  					*((*int64)(yyv6)) = int64(r.DecodeInt(64))
 50358  				}
 50359  			}
 50360  		case "Dead":
 50361  			if r.TryDecodeAsNil() {
 50362  				x.Dead = 0
 50363  			} else {
 50364  				yyv8 := &x.Dead
 50365  				yym9 := z.DecBinary()
 50366  				_ = yym9
 50367  				if false {
 50368  				} else {
 50369  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 50370  				}
 50371  			}
 50372  		default:
 50373  			z.DecStructFieldNotFound(-1, yys3)
 50374  		} // end switch yys3
 50375  	} // end for yyj3
 50376  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 50377  }
 50378  
 50379  func (x *JobChildrenSummary) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 50380  	var h codecSelfer100
 50381  	z, r := codec1978.GenHelperDecoder(d)
 50382  	_, _, _ = h, z, r
 50383  	var yyj10 int
 50384  	var yyb10 bool
 50385  	var yyhl10 bool = l >= 0
 50386  	yyj10++
 50387  	if yyhl10 {
 50388  		yyb10 = yyj10 > l
 50389  	} else {
 50390  		yyb10 = r.CheckBreak()
 50391  	}
 50392  	if yyb10 {
 50393  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50394  		return
 50395  	}
 50396  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50397  	if r.TryDecodeAsNil() {
 50398  		x.Pending = 0
 50399  	} else {
 50400  		yyv11 := &x.Pending
 50401  		yym12 := z.DecBinary()
 50402  		_ = yym12
 50403  		if false {
 50404  		} else {
 50405  			*((*int64)(yyv11)) = int64(r.DecodeInt(64))
 50406  		}
 50407  	}
 50408  	yyj10++
 50409  	if yyhl10 {
 50410  		yyb10 = yyj10 > l
 50411  	} else {
 50412  		yyb10 = r.CheckBreak()
 50413  	}
 50414  	if yyb10 {
 50415  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50416  		return
 50417  	}
 50418  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50419  	if r.TryDecodeAsNil() {
 50420  		x.Running = 0
 50421  	} else {
 50422  		yyv13 := &x.Running
 50423  		yym14 := z.DecBinary()
 50424  		_ = yym14
 50425  		if false {
 50426  		} else {
 50427  			*((*int64)(yyv13)) = int64(r.DecodeInt(64))
 50428  		}
 50429  	}
 50430  	yyj10++
 50431  	if yyhl10 {
 50432  		yyb10 = yyj10 > l
 50433  	} else {
 50434  		yyb10 = r.CheckBreak()
 50435  	}
 50436  	if yyb10 {
 50437  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50438  		return
 50439  	}
 50440  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50441  	if r.TryDecodeAsNil() {
 50442  		x.Dead = 0
 50443  	} else {
 50444  		yyv15 := &x.Dead
 50445  		yym16 := z.DecBinary()
 50446  		_ = yym16
 50447  		if false {
 50448  		} else {
 50449  			*((*int64)(yyv15)) = int64(r.DecodeInt(64))
 50450  		}
 50451  	}
 50452  	for {
 50453  		yyj10++
 50454  		if yyhl10 {
 50455  			yyb10 = yyj10 > l
 50456  		} else {
 50457  			yyb10 = r.CheckBreak()
 50458  		}
 50459  		if yyb10 {
 50460  			break
 50461  		}
 50462  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50463  		z.DecStructFieldNotFound(yyj10-1, "")
 50464  	}
 50465  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50466  }
 50467  
 50468  func (x *TaskGroupSummary) CodecEncodeSelf(e *codec1978.Encoder) {
 50469  	var h codecSelfer100
 50470  	z, r := codec1978.GenHelperEncoder(e)
 50471  	_, _, _ = h, z, r
 50472  	if x == nil {
 50473  		r.EncodeNil()
 50474  	} else {
 50475  		yym1 := z.EncBinary()
 50476  		_ = yym1
 50477  		if false {
 50478  		} else if z.HasExtensions() && z.EncExt(x) {
 50479  		} else {
 50480  			yysep2 := !z.EncBinary()
 50481  			yy2arr2 := z.EncBasicHandle().StructToArray
 50482  			var yyq2 [6]bool
 50483  			_, _, _ = yysep2, yyq2, yy2arr2
 50484  			const yyr2 bool = false
 50485  			var yynn2 int
 50486  			if yyr2 || yy2arr2 {
 50487  				r.EncodeArrayStart(6)
 50488  			} else {
 50489  				yynn2 = 6
 50490  				for _, b := range yyq2 {
 50491  					if b {
 50492  						yynn2++
 50493  					}
 50494  				}
 50495  				r.EncodeMapStart(yynn2)
 50496  				yynn2 = 0
 50497  			}
 50498  			if yyr2 || yy2arr2 {
 50499  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 50500  				yym4 := z.EncBinary()
 50501  				_ = yym4
 50502  				if false {
 50503  				} else {
 50504  					r.EncodeInt(int64(x.Queued))
 50505  				}
 50506  			} else {
 50507  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 50508  				r.EncodeString(codecSelferC_UTF8100, string("Queued"))
 50509  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 50510  				yym5 := z.EncBinary()
 50511  				_ = yym5
 50512  				if false {
 50513  				} else {
 50514  					r.EncodeInt(int64(x.Queued))
 50515  				}
 50516  			}
 50517  			if yyr2 || yy2arr2 {
 50518  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 50519  				yym7 := z.EncBinary()
 50520  				_ = yym7
 50521  				if false {
 50522  				} else {
 50523  					r.EncodeInt(int64(x.Complete))
 50524  				}
 50525  			} else {
 50526  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 50527  				r.EncodeString(codecSelferC_UTF8100, string("Complete"))
 50528  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 50529  				yym8 := z.EncBinary()
 50530  				_ = yym8
 50531  				if false {
 50532  				} else {
 50533  					r.EncodeInt(int64(x.Complete))
 50534  				}
 50535  			}
 50536  			if yyr2 || yy2arr2 {
 50537  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 50538  				yym10 := z.EncBinary()
 50539  				_ = yym10
 50540  				if false {
 50541  				} else {
 50542  					r.EncodeInt(int64(x.Failed))
 50543  				}
 50544  			} else {
 50545  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 50546  				r.EncodeString(codecSelferC_UTF8100, string("Failed"))
 50547  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 50548  				yym11 := z.EncBinary()
 50549  				_ = yym11
 50550  				if false {
 50551  				} else {
 50552  					r.EncodeInt(int64(x.Failed))
 50553  				}
 50554  			}
 50555  			if yyr2 || yy2arr2 {
 50556  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 50557  				yym13 := z.EncBinary()
 50558  				_ = yym13
 50559  				if false {
 50560  				} else {
 50561  					r.EncodeInt(int64(x.Running))
 50562  				}
 50563  			} else {
 50564  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 50565  				r.EncodeString(codecSelferC_UTF8100, string("Running"))
 50566  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 50567  				yym14 := z.EncBinary()
 50568  				_ = yym14
 50569  				if false {
 50570  				} else {
 50571  					r.EncodeInt(int64(x.Running))
 50572  				}
 50573  			}
 50574  			if yyr2 || yy2arr2 {
 50575  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 50576  				yym16 := z.EncBinary()
 50577  				_ = yym16
 50578  				if false {
 50579  				} else {
 50580  					r.EncodeInt(int64(x.Starting))
 50581  				}
 50582  			} else {
 50583  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 50584  				r.EncodeString(codecSelferC_UTF8100, string("Starting"))
 50585  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 50586  				yym17 := z.EncBinary()
 50587  				_ = yym17
 50588  				if false {
 50589  				} else {
 50590  					r.EncodeInt(int64(x.Starting))
 50591  				}
 50592  			}
 50593  			if yyr2 || yy2arr2 {
 50594  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 50595  				yym19 := z.EncBinary()
 50596  				_ = yym19
 50597  				if false {
 50598  				} else {
 50599  					r.EncodeInt(int64(x.Lost))
 50600  				}
 50601  			} else {
 50602  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 50603  				r.EncodeString(codecSelferC_UTF8100, string("Lost"))
 50604  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 50605  				yym20 := z.EncBinary()
 50606  				_ = yym20
 50607  				if false {
 50608  				} else {
 50609  					r.EncodeInt(int64(x.Lost))
 50610  				}
 50611  			}
 50612  			if yyr2 || yy2arr2 {
 50613  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 50614  			} else {
 50615  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 50616  			}
 50617  		}
 50618  	}
 50619  }
 50620  
 50621  func (x *TaskGroupSummary) CodecDecodeSelf(d *codec1978.Decoder) {
 50622  	var h codecSelfer100
 50623  	z, r := codec1978.GenHelperDecoder(d)
 50624  	_, _, _ = h, z, r
 50625  	yym1 := z.DecBinary()
 50626  	_ = yym1
 50627  	if false {
 50628  	} else if z.HasExtensions() && z.DecExt(x) {
 50629  	} else {
 50630  		yyct2 := r.ContainerType()
 50631  		if yyct2 == codecSelferValueTypeMap100 {
 50632  			yyl2 := r.ReadMapStart()
 50633  			if yyl2 == 0 {
 50634  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 50635  			} else {
 50636  				x.codecDecodeSelfFromMap(yyl2, d)
 50637  			}
 50638  		} else if yyct2 == codecSelferValueTypeArray100 {
 50639  			yyl2 := r.ReadArrayStart()
 50640  			if yyl2 == 0 {
 50641  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50642  			} else {
 50643  				x.codecDecodeSelfFromArray(yyl2, d)
 50644  			}
 50645  		} else {
 50646  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 50647  		}
 50648  	}
 50649  }
 50650  
 50651  func (x *TaskGroupSummary) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 50652  	var h codecSelfer100
 50653  	z, r := codec1978.GenHelperDecoder(d)
 50654  	_, _, _ = h, z, r
 50655  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 50656  	_ = yys3Slc
 50657  	var yyhl3 bool = l >= 0
 50658  	for yyj3 := 0; ; yyj3++ {
 50659  		if yyhl3 {
 50660  			if yyj3 >= l {
 50661  				break
 50662  			}
 50663  		} else {
 50664  			if r.CheckBreak() {
 50665  				break
 50666  			}
 50667  		}
 50668  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 50669  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 50670  		yys3 := string(yys3Slc)
 50671  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 50672  		switch yys3 {
 50673  		case "Queued":
 50674  			if r.TryDecodeAsNil() {
 50675  				x.Queued = 0
 50676  			} else {
 50677  				yyv4 := &x.Queued
 50678  				yym5 := z.DecBinary()
 50679  				_ = yym5
 50680  				if false {
 50681  				} else {
 50682  					*((*int)(yyv4)) = int(r.DecodeInt(codecSelferBitsize100))
 50683  				}
 50684  			}
 50685  		case "Complete":
 50686  			if r.TryDecodeAsNil() {
 50687  				x.Complete = 0
 50688  			} else {
 50689  				yyv6 := &x.Complete
 50690  				yym7 := z.DecBinary()
 50691  				_ = yym7
 50692  				if false {
 50693  				} else {
 50694  					*((*int)(yyv6)) = int(r.DecodeInt(codecSelferBitsize100))
 50695  				}
 50696  			}
 50697  		case "Failed":
 50698  			if r.TryDecodeAsNil() {
 50699  				x.Failed = 0
 50700  			} else {
 50701  				yyv8 := &x.Failed
 50702  				yym9 := z.DecBinary()
 50703  				_ = yym9
 50704  				if false {
 50705  				} else {
 50706  					*((*int)(yyv8)) = int(r.DecodeInt(codecSelferBitsize100))
 50707  				}
 50708  			}
 50709  		case "Running":
 50710  			if r.TryDecodeAsNil() {
 50711  				x.Running = 0
 50712  			} else {
 50713  				yyv10 := &x.Running
 50714  				yym11 := z.DecBinary()
 50715  				_ = yym11
 50716  				if false {
 50717  				} else {
 50718  					*((*int)(yyv10)) = int(r.DecodeInt(codecSelferBitsize100))
 50719  				}
 50720  			}
 50721  		case "Starting":
 50722  			if r.TryDecodeAsNil() {
 50723  				x.Starting = 0
 50724  			} else {
 50725  				yyv12 := &x.Starting
 50726  				yym13 := z.DecBinary()
 50727  				_ = yym13
 50728  				if false {
 50729  				} else {
 50730  					*((*int)(yyv12)) = int(r.DecodeInt(codecSelferBitsize100))
 50731  				}
 50732  			}
 50733  		case "Lost":
 50734  			if r.TryDecodeAsNil() {
 50735  				x.Lost = 0
 50736  			} else {
 50737  				yyv14 := &x.Lost
 50738  				yym15 := z.DecBinary()
 50739  				_ = yym15
 50740  				if false {
 50741  				} else {
 50742  					*((*int)(yyv14)) = int(r.DecodeInt(codecSelferBitsize100))
 50743  				}
 50744  			}
 50745  		default:
 50746  			z.DecStructFieldNotFound(-1, yys3)
 50747  		} // end switch yys3
 50748  	} // end for yyj3
 50749  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 50750  }
 50751  
 50752  func (x *TaskGroupSummary) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 50753  	var h codecSelfer100
 50754  	z, r := codec1978.GenHelperDecoder(d)
 50755  	_, _, _ = h, z, r
 50756  	var yyj16 int
 50757  	var yyb16 bool
 50758  	var yyhl16 bool = l >= 0
 50759  	yyj16++
 50760  	if yyhl16 {
 50761  		yyb16 = yyj16 > l
 50762  	} else {
 50763  		yyb16 = r.CheckBreak()
 50764  	}
 50765  	if yyb16 {
 50766  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50767  		return
 50768  	}
 50769  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50770  	if r.TryDecodeAsNil() {
 50771  		x.Queued = 0
 50772  	} else {
 50773  		yyv17 := &x.Queued
 50774  		yym18 := z.DecBinary()
 50775  		_ = yym18
 50776  		if false {
 50777  		} else {
 50778  			*((*int)(yyv17)) = int(r.DecodeInt(codecSelferBitsize100))
 50779  		}
 50780  	}
 50781  	yyj16++
 50782  	if yyhl16 {
 50783  		yyb16 = yyj16 > l
 50784  	} else {
 50785  		yyb16 = r.CheckBreak()
 50786  	}
 50787  	if yyb16 {
 50788  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50789  		return
 50790  	}
 50791  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50792  	if r.TryDecodeAsNil() {
 50793  		x.Complete = 0
 50794  	} else {
 50795  		yyv19 := &x.Complete
 50796  		yym20 := z.DecBinary()
 50797  		_ = yym20
 50798  		if false {
 50799  		} else {
 50800  			*((*int)(yyv19)) = int(r.DecodeInt(codecSelferBitsize100))
 50801  		}
 50802  	}
 50803  	yyj16++
 50804  	if yyhl16 {
 50805  		yyb16 = yyj16 > l
 50806  	} else {
 50807  		yyb16 = r.CheckBreak()
 50808  	}
 50809  	if yyb16 {
 50810  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50811  		return
 50812  	}
 50813  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50814  	if r.TryDecodeAsNil() {
 50815  		x.Failed = 0
 50816  	} else {
 50817  		yyv21 := &x.Failed
 50818  		yym22 := z.DecBinary()
 50819  		_ = yym22
 50820  		if false {
 50821  		} else {
 50822  			*((*int)(yyv21)) = int(r.DecodeInt(codecSelferBitsize100))
 50823  		}
 50824  	}
 50825  	yyj16++
 50826  	if yyhl16 {
 50827  		yyb16 = yyj16 > l
 50828  	} else {
 50829  		yyb16 = r.CheckBreak()
 50830  	}
 50831  	if yyb16 {
 50832  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50833  		return
 50834  	}
 50835  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50836  	if r.TryDecodeAsNil() {
 50837  		x.Running = 0
 50838  	} else {
 50839  		yyv23 := &x.Running
 50840  		yym24 := z.DecBinary()
 50841  		_ = yym24
 50842  		if false {
 50843  		} else {
 50844  			*((*int)(yyv23)) = int(r.DecodeInt(codecSelferBitsize100))
 50845  		}
 50846  	}
 50847  	yyj16++
 50848  	if yyhl16 {
 50849  		yyb16 = yyj16 > l
 50850  	} else {
 50851  		yyb16 = r.CheckBreak()
 50852  	}
 50853  	if yyb16 {
 50854  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50855  		return
 50856  	}
 50857  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50858  	if r.TryDecodeAsNil() {
 50859  		x.Starting = 0
 50860  	} else {
 50861  		yyv25 := &x.Starting
 50862  		yym26 := z.DecBinary()
 50863  		_ = yym26
 50864  		if false {
 50865  		} else {
 50866  			*((*int)(yyv25)) = int(r.DecodeInt(codecSelferBitsize100))
 50867  		}
 50868  	}
 50869  	yyj16++
 50870  	if yyhl16 {
 50871  		yyb16 = yyj16 > l
 50872  	} else {
 50873  		yyb16 = r.CheckBreak()
 50874  	}
 50875  	if yyb16 {
 50876  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50877  		return
 50878  	}
 50879  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50880  	if r.TryDecodeAsNil() {
 50881  		x.Lost = 0
 50882  	} else {
 50883  		yyv27 := &x.Lost
 50884  		yym28 := z.DecBinary()
 50885  		_ = yym28
 50886  		if false {
 50887  		} else {
 50888  			*((*int)(yyv27)) = int(r.DecodeInt(codecSelferBitsize100))
 50889  		}
 50890  	}
 50891  	for {
 50892  		yyj16++
 50893  		if yyhl16 {
 50894  			yyb16 = yyj16 > l
 50895  		} else {
 50896  			yyb16 = r.CheckBreak()
 50897  		}
 50898  		if yyb16 {
 50899  			break
 50900  		}
 50901  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 50902  		z.DecStructFieldNotFound(yyj16-1, "")
 50903  	}
 50904  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 50905  }
 50906  
 50907  func (x *UpdateStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
 50908  	var h codecSelfer100
 50909  	z, r := codec1978.GenHelperEncoder(e)
 50910  	_, _, _ = h, z, r
 50911  	if x == nil {
 50912  		r.EncodeNil()
 50913  	} else {
 50914  		yym1 := z.EncBinary()
 50915  		_ = yym1
 50916  		if false {
 50917  		} else if z.HasExtensions() && z.EncExt(x) {
 50918  		} else {
 50919  			yysep2 := !z.EncBinary()
 50920  			yy2arr2 := z.EncBasicHandle().StructToArray
 50921  			var yyq2 [7]bool
 50922  			_, _, _ = yysep2, yyq2, yy2arr2
 50923  			const yyr2 bool = false
 50924  			var yynn2 int
 50925  			if yyr2 || yy2arr2 {
 50926  				r.EncodeArrayStart(7)
 50927  			} else {
 50928  				yynn2 = 7
 50929  				for _, b := range yyq2 {
 50930  					if b {
 50931  						yynn2++
 50932  					}
 50933  				}
 50934  				r.EncodeMapStart(yynn2)
 50935  				yynn2 = 0
 50936  			}
 50937  			if yyr2 || yy2arr2 {
 50938  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 50939  				yym4 := z.EncBinary()
 50940  				_ = yym4
 50941  				if false {
 50942  				} else if z.HasExtensions() && z.EncExt(x.Stagger) {
 50943  				} else {
 50944  					r.EncodeInt(int64(x.Stagger))
 50945  				}
 50946  			} else {
 50947  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 50948  				r.EncodeString(codecSelferC_UTF8100, string("Stagger"))
 50949  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 50950  				yym5 := z.EncBinary()
 50951  				_ = yym5
 50952  				if false {
 50953  				} else if z.HasExtensions() && z.EncExt(x.Stagger) {
 50954  				} else {
 50955  					r.EncodeInt(int64(x.Stagger))
 50956  				}
 50957  			}
 50958  			if yyr2 || yy2arr2 {
 50959  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 50960  				yym7 := z.EncBinary()
 50961  				_ = yym7
 50962  				if false {
 50963  				} else {
 50964  					r.EncodeInt(int64(x.MaxParallel))
 50965  				}
 50966  			} else {
 50967  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 50968  				r.EncodeString(codecSelferC_UTF8100, string("MaxParallel"))
 50969  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 50970  				yym8 := z.EncBinary()
 50971  				_ = yym8
 50972  				if false {
 50973  				} else {
 50974  					r.EncodeInt(int64(x.MaxParallel))
 50975  				}
 50976  			}
 50977  			if yyr2 || yy2arr2 {
 50978  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 50979  				yym10 := z.EncBinary()
 50980  				_ = yym10
 50981  				if false {
 50982  				} else {
 50983  					r.EncodeString(codecSelferC_UTF8100, string(x.HealthCheck))
 50984  				}
 50985  			} else {
 50986  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 50987  				r.EncodeString(codecSelferC_UTF8100, string("HealthCheck"))
 50988  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 50989  				yym11 := z.EncBinary()
 50990  				_ = yym11
 50991  				if false {
 50992  				} else {
 50993  					r.EncodeString(codecSelferC_UTF8100, string(x.HealthCheck))
 50994  				}
 50995  			}
 50996  			if yyr2 || yy2arr2 {
 50997  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 50998  				yym13 := z.EncBinary()
 50999  				_ = yym13
 51000  				if false {
 51001  				} else if z.HasExtensions() && z.EncExt(x.MinHealthyTime) {
 51002  				} else {
 51003  					r.EncodeInt(int64(x.MinHealthyTime))
 51004  				}
 51005  			} else {
 51006  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 51007  				r.EncodeString(codecSelferC_UTF8100, string("MinHealthyTime"))
 51008  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 51009  				yym14 := z.EncBinary()
 51010  				_ = yym14
 51011  				if false {
 51012  				} else if z.HasExtensions() && z.EncExt(x.MinHealthyTime) {
 51013  				} else {
 51014  					r.EncodeInt(int64(x.MinHealthyTime))
 51015  				}
 51016  			}
 51017  			if yyr2 || yy2arr2 {
 51018  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 51019  				yym16 := z.EncBinary()
 51020  				_ = yym16
 51021  				if false {
 51022  				} else if z.HasExtensions() && z.EncExt(x.HealthyDeadline) {
 51023  				} else {
 51024  					r.EncodeInt(int64(x.HealthyDeadline))
 51025  				}
 51026  			} else {
 51027  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 51028  				r.EncodeString(codecSelferC_UTF8100, string("HealthyDeadline"))
 51029  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 51030  				yym17 := z.EncBinary()
 51031  				_ = yym17
 51032  				if false {
 51033  				} else if z.HasExtensions() && z.EncExt(x.HealthyDeadline) {
 51034  				} else {
 51035  					r.EncodeInt(int64(x.HealthyDeadline))
 51036  				}
 51037  			}
 51038  			if yyr2 || yy2arr2 {
 51039  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 51040  				yym19 := z.EncBinary()
 51041  				_ = yym19
 51042  				if false {
 51043  				} else {
 51044  					r.EncodeBool(bool(x.AutoRevert))
 51045  				}
 51046  			} else {
 51047  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 51048  				r.EncodeString(codecSelferC_UTF8100, string("AutoRevert"))
 51049  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 51050  				yym20 := z.EncBinary()
 51051  				_ = yym20
 51052  				if false {
 51053  				} else {
 51054  					r.EncodeBool(bool(x.AutoRevert))
 51055  				}
 51056  			}
 51057  			if yyr2 || yy2arr2 {
 51058  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 51059  				yym22 := z.EncBinary()
 51060  				_ = yym22
 51061  				if false {
 51062  				} else {
 51063  					r.EncodeInt(int64(x.Canary))
 51064  				}
 51065  			} else {
 51066  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 51067  				r.EncodeString(codecSelferC_UTF8100, string("Canary"))
 51068  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 51069  				yym23 := z.EncBinary()
 51070  				_ = yym23
 51071  				if false {
 51072  				} else {
 51073  					r.EncodeInt(int64(x.Canary))
 51074  				}
 51075  			}
 51076  			if yyr2 || yy2arr2 {
 51077  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 51078  			} else {
 51079  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 51080  			}
 51081  		}
 51082  	}
 51083  }
 51084  
 51085  func (x *UpdateStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
 51086  	var h codecSelfer100
 51087  	z, r := codec1978.GenHelperDecoder(d)
 51088  	_, _, _ = h, z, r
 51089  	yym1 := z.DecBinary()
 51090  	_ = yym1
 51091  	if false {
 51092  	} else if z.HasExtensions() && z.DecExt(x) {
 51093  	} else {
 51094  		yyct2 := r.ContainerType()
 51095  		if yyct2 == codecSelferValueTypeMap100 {
 51096  			yyl2 := r.ReadMapStart()
 51097  			if yyl2 == 0 {
 51098  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 51099  			} else {
 51100  				x.codecDecodeSelfFromMap(yyl2, d)
 51101  			}
 51102  		} else if yyct2 == codecSelferValueTypeArray100 {
 51103  			yyl2 := r.ReadArrayStart()
 51104  			if yyl2 == 0 {
 51105  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51106  			} else {
 51107  				x.codecDecodeSelfFromArray(yyl2, d)
 51108  			}
 51109  		} else {
 51110  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 51111  		}
 51112  	}
 51113  }
 51114  
 51115  func (x *UpdateStrategy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 51116  	var h codecSelfer100
 51117  	z, r := codec1978.GenHelperDecoder(d)
 51118  	_, _, _ = h, z, r
 51119  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 51120  	_ = yys3Slc
 51121  	var yyhl3 bool = l >= 0
 51122  	for yyj3 := 0; ; yyj3++ {
 51123  		if yyhl3 {
 51124  			if yyj3 >= l {
 51125  				break
 51126  			}
 51127  		} else {
 51128  			if r.CheckBreak() {
 51129  				break
 51130  			}
 51131  		}
 51132  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 51133  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 51134  		yys3 := string(yys3Slc)
 51135  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 51136  		switch yys3 {
 51137  		case "Stagger":
 51138  			if r.TryDecodeAsNil() {
 51139  				x.Stagger = 0
 51140  			} else {
 51141  				yyv4 := &x.Stagger
 51142  				yym5 := z.DecBinary()
 51143  				_ = yym5
 51144  				if false {
 51145  				} else if z.HasExtensions() && z.DecExt(yyv4) {
 51146  				} else {
 51147  					*((*int64)(yyv4)) = int64(r.DecodeInt(64))
 51148  				}
 51149  			}
 51150  		case "MaxParallel":
 51151  			if r.TryDecodeAsNil() {
 51152  				x.MaxParallel = 0
 51153  			} else {
 51154  				yyv6 := &x.MaxParallel
 51155  				yym7 := z.DecBinary()
 51156  				_ = yym7
 51157  				if false {
 51158  				} else {
 51159  					*((*int)(yyv6)) = int(r.DecodeInt(codecSelferBitsize100))
 51160  				}
 51161  			}
 51162  		case "HealthCheck":
 51163  			if r.TryDecodeAsNil() {
 51164  				x.HealthCheck = ""
 51165  			} else {
 51166  				yyv8 := &x.HealthCheck
 51167  				yym9 := z.DecBinary()
 51168  				_ = yym9
 51169  				if false {
 51170  				} else {
 51171  					*((*string)(yyv8)) = r.DecodeString()
 51172  				}
 51173  			}
 51174  		case "MinHealthyTime":
 51175  			if r.TryDecodeAsNil() {
 51176  				x.MinHealthyTime = 0
 51177  			} else {
 51178  				yyv10 := &x.MinHealthyTime
 51179  				yym11 := z.DecBinary()
 51180  				_ = yym11
 51181  				if false {
 51182  				} else if z.HasExtensions() && z.DecExt(yyv10) {
 51183  				} else {
 51184  					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
 51185  				}
 51186  			}
 51187  		case "HealthyDeadline":
 51188  			if r.TryDecodeAsNil() {
 51189  				x.HealthyDeadline = 0
 51190  			} else {
 51191  				yyv12 := &x.HealthyDeadline
 51192  				yym13 := z.DecBinary()
 51193  				_ = yym13
 51194  				if false {
 51195  				} else if z.HasExtensions() && z.DecExt(yyv12) {
 51196  				} else {
 51197  					*((*int64)(yyv12)) = int64(r.DecodeInt(64))
 51198  				}
 51199  			}
 51200  		case "AutoRevert":
 51201  			if r.TryDecodeAsNil() {
 51202  				x.AutoRevert = false
 51203  			} else {
 51204  				yyv14 := &x.AutoRevert
 51205  				yym15 := z.DecBinary()
 51206  				_ = yym15
 51207  				if false {
 51208  				} else {
 51209  					*((*bool)(yyv14)) = r.DecodeBool()
 51210  				}
 51211  			}
 51212  		case "Canary":
 51213  			if r.TryDecodeAsNil() {
 51214  				x.Canary = 0
 51215  			} else {
 51216  				yyv16 := &x.Canary
 51217  				yym17 := z.DecBinary()
 51218  				_ = yym17
 51219  				if false {
 51220  				} else {
 51221  					*((*int)(yyv16)) = int(r.DecodeInt(codecSelferBitsize100))
 51222  				}
 51223  			}
 51224  		default:
 51225  			z.DecStructFieldNotFound(-1, yys3)
 51226  		} // end switch yys3
 51227  	} // end for yyj3
 51228  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 51229  }
 51230  
 51231  func (x *UpdateStrategy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 51232  	var h codecSelfer100
 51233  	z, r := codec1978.GenHelperDecoder(d)
 51234  	_, _, _ = h, z, r
 51235  	var yyj18 int
 51236  	var yyb18 bool
 51237  	var yyhl18 bool = l >= 0
 51238  	yyj18++
 51239  	if yyhl18 {
 51240  		yyb18 = yyj18 > l
 51241  	} else {
 51242  		yyb18 = r.CheckBreak()
 51243  	}
 51244  	if yyb18 {
 51245  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51246  		return
 51247  	}
 51248  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 51249  	if r.TryDecodeAsNil() {
 51250  		x.Stagger = 0
 51251  	} else {
 51252  		yyv19 := &x.Stagger
 51253  		yym20 := z.DecBinary()
 51254  		_ = yym20
 51255  		if false {
 51256  		} else if z.HasExtensions() && z.DecExt(yyv19) {
 51257  		} else {
 51258  			*((*int64)(yyv19)) = int64(r.DecodeInt(64))
 51259  		}
 51260  	}
 51261  	yyj18++
 51262  	if yyhl18 {
 51263  		yyb18 = yyj18 > l
 51264  	} else {
 51265  		yyb18 = r.CheckBreak()
 51266  	}
 51267  	if yyb18 {
 51268  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51269  		return
 51270  	}
 51271  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 51272  	if r.TryDecodeAsNil() {
 51273  		x.MaxParallel = 0
 51274  	} else {
 51275  		yyv21 := &x.MaxParallel
 51276  		yym22 := z.DecBinary()
 51277  		_ = yym22
 51278  		if false {
 51279  		} else {
 51280  			*((*int)(yyv21)) = int(r.DecodeInt(codecSelferBitsize100))
 51281  		}
 51282  	}
 51283  	yyj18++
 51284  	if yyhl18 {
 51285  		yyb18 = yyj18 > l
 51286  	} else {
 51287  		yyb18 = r.CheckBreak()
 51288  	}
 51289  	if yyb18 {
 51290  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51291  		return
 51292  	}
 51293  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 51294  	if r.TryDecodeAsNil() {
 51295  		x.HealthCheck = ""
 51296  	} else {
 51297  		yyv23 := &x.HealthCheck
 51298  		yym24 := z.DecBinary()
 51299  		_ = yym24
 51300  		if false {
 51301  		} else {
 51302  			*((*string)(yyv23)) = r.DecodeString()
 51303  		}
 51304  	}
 51305  	yyj18++
 51306  	if yyhl18 {
 51307  		yyb18 = yyj18 > l
 51308  	} else {
 51309  		yyb18 = r.CheckBreak()
 51310  	}
 51311  	if yyb18 {
 51312  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51313  		return
 51314  	}
 51315  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 51316  	if r.TryDecodeAsNil() {
 51317  		x.MinHealthyTime = 0
 51318  	} else {
 51319  		yyv25 := &x.MinHealthyTime
 51320  		yym26 := z.DecBinary()
 51321  		_ = yym26
 51322  		if false {
 51323  		} else if z.HasExtensions() && z.DecExt(yyv25) {
 51324  		} else {
 51325  			*((*int64)(yyv25)) = int64(r.DecodeInt(64))
 51326  		}
 51327  	}
 51328  	yyj18++
 51329  	if yyhl18 {
 51330  		yyb18 = yyj18 > l
 51331  	} else {
 51332  		yyb18 = r.CheckBreak()
 51333  	}
 51334  	if yyb18 {
 51335  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51336  		return
 51337  	}
 51338  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 51339  	if r.TryDecodeAsNil() {
 51340  		x.HealthyDeadline = 0
 51341  	} else {
 51342  		yyv27 := &x.HealthyDeadline
 51343  		yym28 := z.DecBinary()
 51344  		_ = yym28
 51345  		if false {
 51346  		} else if z.HasExtensions() && z.DecExt(yyv27) {
 51347  		} else {
 51348  			*((*int64)(yyv27)) = int64(r.DecodeInt(64))
 51349  		}
 51350  	}
 51351  	yyj18++
 51352  	if yyhl18 {
 51353  		yyb18 = yyj18 > l
 51354  	} else {
 51355  		yyb18 = r.CheckBreak()
 51356  	}
 51357  	if yyb18 {
 51358  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51359  		return
 51360  	}
 51361  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 51362  	if r.TryDecodeAsNil() {
 51363  		x.AutoRevert = false
 51364  	} else {
 51365  		yyv29 := &x.AutoRevert
 51366  		yym30 := z.DecBinary()
 51367  		_ = yym30
 51368  		if false {
 51369  		} else {
 51370  			*((*bool)(yyv29)) = r.DecodeBool()
 51371  		}
 51372  	}
 51373  	yyj18++
 51374  	if yyhl18 {
 51375  		yyb18 = yyj18 > l
 51376  	} else {
 51377  		yyb18 = r.CheckBreak()
 51378  	}
 51379  	if yyb18 {
 51380  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51381  		return
 51382  	}
 51383  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 51384  	if r.TryDecodeAsNil() {
 51385  		x.Canary = 0
 51386  	} else {
 51387  		yyv31 := &x.Canary
 51388  		yym32 := z.DecBinary()
 51389  		_ = yym32
 51390  		if false {
 51391  		} else {
 51392  			*((*int)(yyv31)) = int(r.DecodeInt(codecSelferBitsize100))
 51393  		}
 51394  	}
 51395  	for {
 51396  		yyj18++
 51397  		if yyhl18 {
 51398  			yyb18 = yyj18 > l
 51399  		} else {
 51400  			yyb18 = r.CheckBreak()
 51401  		}
 51402  		if yyb18 {
 51403  			break
 51404  		}
 51405  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 51406  		z.DecStructFieldNotFound(yyj18-1, "")
 51407  	}
 51408  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51409  }
 51410  
 51411  func (x *PeriodicConfig) CodecEncodeSelf(e *codec1978.Encoder) {
 51412  	var h codecSelfer100
 51413  	z, r := codec1978.GenHelperEncoder(e)
 51414  	_, _, _ = h, z, r
 51415  	if x == nil {
 51416  		r.EncodeNil()
 51417  	} else {
 51418  		yym1 := z.EncBinary()
 51419  		_ = yym1
 51420  		if false {
 51421  		} else if z.HasExtensions() && z.EncExt(x) {
 51422  		} else {
 51423  			yysep2 := !z.EncBinary()
 51424  			yy2arr2 := z.EncBasicHandle().StructToArray
 51425  			var yyq2 [5]bool
 51426  			_, _, _ = yysep2, yyq2, yy2arr2
 51427  			const yyr2 bool = false
 51428  			var yynn2 int
 51429  			if yyr2 || yy2arr2 {
 51430  				r.EncodeArrayStart(5)
 51431  			} else {
 51432  				yynn2 = 5
 51433  				for _, b := range yyq2 {
 51434  					if b {
 51435  						yynn2++
 51436  					}
 51437  				}
 51438  				r.EncodeMapStart(yynn2)
 51439  				yynn2 = 0
 51440  			}
 51441  			if yyr2 || yy2arr2 {
 51442  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 51443  				yym4 := z.EncBinary()
 51444  				_ = yym4
 51445  				if false {
 51446  				} else {
 51447  					r.EncodeBool(bool(x.Enabled))
 51448  				}
 51449  			} else {
 51450  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 51451  				r.EncodeString(codecSelferC_UTF8100, string("Enabled"))
 51452  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 51453  				yym5 := z.EncBinary()
 51454  				_ = yym5
 51455  				if false {
 51456  				} else {
 51457  					r.EncodeBool(bool(x.Enabled))
 51458  				}
 51459  			}
 51460  			if yyr2 || yy2arr2 {
 51461  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 51462  				yym7 := z.EncBinary()
 51463  				_ = yym7
 51464  				if false {
 51465  				} else {
 51466  					r.EncodeString(codecSelferC_UTF8100, string(x.Spec))
 51467  				}
 51468  			} else {
 51469  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 51470  				r.EncodeString(codecSelferC_UTF8100, string("Spec"))
 51471  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 51472  				yym8 := z.EncBinary()
 51473  				_ = yym8
 51474  				if false {
 51475  				} else {
 51476  					r.EncodeString(codecSelferC_UTF8100, string(x.Spec))
 51477  				}
 51478  			}
 51479  			if yyr2 || yy2arr2 {
 51480  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 51481  				yym10 := z.EncBinary()
 51482  				_ = yym10
 51483  				if false {
 51484  				} else {
 51485  					r.EncodeString(codecSelferC_UTF8100, string(x.SpecType))
 51486  				}
 51487  			} else {
 51488  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 51489  				r.EncodeString(codecSelferC_UTF8100, string("SpecType"))
 51490  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 51491  				yym11 := z.EncBinary()
 51492  				_ = yym11
 51493  				if false {
 51494  				} else {
 51495  					r.EncodeString(codecSelferC_UTF8100, string(x.SpecType))
 51496  				}
 51497  			}
 51498  			if yyr2 || yy2arr2 {
 51499  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 51500  				yym13 := z.EncBinary()
 51501  				_ = yym13
 51502  				if false {
 51503  				} else {
 51504  					r.EncodeBool(bool(x.ProhibitOverlap))
 51505  				}
 51506  			} else {
 51507  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 51508  				r.EncodeString(codecSelferC_UTF8100, string("ProhibitOverlap"))
 51509  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 51510  				yym14 := z.EncBinary()
 51511  				_ = yym14
 51512  				if false {
 51513  				} else {
 51514  					r.EncodeBool(bool(x.ProhibitOverlap))
 51515  				}
 51516  			}
 51517  			if yyr2 || yy2arr2 {
 51518  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 51519  				yym16 := z.EncBinary()
 51520  				_ = yym16
 51521  				if false {
 51522  				} else {
 51523  					r.EncodeString(codecSelferC_UTF8100, string(x.TimeZone))
 51524  				}
 51525  			} else {
 51526  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 51527  				r.EncodeString(codecSelferC_UTF8100, string("TimeZone"))
 51528  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 51529  				yym17 := z.EncBinary()
 51530  				_ = yym17
 51531  				if false {
 51532  				} else {
 51533  					r.EncodeString(codecSelferC_UTF8100, string(x.TimeZone))
 51534  				}
 51535  			}
 51536  			if yyr2 || yy2arr2 {
 51537  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 51538  			} else {
 51539  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 51540  			}
 51541  		}
 51542  	}
 51543  }
 51544  
 51545  func (x *PeriodicConfig) CodecDecodeSelf(d *codec1978.Decoder) {
 51546  	var h codecSelfer100
 51547  	z, r := codec1978.GenHelperDecoder(d)
 51548  	_, _, _ = h, z, r
 51549  	yym1 := z.DecBinary()
 51550  	_ = yym1
 51551  	if false {
 51552  	} else if z.HasExtensions() && z.DecExt(x) {
 51553  	} else {
 51554  		yyct2 := r.ContainerType()
 51555  		if yyct2 == codecSelferValueTypeMap100 {
 51556  			yyl2 := r.ReadMapStart()
 51557  			if yyl2 == 0 {
 51558  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 51559  			} else {
 51560  				x.codecDecodeSelfFromMap(yyl2, d)
 51561  			}
 51562  		} else if yyct2 == codecSelferValueTypeArray100 {
 51563  			yyl2 := r.ReadArrayStart()
 51564  			if yyl2 == 0 {
 51565  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51566  			} else {
 51567  				x.codecDecodeSelfFromArray(yyl2, d)
 51568  			}
 51569  		} else {
 51570  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 51571  		}
 51572  	}
 51573  }
 51574  
 51575  func (x *PeriodicConfig) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 51576  	var h codecSelfer100
 51577  	z, r := codec1978.GenHelperDecoder(d)
 51578  	_, _, _ = h, z, r
 51579  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 51580  	_ = yys3Slc
 51581  	var yyhl3 bool = l >= 0
 51582  	for yyj3 := 0; ; yyj3++ {
 51583  		if yyhl3 {
 51584  			if yyj3 >= l {
 51585  				break
 51586  			}
 51587  		} else {
 51588  			if r.CheckBreak() {
 51589  				break
 51590  			}
 51591  		}
 51592  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 51593  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 51594  		yys3 := string(yys3Slc)
 51595  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 51596  		switch yys3 {
 51597  		case "Enabled":
 51598  			if r.TryDecodeAsNil() {
 51599  				x.Enabled = false
 51600  			} else {
 51601  				yyv4 := &x.Enabled
 51602  				yym5 := z.DecBinary()
 51603  				_ = yym5
 51604  				if false {
 51605  				} else {
 51606  					*((*bool)(yyv4)) = r.DecodeBool()
 51607  				}
 51608  			}
 51609  		case "Spec":
 51610  			if r.TryDecodeAsNil() {
 51611  				x.Spec = ""
 51612  			} else {
 51613  				yyv6 := &x.Spec
 51614  				yym7 := z.DecBinary()
 51615  				_ = yym7
 51616  				if false {
 51617  				} else {
 51618  					*((*string)(yyv6)) = r.DecodeString()
 51619  				}
 51620  			}
 51621  		case "SpecType":
 51622  			if r.TryDecodeAsNil() {
 51623  				x.SpecType = ""
 51624  			} else {
 51625  				yyv8 := &x.SpecType
 51626  				yym9 := z.DecBinary()
 51627  				_ = yym9
 51628  				if false {
 51629  				} else {
 51630  					*((*string)(yyv8)) = r.DecodeString()
 51631  				}
 51632  			}
 51633  		case "ProhibitOverlap":
 51634  			if r.TryDecodeAsNil() {
 51635  				x.ProhibitOverlap = false
 51636  			} else {
 51637  				yyv10 := &x.ProhibitOverlap
 51638  				yym11 := z.DecBinary()
 51639  				_ = yym11
 51640  				if false {
 51641  				} else {
 51642  					*((*bool)(yyv10)) = r.DecodeBool()
 51643  				}
 51644  			}
 51645  		case "TimeZone":
 51646  			if r.TryDecodeAsNil() {
 51647  				x.TimeZone = ""
 51648  			} else {
 51649  				yyv12 := &x.TimeZone
 51650  				yym13 := z.DecBinary()
 51651  				_ = yym13
 51652  				if false {
 51653  				} else {
 51654  					*((*string)(yyv12)) = r.DecodeString()
 51655  				}
 51656  			}
 51657  		default:
 51658  			z.DecStructFieldNotFound(-1, yys3)
 51659  		} // end switch yys3
 51660  	} // end for yyj3
 51661  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 51662  }
 51663  
 51664  func (x *PeriodicConfig) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 51665  	var h codecSelfer100
 51666  	z, r := codec1978.GenHelperDecoder(d)
 51667  	_, _, _ = h, z, r
 51668  	var yyj14 int
 51669  	var yyb14 bool
 51670  	var yyhl14 bool = l >= 0
 51671  	yyj14++
 51672  	if yyhl14 {
 51673  		yyb14 = yyj14 > l
 51674  	} else {
 51675  		yyb14 = r.CheckBreak()
 51676  	}
 51677  	if yyb14 {
 51678  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51679  		return
 51680  	}
 51681  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 51682  	if r.TryDecodeAsNil() {
 51683  		x.Enabled = false
 51684  	} else {
 51685  		yyv15 := &x.Enabled
 51686  		yym16 := z.DecBinary()
 51687  		_ = yym16
 51688  		if false {
 51689  		} else {
 51690  			*((*bool)(yyv15)) = r.DecodeBool()
 51691  		}
 51692  	}
 51693  	yyj14++
 51694  	if yyhl14 {
 51695  		yyb14 = yyj14 > l
 51696  	} else {
 51697  		yyb14 = r.CheckBreak()
 51698  	}
 51699  	if yyb14 {
 51700  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51701  		return
 51702  	}
 51703  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 51704  	if r.TryDecodeAsNil() {
 51705  		x.Spec = ""
 51706  	} else {
 51707  		yyv17 := &x.Spec
 51708  		yym18 := z.DecBinary()
 51709  		_ = yym18
 51710  		if false {
 51711  		} else {
 51712  			*((*string)(yyv17)) = r.DecodeString()
 51713  		}
 51714  	}
 51715  	yyj14++
 51716  	if yyhl14 {
 51717  		yyb14 = yyj14 > l
 51718  	} else {
 51719  		yyb14 = r.CheckBreak()
 51720  	}
 51721  	if yyb14 {
 51722  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51723  		return
 51724  	}
 51725  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 51726  	if r.TryDecodeAsNil() {
 51727  		x.SpecType = ""
 51728  	} else {
 51729  		yyv19 := &x.SpecType
 51730  		yym20 := z.DecBinary()
 51731  		_ = yym20
 51732  		if false {
 51733  		} else {
 51734  			*((*string)(yyv19)) = r.DecodeString()
 51735  		}
 51736  	}
 51737  	yyj14++
 51738  	if yyhl14 {
 51739  		yyb14 = yyj14 > l
 51740  	} else {
 51741  		yyb14 = r.CheckBreak()
 51742  	}
 51743  	if yyb14 {
 51744  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51745  		return
 51746  	}
 51747  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 51748  	if r.TryDecodeAsNil() {
 51749  		x.ProhibitOverlap = false
 51750  	} else {
 51751  		yyv21 := &x.ProhibitOverlap
 51752  		yym22 := z.DecBinary()
 51753  		_ = yym22
 51754  		if false {
 51755  		} else {
 51756  			*((*bool)(yyv21)) = r.DecodeBool()
 51757  		}
 51758  	}
 51759  	yyj14++
 51760  	if yyhl14 {
 51761  		yyb14 = yyj14 > l
 51762  	} else {
 51763  		yyb14 = r.CheckBreak()
 51764  	}
 51765  	if yyb14 {
 51766  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51767  		return
 51768  	}
 51769  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 51770  	if r.TryDecodeAsNil() {
 51771  		x.TimeZone = ""
 51772  	} else {
 51773  		yyv23 := &x.TimeZone
 51774  		yym24 := z.DecBinary()
 51775  		_ = yym24
 51776  		if false {
 51777  		} else {
 51778  			*((*string)(yyv23)) = r.DecodeString()
 51779  		}
 51780  	}
 51781  	for {
 51782  		yyj14++
 51783  		if yyhl14 {
 51784  			yyb14 = yyj14 > l
 51785  		} else {
 51786  			yyb14 = r.CheckBreak()
 51787  		}
 51788  		if yyb14 {
 51789  			break
 51790  		}
 51791  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 51792  		z.DecStructFieldNotFound(yyj14-1, "")
 51793  	}
 51794  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51795  }
 51796  
 51797  func (x *PeriodicLaunch) CodecEncodeSelf(e *codec1978.Encoder) {
 51798  	var h codecSelfer100
 51799  	z, r := codec1978.GenHelperEncoder(e)
 51800  	_, _, _ = h, z, r
 51801  	if x == nil {
 51802  		r.EncodeNil()
 51803  	} else {
 51804  		yym1 := z.EncBinary()
 51805  		_ = yym1
 51806  		if false {
 51807  		} else if z.HasExtensions() && z.EncExt(x) {
 51808  		} else {
 51809  			yysep2 := !z.EncBinary()
 51810  			yy2arr2 := z.EncBasicHandle().StructToArray
 51811  			var yyq2 [5]bool
 51812  			_, _, _ = yysep2, yyq2, yy2arr2
 51813  			const yyr2 bool = false
 51814  			var yynn2 int
 51815  			if yyr2 || yy2arr2 {
 51816  				r.EncodeArrayStart(5)
 51817  			} else {
 51818  				yynn2 = 5
 51819  				for _, b := range yyq2 {
 51820  					if b {
 51821  						yynn2++
 51822  					}
 51823  				}
 51824  				r.EncodeMapStart(yynn2)
 51825  				yynn2 = 0
 51826  			}
 51827  			if yyr2 || yy2arr2 {
 51828  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 51829  				yym4 := z.EncBinary()
 51830  				_ = yym4
 51831  				if false {
 51832  				} else {
 51833  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 51834  				}
 51835  			} else {
 51836  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 51837  				r.EncodeString(codecSelferC_UTF8100, string("ID"))
 51838  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 51839  				yym5 := z.EncBinary()
 51840  				_ = yym5
 51841  				if false {
 51842  				} else {
 51843  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 51844  				}
 51845  			}
 51846  			if yyr2 || yy2arr2 {
 51847  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 51848  				yym7 := z.EncBinary()
 51849  				_ = yym7
 51850  				if false {
 51851  				} else {
 51852  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 51853  				}
 51854  			} else {
 51855  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 51856  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 51857  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 51858  				yym8 := z.EncBinary()
 51859  				_ = yym8
 51860  				if false {
 51861  				} else {
 51862  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 51863  				}
 51864  			}
 51865  			if yyr2 || yy2arr2 {
 51866  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 51867  				yy10 := &x.Launch
 51868  				yym11 := z.EncBinary()
 51869  				_ = yym11
 51870  				if false {
 51871  				} else if yym12 := z.TimeRtidIfBinc(); yym12 != 0 {
 51872  					r.EncodeBuiltin(yym12, yy10)
 51873  				} else if z.HasExtensions() && z.EncExt(yy10) {
 51874  				} else if yym11 {
 51875  					z.EncBinaryMarshal(yy10)
 51876  				} else if !yym11 && z.IsJSONHandle() {
 51877  					z.EncJSONMarshal(yy10)
 51878  				} else {
 51879  					z.EncFallback(yy10)
 51880  				}
 51881  			} else {
 51882  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 51883  				r.EncodeString(codecSelferC_UTF8100, string("Launch"))
 51884  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 51885  				yy13 := &x.Launch
 51886  				yym14 := z.EncBinary()
 51887  				_ = yym14
 51888  				if false {
 51889  				} else if yym15 := z.TimeRtidIfBinc(); yym15 != 0 {
 51890  					r.EncodeBuiltin(yym15, yy13)
 51891  				} else if z.HasExtensions() && z.EncExt(yy13) {
 51892  				} else if yym14 {
 51893  					z.EncBinaryMarshal(yy13)
 51894  				} else if !yym14 && z.IsJSONHandle() {
 51895  					z.EncJSONMarshal(yy13)
 51896  				} else {
 51897  					z.EncFallback(yy13)
 51898  				}
 51899  			}
 51900  			if yyr2 || yy2arr2 {
 51901  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 51902  				yym17 := z.EncBinary()
 51903  				_ = yym17
 51904  				if false {
 51905  				} else {
 51906  					r.EncodeUint(uint64(x.CreateIndex))
 51907  				}
 51908  			} else {
 51909  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 51910  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 51911  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 51912  				yym18 := z.EncBinary()
 51913  				_ = yym18
 51914  				if false {
 51915  				} else {
 51916  					r.EncodeUint(uint64(x.CreateIndex))
 51917  				}
 51918  			}
 51919  			if yyr2 || yy2arr2 {
 51920  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 51921  				yym20 := z.EncBinary()
 51922  				_ = yym20
 51923  				if false {
 51924  				} else {
 51925  					r.EncodeUint(uint64(x.ModifyIndex))
 51926  				}
 51927  			} else {
 51928  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 51929  				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
 51930  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 51931  				yym21 := z.EncBinary()
 51932  				_ = yym21
 51933  				if false {
 51934  				} else {
 51935  					r.EncodeUint(uint64(x.ModifyIndex))
 51936  				}
 51937  			}
 51938  			if yyr2 || yy2arr2 {
 51939  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 51940  			} else {
 51941  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 51942  			}
 51943  		}
 51944  	}
 51945  }
 51946  
 51947  func (x *PeriodicLaunch) CodecDecodeSelf(d *codec1978.Decoder) {
 51948  	var h codecSelfer100
 51949  	z, r := codec1978.GenHelperDecoder(d)
 51950  	_, _, _ = h, z, r
 51951  	yym1 := z.DecBinary()
 51952  	_ = yym1
 51953  	if false {
 51954  	} else if z.HasExtensions() && z.DecExt(x) {
 51955  	} else {
 51956  		yyct2 := r.ContainerType()
 51957  		if yyct2 == codecSelferValueTypeMap100 {
 51958  			yyl2 := r.ReadMapStart()
 51959  			if yyl2 == 0 {
 51960  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 51961  			} else {
 51962  				x.codecDecodeSelfFromMap(yyl2, d)
 51963  			}
 51964  		} else if yyct2 == codecSelferValueTypeArray100 {
 51965  			yyl2 := r.ReadArrayStart()
 51966  			if yyl2 == 0 {
 51967  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 51968  			} else {
 51969  				x.codecDecodeSelfFromArray(yyl2, d)
 51970  			}
 51971  		} else {
 51972  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 51973  		}
 51974  	}
 51975  }
 51976  
 51977  func (x *PeriodicLaunch) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 51978  	var h codecSelfer100
 51979  	z, r := codec1978.GenHelperDecoder(d)
 51980  	_, _, _ = h, z, r
 51981  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 51982  	_ = yys3Slc
 51983  	var yyhl3 bool = l >= 0
 51984  	for yyj3 := 0; ; yyj3++ {
 51985  		if yyhl3 {
 51986  			if yyj3 >= l {
 51987  				break
 51988  			}
 51989  		} else {
 51990  			if r.CheckBreak() {
 51991  				break
 51992  			}
 51993  		}
 51994  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 51995  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 51996  		yys3 := string(yys3Slc)
 51997  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 51998  		switch yys3 {
 51999  		case "ID":
 52000  			if r.TryDecodeAsNil() {
 52001  				x.ID = ""
 52002  			} else {
 52003  				yyv4 := &x.ID
 52004  				yym5 := z.DecBinary()
 52005  				_ = yym5
 52006  				if false {
 52007  				} else {
 52008  					*((*string)(yyv4)) = r.DecodeString()
 52009  				}
 52010  			}
 52011  		case "Namespace":
 52012  			if r.TryDecodeAsNil() {
 52013  				x.Namespace = ""
 52014  			} else {
 52015  				yyv6 := &x.Namespace
 52016  				yym7 := z.DecBinary()
 52017  				_ = yym7
 52018  				if false {
 52019  				} else {
 52020  					*((*string)(yyv6)) = r.DecodeString()
 52021  				}
 52022  			}
 52023  		case "Launch":
 52024  			if r.TryDecodeAsNil() {
 52025  				x.Launch = time.Time{}
 52026  			} else {
 52027  				yyv8 := &x.Launch
 52028  				yym9 := z.DecBinary()
 52029  				_ = yym9
 52030  				if false {
 52031  				} else if yym10 := z.TimeRtidIfBinc(); yym10 != 0 {
 52032  					r.DecodeBuiltin(yym10, yyv8)
 52033  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 52034  				} else if yym9 {
 52035  					z.DecBinaryUnmarshal(yyv8)
 52036  				} else if !yym9 && z.IsJSONHandle() {
 52037  					z.DecJSONUnmarshal(yyv8)
 52038  				} else {
 52039  					z.DecFallback(yyv8, false)
 52040  				}
 52041  			}
 52042  		case "CreateIndex":
 52043  			if r.TryDecodeAsNil() {
 52044  				x.CreateIndex = 0
 52045  			} else {
 52046  				yyv11 := &x.CreateIndex
 52047  				yym12 := z.DecBinary()
 52048  				_ = yym12
 52049  				if false {
 52050  				} else {
 52051  					*((*uint64)(yyv11)) = uint64(r.DecodeUint(64))
 52052  				}
 52053  			}
 52054  		case "ModifyIndex":
 52055  			if r.TryDecodeAsNil() {
 52056  				x.ModifyIndex = 0
 52057  			} else {
 52058  				yyv13 := &x.ModifyIndex
 52059  				yym14 := z.DecBinary()
 52060  				_ = yym14
 52061  				if false {
 52062  				} else {
 52063  					*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 52064  				}
 52065  			}
 52066  		default:
 52067  			z.DecStructFieldNotFound(-1, yys3)
 52068  		} // end switch yys3
 52069  	} // end for yyj3
 52070  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 52071  }
 52072  
 52073  func (x *PeriodicLaunch) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 52074  	var h codecSelfer100
 52075  	z, r := codec1978.GenHelperDecoder(d)
 52076  	_, _, _ = h, z, r
 52077  	var yyj15 int
 52078  	var yyb15 bool
 52079  	var yyhl15 bool = l >= 0
 52080  	yyj15++
 52081  	if yyhl15 {
 52082  		yyb15 = yyj15 > l
 52083  	} else {
 52084  		yyb15 = r.CheckBreak()
 52085  	}
 52086  	if yyb15 {
 52087  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52088  		return
 52089  	}
 52090  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52091  	if r.TryDecodeAsNil() {
 52092  		x.ID = ""
 52093  	} else {
 52094  		yyv16 := &x.ID
 52095  		yym17 := z.DecBinary()
 52096  		_ = yym17
 52097  		if false {
 52098  		} else {
 52099  			*((*string)(yyv16)) = r.DecodeString()
 52100  		}
 52101  	}
 52102  	yyj15++
 52103  	if yyhl15 {
 52104  		yyb15 = yyj15 > l
 52105  	} else {
 52106  		yyb15 = r.CheckBreak()
 52107  	}
 52108  	if yyb15 {
 52109  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52110  		return
 52111  	}
 52112  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52113  	if r.TryDecodeAsNil() {
 52114  		x.Namespace = ""
 52115  	} else {
 52116  		yyv18 := &x.Namespace
 52117  		yym19 := z.DecBinary()
 52118  		_ = yym19
 52119  		if false {
 52120  		} else {
 52121  			*((*string)(yyv18)) = r.DecodeString()
 52122  		}
 52123  	}
 52124  	yyj15++
 52125  	if yyhl15 {
 52126  		yyb15 = yyj15 > l
 52127  	} else {
 52128  		yyb15 = r.CheckBreak()
 52129  	}
 52130  	if yyb15 {
 52131  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52132  		return
 52133  	}
 52134  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52135  	if r.TryDecodeAsNil() {
 52136  		x.Launch = time.Time{}
 52137  	} else {
 52138  		yyv20 := &x.Launch
 52139  		yym21 := z.DecBinary()
 52140  		_ = yym21
 52141  		if false {
 52142  		} else if yym22 := z.TimeRtidIfBinc(); yym22 != 0 {
 52143  			r.DecodeBuiltin(yym22, yyv20)
 52144  		} else if z.HasExtensions() && z.DecExt(yyv20) {
 52145  		} else if yym21 {
 52146  			z.DecBinaryUnmarshal(yyv20)
 52147  		} else if !yym21 && z.IsJSONHandle() {
 52148  			z.DecJSONUnmarshal(yyv20)
 52149  		} else {
 52150  			z.DecFallback(yyv20, false)
 52151  		}
 52152  	}
 52153  	yyj15++
 52154  	if yyhl15 {
 52155  		yyb15 = yyj15 > l
 52156  	} else {
 52157  		yyb15 = r.CheckBreak()
 52158  	}
 52159  	if yyb15 {
 52160  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52161  		return
 52162  	}
 52163  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52164  	if r.TryDecodeAsNil() {
 52165  		x.CreateIndex = 0
 52166  	} else {
 52167  		yyv23 := &x.CreateIndex
 52168  		yym24 := z.DecBinary()
 52169  		_ = yym24
 52170  		if false {
 52171  		} else {
 52172  			*((*uint64)(yyv23)) = uint64(r.DecodeUint(64))
 52173  		}
 52174  	}
 52175  	yyj15++
 52176  	if yyhl15 {
 52177  		yyb15 = yyj15 > l
 52178  	} else {
 52179  		yyb15 = r.CheckBreak()
 52180  	}
 52181  	if yyb15 {
 52182  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52183  		return
 52184  	}
 52185  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52186  	if r.TryDecodeAsNil() {
 52187  		x.ModifyIndex = 0
 52188  	} else {
 52189  		yyv25 := &x.ModifyIndex
 52190  		yym26 := z.DecBinary()
 52191  		_ = yym26
 52192  		if false {
 52193  		} else {
 52194  			*((*uint64)(yyv25)) = uint64(r.DecodeUint(64))
 52195  		}
 52196  	}
 52197  	for {
 52198  		yyj15++
 52199  		if yyhl15 {
 52200  			yyb15 = yyj15 > l
 52201  		} else {
 52202  			yyb15 = r.CheckBreak()
 52203  		}
 52204  		if yyb15 {
 52205  			break
 52206  		}
 52207  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52208  		z.DecStructFieldNotFound(yyj15-1, "")
 52209  	}
 52210  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52211  }
 52212  
 52213  func (x *ParameterizedJobConfig) CodecEncodeSelf(e *codec1978.Encoder) {
 52214  	var h codecSelfer100
 52215  	z, r := codec1978.GenHelperEncoder(e)
 52216  	_, _, _ = h, z, r
 52217  	if x == nil {
 52218  		r.EncodeNil()
 52219  	} else {
 52220  		yym1 := z.EncBinary()
 52221  		_ = yym1
 52222  		if false {
 52223  		} else if z.HasExtensions() && z.EncExt(x) {
 52224  		} else {
 52225  			yysep2 := !z.EncBinary()
 52226  			yy2arr2 := z.EncBasicHandle().StructToArray
 52227  			var yyq2 [3]bool
 52228  			_, _, _ = yysep2, yyq2, yy2arr2
 52229  			const yyr2 bool = false
 52230  			var yynn2 int
 52231  			if yyr2 || yy2arr2 {
 52232  				r.EncodeArrayStart(3)
 52233  			} else {
 52234  				yynn2 = 3
 52235  				for _, b := range yyq2 {
 52236  					if b {
 52237  						yynn2++
 52238  					}
 52239  				}
 52240  				r.EncodeMapStart(yynn2)
 52241  				yynn2 = 0
 52242  			}
 52243  			if yyr2 || yy2arr2 {
 52244  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 52245  				yym4 := z.EncBinary()
 52246  				_ = yym4
 52247  				if false {
 52248  				} else {
 52249  					r.EncodeString(codecSelferC_UTF8100, string(x.Payload))
 52250  				}
 52251  			} else {
 52252  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 52253  				r.EncodeString(codecSelferC_UTF8100, string("Payload"))
 52254  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 52255  				yym5 := z.EncBinary()
 52256  				_ = yym5
 52257  				if false {
 52258  				} else {
 52259  					r.EncodeString(codecSelferC_UTF8100, string(x.Payload))
 52260  				}
 52261  			}
 52262  			if yyr2 || yy2arr2 {
 52263  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 52264  				if x.MetaRequired == nil {
 52265  					r.EncodeNil()
 52266  				} else {
 52267  					yym7 := z.EncBinary()
 52268  					_ = yym7
 52269  					if false {
 52270  					} else {
 52271  						z.F.EncSliceStringV(x.MetaRequired, false, e)
 52272  					}
 52273  				}
 52274  			} else {
 52275  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 52276  				r.EncodeString(codecSelferC_UTF8100, string("MetaRequired"))
 52277  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 52278  				if x.MetaRequired == nil {
 52279  					r.EncodeNil()
 52280  				} else {
 52281  					yym8 := z.EncBinary()
 52282  					_ = yym8
 52283  					if false {
 52284  					} else {
 52285  						z.F.EncSliceStringV(x.MetaRequired, false, e)
 52286  					}
 52287  				}
 52288  			}
 52289  			if yyr2 || yy2arr2 {
 52290  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 52291  				if x.MetaOptional == nil {
 52292  					r.EncodeNil()
 52293  				} else {
 52294  					yym10 := z.EncBinary()
 52295  					_ = yym10
 52296  					if false {
 52297  					} else {
 52298  						z.F.EncSliceStringV(x.MetaOptional, false, e)
 52299  					}
 52300  				}
 52301  			} else {
 52302  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 52303  				r.EncodeString(codecSelferC_UTF8100, string("MetaOptional"))
 52304  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 52305  				if x.MetaOptional == nil {
 52306  					r.EncodeNil()
 52307  				} else {
 52308  					yym11 := z.EncBinary()
 52309  					_ = yym11
 52310  					if false {
 52311  					} else {
 52312  						z.F.EncSliceStringV(x.MetaOptional, false, e)
 52313  					}
 52314  				}
 52315  			}
 52316  			if yyr2 || yy2arr2 {
 52317  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 52318  			} else {
 52319  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 52320  			}
 52321  		}
 52322  	}
 52323  }
 52324  
 52325  func (x *ParameterizedJobConfig) CodecDecodeSelf(d *codec1978.Decoder) {
 52326  	var h codecSelfer100
 52327  	z, r := codec1978.GenHelperDecoder(d)
 52328  	_, _, _ = h, z, r
 52329  	yym1 := z.DecBinary()
 52330  	_ = yym1
 52331  	if false {
 52332  	} else if z.HasExtensions() && z.DecExt(x) {
 52333  	} else {
 52334  		yyct2 := r.ContainerType()
 52335  		if yyct2 == codecSelferValueTypeMap100 {
 52336  			yyl2 := r.ReadMapStart()
 52337  			if yyl2 == 0 {
 52338  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 52339  			} else {
 52340  				x.codecDecodeSelfFromMap(yyl2, d)
 52341  			}
 52342  		} else if yyct2 == codecSelferValueTypeArray100 {
 52343  			yyl2 := r.ReadArrayStart()
 52344  			if yyl2 == 0 {
 52345  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52346  			} else {
 52347  				x.codecDecodeSelfFromArray(yyl2, d)
 52348  			}
 52349  		} else {
 52350  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 52351  		}
 52352  	}
 52353  }
 52354  
 52355  func (x *ParameterizedJobConfig) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 52356  	var h codecSelfer100
 52357  	z, r := codec1978.GenHelperDecoder(d)
 52358  	_, _, _ = h, z, r
 52359  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 52360  	_ = yys3Slc
 52361  	var yyhl3 bool = l >= 0
 52362  	for yyj3 := 0; ; yyj3++ {
 52363  		if yyhl3 {
 52364  			if yyj3 >= l {
 52365  				break
 52366  			}
 52367  		} else {
 52368  			if r.CheckBreak() {
 52369  				break
 52370  			}
 52371  		}
 52372  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 52373  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 52374  		yys3 := string(yys3Slc)
 52375  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 52376  		switch yys3 {
 52377  		case "Payload":
 52378  			if r.TryDecodeAsNil() {
 52379  				x.Payload = ""
 52380  			} else {
 52381  				yyv4 := &x.Payload
 52382  				yym5 := z.DecBinary()
 52383  				_ = yym5
 52384  				if false {
 52385  				} else {
 52386  					*((*string)(yyv4)) = r.DecodeString()
 52387  				}
 52388  			}
 52389  		case "MetaRequired":
 52390  			if r.TryDecodeAsNil() {
 52391  				x.MetaRequired = nil
 52392  			} else {
 52393  				yyv6 := &x.MetaRequired
 52394  				yym7 := z.DecBinary()
 52395  				_ = yym7
 52396  				if false {
 52397  				} else {
 52398  					z.F.DecSliceStringX(yyv6, false, d)
 52399  				}
 52400  			}
 52401  		case "MetaOptional":
 52402  			if r.TryDecodeAsNil() {
 52403  				x.MetaOptional = nil
 52404  			} else {
 52405  				yyv8 := &x.MetaOptional
 52406  				yym9 := z.DecBinary()
 52407  				_ = yym9
 52408  				if false {
 52409  				} else {
 52410  					z.F.DecSliceStringX(yyv8, false, d)
 52411  				}
 52412  			}
 52413  		default:
 52414  			z.DecStructFieldNotFound(-1, yys3)
 52415  		} // end switch yys3
 52416  	} // end for yyj3
 52417  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 52418  }
 52419  
 52420  func (x *ParameterizedJobConfig) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 52421  	var h codecSelfer100
 52422  	z, r := codec1978.GenHelperDecoder(d)
 52423  	_, _, _ = h, z, r
 52424  	var yyj10 int
 52425  	var yyb10 bool
 52426  	var yyhl10 bool = l >= 0
 52427  	yyj10++
 52428  	if yyhl10 {
 52429  		yyb10 = yyj10 > l
 52430  	} else {
 52431  		yyb10 = r.CheckBreak()
 52432  	}
 52433  	if yyb10 {
 52434  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52435  		return
 52436  	}
 52437  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52438  	if r.TryDecodeAsNil() {
 52439  		x.Payload = ""
 52440  	} else {
 52441  		yyv11 := &x.Payload
 52442  		yym12 := z.DecBinary()
 52443  		_ = yym12
 52444  		if false {
 52445  		} else {
 52446  			*((*string)(yyv11)) = r.DecodeString()
 52447  		}
 52448  	}
 52449  	yyj10++
 52450  	if yyhl10 {
 52451  		yyb10 = yyj10 > l
 52452  	} else {
 52453  		yyb10 = r.CheckBreak()
 52454  	}
 52455  	if yyb10 {
 52456  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52457  		return
 52458  	}
 52459  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52460  	if r.TryDecodeAsNil() {
 52461  		x.MetaRequired = nil
 52462  	} else {
 52463  		yyv13 := &x.MetaRequired
 52464  		yym14 := z.DecBinary()
 52465  		_ = yym14
 52466  		if false {
 52467  		} else {
 52468  			z.F.DecSliceStringX(yyv13, false, d)
 52469  		}
 52470  	}
 52471  	yyj10++
 52472  	if yyhl10 {
 52473  		yyb10 = yyj10 > l
 52474  	} else {
 52475  		yyb10 = r.CheckBreak()
 52476  	}
 52477  	if yyb10 {
 52478  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52479  		return
 52480  	}
 52481  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52482  	if r.TryDecodeAsNil() {
 52483  		x.MetaOptional = nil
 52484  	} else {
 52485  		yyv15 := &x.MetaOptional
 52486  		yym16 := z.DecBinary()
 52487  		_ = yym16
 52488  		if false {
 52489  		} else {
 52490  			z.F.DecSliceStringX(yyv15, false, d)
 52491  		}
 52492  	}
 52493  	for {
 52494  		yyj10++
 52495  		if yyhl10 {
 52496  			yyb10 = yyj10 > l
 52497  		} else {
 52498  			yyb10 = r.CheckBreak()
 52499  		}
 52500  		if yyb10 {
 52501  			break
 52502  		}
 52503  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52504  		z.DecStructFieldNotFound(yyj10-1, "")
 52505  	}
 52506  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52507  }
 52508  
 52509  func (x *DispatchPayloadConfig) CodecEncodeSelf(e *codec1978.Encoder) {
 52510  	var h codecSelfer100
 52511  	z, r := codec1978.GenHelperEncoder(e)
 52512  	_, _, _ = h, z, r
 52513  	if x == nil {
 52514  		r.EncodeNil()
 52515  	} else {
 52516  		yym1 := z.EncBinary()
 52517  		_ = yym1
 52518  		if false {
 52519  		} else if z.HasExtensions() && z.EncExt(x) {
 52520  		} else {
 52521  			yysep2 := !z.EncBinary()
 52522  			yy2arr2 := z.EncBasicHandle().StructToArray
 52523  			var yyq2 [1]bool
 52524  			_, _, _ = yysep2, yyq2, yy2arr2
 52525  			const yyr2 bool = false
 52526  			var yynn2 int
 52527  			if yyr2 || yy2arr2 {
 52528  				r.EncodeArrayStart(1)
 52529  			} else {
 52530  				yynn2 = 1
 52531  				for _, b := range yyq2 {
 52532  					if b {
 52533  						yynn2++
 52534  					}
 52535  				}
 52536  				r.EncodeMapStart(yynn2)
 52537  				yynn2 = 0
 52538  			}
 52539  			if yyr2 || yy2arr2 {
 52540  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 52541  				yym4 := z.EncBinary()
 52542  				_ = yym4
 52543  				if false {
 52544  				} else {
 52545  					r.EncodeString(codecSelferC_UTF8100, string(x.File))
 52546  				}
 52547  			} else {
 52548  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 52549  				r.EncodeString(codecSelferC_UTF8100, string("File"))
 52550  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 52551  				yym5 := z.EncBinary()
 52552  				_ = yym5
 52553  				if false {
 52554  				} else {
 52555  					r.EncodeString(codecSelferC_UTF8100, string(x.File))
 52556  				}
 52557  			}
 52558  			if yyr2 || yy2arr2 {
 52559  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 52560  			} else {
 52561  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 52562  			}
 52563  		}
 52564  	}
 52565  }
 52566  
 52567  func (x *DispatchPayloadConfig) CodecDecodeSelf(d *codec1978.Decoder) {
 52568  	var h codecSelfer100
 52569  	z, r := codec1978.GenHelperDecoder(d)
 52570  	_, _, _ = h, z, r
 52571  	yym1 := z.DecBinary()
 52572  	_ = yym1
 52573  	if false {
 52574  	} else if z.HasExtensions() && z.DecExt(x) {
 52575  	} else {
 52576  		yyct2 := r.ContainerType()
 52577  		if yyct2 == codecSelferValueTypeMap100 {
 52578  			yyl2 := r.ReadMapStart()
 52579  			if yyl2 == 0 {
 52580  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 52581  			} else {
 52582  				x.codecDecodeSelfFromMap(yyl2, d)
 52583  			}
 52584  		} else if yyct2 == codecSelferValueTypeArray100 {
 52585  			yyl2 := r.ReadArrayStart()
 52586  			if yyl2 == 0 {
 52587  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52588  			} else {
 52589  				x.codecDecodeSelfFromArray(yyl2, d)
 52590  			}
 52591  		} else {
 52592  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 52593  		}
 52594  	}
 52595  }
 52596  
 52597  func (x *DispatchPayloadConfig) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 52598  	var h codecSelfer100
 52599  	z, r := codec1978.GenHelperDecoder(d)
 52600  	_, _, _ = h, z, r
 52601  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 52602  	_ = yys3Slc
 52603  	var yyhl3 bool = l >= 0
 52604  	for yyj3 := 0; ; yyj3++ {
 52605  		if yyhl3 {
 52606  			if yyj3 >= l {
 52607  				break
 52608  			}
 52609  		} else {
 52610  			if r.CheckBreak() {
 52611  				break
 52612  			}
 52613  		}
 52614  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 52615  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 52616  		yys3 := string(yys3Slc)
 52617  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 52618  		switch yys3 {
 52619  		case "File":
 52620  			if r.TryDecodeAsNil() {
 52621  				x.File = ""
 52622  			} else {
 52623  				yyv4 := &x.File
 52624  				yym5 := z.DecBinary()
 52625  				_ = yym5
 52626  				if false {
 52627  				} else {
 52628  					*((*string)(yyv4)) = r.DecodeString()
 52629  				}
 52630  			}
 52631  		default:
 52632  			z.DecStructFieldNotFound(-1, yys3)
 52633  		} // end switch yys3
 52634  	} // end for yyj3
 52635  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 52636  }
 52637  
 52638  func (x *DispatchPayloadConfig) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 52639  	var h codecSelfer100
 52640  	z, r := codec1978.GenHelperDecoder(d)
 52641  	_, _, _ = h, z, r
 52642  	var yyj6 int
 52643  	var yyb6 bool
 52644  	var yyhl6 bool = l >= 0
 52645  	yyj6++
 52646  	if yyhl6 {
 52647  		yyb6 = yyj6 > l
 52648  	} else {
 52649  		yyb6 = r.CheckBreak()
 52650  	}
 52651  	if yyb6 {
 52652  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52653  		return
 52654  	}
 52655  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52656  	if r.TryDecodeAsNil() {
 52657  		x.File = ""
 52658  	} else {
 52659  		yyv7 := &x.File
 52660  		yym8 := z.DecBinary()
 52661  		_ = yym8
 52662  		if false {
 52663  		} else {
 52664  			*((*string)(yyv7)) = r.DecodeString()
 52665  		}
 52666  	}
 52667  	for {
 52668  		yyj6++
 52669  		if yyhl6 {
 52670  			yyb6 = yyj6 > l
 52671  		} else {
 52672  			yyb6 = r.CheckBreak()
 52673  		}
 52674  		if yyb6 {
 52675  			break
 52676  		}
 52677  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52678  		z.DecStructFieldNotFound(yyj6-1, "")
 52679  	}
 52680  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52681  }
 52682  
 52683  func (x *RestartPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
 52684  	var h codecSelfer100
 52685  	z, r := codec1978.GenHelperEncoder(e)
 52686  	_, _, _ = h, z, r
 52687  	if x == nil {
 52688  		r.EncodeNil()
 52689  	} else {
 52690  		yym1 := z.EncBinary()
 52691  		_ = yym1
 52692  		if false {
 52693  		} else if z.HasExtensions() && z.EncExt(x) {
 52694  		} else {
 52695  			yysep2 := !z.EncBinary()
 52696  			yy2arr2 := z.EncBasicHandle().StructToArray
 52697  			var yyq2 [4]bool
 52698  			_, _, _ = yysep2, yyq2, yy2arr2
 52699  			const yyr2 bool = false
 52700  			var yynn2 int
 52701  			if yyr2 || yy2arr2 {
 52702  				r.EncodeArrayStart(4)
 52703  			} else {
 52704  				yynn2 = 4
 52705  				for _, b := range yyq2 {
 52706  					if b {
 52707  						yynn2++
 52708  					}
 52709  				}
 52710  				r.EncodeMapStart(yynn2)
 52711  				yynn2 = 0
 52712  			}
 52713  			if yyr2 || yy2arr2 {
 52714  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 52715  				yym4 := z.EncBinary()
 52716  				_ = yym4
 52717  				if false {
 52718  				} else {
 52719  					r.EncodeInt(int64(x.Attempts))
 52720  				}
 52721  			} else {
 52722  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 52723  				r.EncodeString(codecSelferC_UTF8100, string("Attempts"))
 52724  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 52725  				yym5 := z.EncBinary()
 52726  				_ = yym5
 52727  				if false {
 52728  				} else {
 52729  					r.EncodeInt(int64(x.Attempts))
 52730  				}
 52731  			}
 52732  			if yyr2 || yy2arr2 {
 52733  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 52734  				yym7 := z.EncBinary()
 52735  				_ = yym7
 52736  				if false {
 52737  				} else if z.HasExtensions() && z.EncExt(x.Interval) {
 52738  				} else {
 52739  					r.EncodeInt(int64(x.Interval))
 52740  				}
 52741  			} else {
 52742  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 52743  				r.EncodeString(codecSelferC_UTF8100, string("Interval"))
 52744  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 52745  				yym8 := z.EncBinary()
 52746  				_ = yym8
 52747  				if false {
 52748  				} else if z.HasExtensions() && z.EncExt(x.Interval) {
 52749  				} else {
 52750  					r.EncodeInt(int64(x.Interval))
 52751  				}
 52752  			}
 52753  			if yyr2 || yy2arr2 {
 52754  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 52755  				yym10 := z.EncBinary()
 52756  				_ = yym10
 52757  				if false {
 52758  				} else if z.HasExtensions() && z.EncExt(x.Delay) {
 52759  				} else {
 52760  					r.EncodeInt(int64(x.Delay))
 52761  				}
 52762  			} else {
 52763  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 52764  				r.EncodeString(codecSelferC_UTF8100, string("Delay"))
 52765  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 52766  				yym11 := z.EncBinary()
 52767  				_ = yym11
 52768  				if false {
 52769  				} else if z.HasExtensions() && z.EncExt(x.Delay) {
 52770  				} else {
 52771  					r.EncodeInt(int64(x.Delay))
 52772  				}
 52773  			}
 52774  			if yyr2 || yy2arr2 {
 52775  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 52776  				yym13 := z.EncBinary()
 52777  				_ = yym13
 52778  				if false {
 52779  				} else {
 52780  					r.EncodeString(codecSelferC_UTF8100, string(x.Mode))
 52781  				}
 52782  			} else {
 52783  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 52784  				r.EncodeString(codecSelferC_UTF8100, string("Mode"))
 52785  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 52786  				yym14 := z.EncBinary()
 52787  				_ = yym14
 52788  				if false {
 52789  				} else {
 52790  					r.EncodeString(codecSelferC_UTF8100, string(x.Mode))
 52791  				}
 52792  			}
 52793  			if yyr2 || yy2arr2 {
 52794  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 52795  			} else {
 52796  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 52797  			}
 52798  		}
 52799  	}
 52800  }
 52801  
 52802  func (x *RestartPolicy) CodecDecodeSelf(d *codec1978.Decoder) {
 52803  	var h codecSelfer100
 52804  	z, r := codec1978.GenHelperDecoder(d)
 52805  	_, _, _ = h, z, r
 52806  	yym1 := z.DecBinary()
 52807  	_ = yym1
 52808  	if false {
 52809  	} else if z.HasExtensions() && z.DecExt(x) {
 52810  	} else {
 52811  		yyct2 := r.ContainerType()
 52812  		if yyct2 == codecSelferValueTypeMap100 {
 52813  			yyl2 := r.ReadMapStart()
 52814  			if yyl2 == 0 {
 52815  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 52816  			} else {
 52817  				x.codecDecodeSelfFromMap(yyl2, d)
 52818  			}
 52819  		} else if yyct2 == codecSelferValueTypeArray100 {
 52820  			yyl2 := r.ReadArrayStart()
 52821  			if yyl2 == 0 {
 52822  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52823  			} else {
 52824  				x.codecDecodeSelfFromArray(yyl2, d)
 52825  			}
 52826  		} else {
 52827  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 52828  		}
 52829  	}
 52830  }
 52831  
 52832  func (x *RestartPolicy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 52833  	var h codecSelfer100
 52834  	z, r := codec1978.GenHelperDecoder(d)
 52835  	_, _, _ = h, z, r
 52836  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 52837  	_ = yys3Slc
 52838  	var yyhl3 bool = l >= 0
 52839  	for yyj3 := 0; ; yyj3++ {
 52840  		if yyhl3 {
 52841  			if yyj3 >= l {
 52842  				break
 52843  			}
 52844  		} else {
 52845  			if r.CheckBreak() {
 52846  				break
 52847  			}
 52848  		}
 52849  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 52850  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 52851  		yys3 := string(yys3Slc)
 52852  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 52853  		switch yys3 {
 52854  		case "Attempts":
 52855  			if r.TryDecodeAsNil() {
 52856  				x.Attempts = 0
 52857  			} else {
 52858  				yyv4 := &x.Attempts
 52859  				yym5 := z.DecBinary()
 52860  				_ = yym5
 52861  				if false {
 52862  				} else {
 52863  					*((*int)(yyv4)) = int(r.DecodeInt(codecSelferBitsize100))
 52864  				}
 52865  			}
 52866  		case "Interval":
 52867  			if r.TryDecodeAsNil() {
 52868  				x.Interval = 0
 52869  			} else {
 52870  				yyv6 := &x.Interval
 52871  				yym7 := z.DecBinary()
 52872  				_ = yym7
 52873  				if false {
 52874  				} else if z.HasExtensions() && z.DecExt(yyv6) {
 52875  				} else {
 52876  					*((*int64)(yyv6)) = int64(r.DecodeInt(64))
 52877  				}
 52878  			}
 52879  		case "Delay":
 52880  			if r.TryDecodeAsNil() {
 52881  				x.Delay = 0
 52882  			} else {
 52883  				yyv8 := &x.Delay
 52884  				yym9 := z.DecBinary()
 52885  				_ = yym9
 52886  				if false {
 52887  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 52888  				} else {
 52889  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 52890  				}
 52891  			}
 52892  		case "Mode":
 52893  			if r.TryDecodeAsNil() {
 52894  				x.Mode = ""
 52895  			} else {
 52896  				yyv10 := &x.Mode
 52897  				yym11 := z.DecBinary()
 52898  				_ = yym11
 52899  				if false {
 52900  				} else {
 52901  					*((*string)(yyv10)) = r.DecodeString()
 52902  				}
 52903  			}
 52904  		default:
 52905  			z.DecStructFieldNotFound(-1, yys3)
 52906  		} // end switch yys3
 52907  	} // end for yyj3
 52908  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 52909  }
 52910  
 52911  func (x *RestartPolicy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 52912  	var h codecSelfer100
 52913  	z, r := codec1978.GenHelperDecoder(d)
 52914  	_, _, _ = h, z, r
 52915  	var yyj12 int
 52916  	var yyb12 bool
 52917  	var yyhl12 bool = l >= 0
 52918  	yyj12++
 52919  	if yyhl12 {
 52920  		yyb12 = yyj12 > l
 52921  	} else {
 52922  		yyb12 = r.CheckBreak()
 52923  	}
 52924  	if yyb12 {
 52925  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52926  		return
 52927  	}
 52928  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52929  	if r.TryDecodeAsNil() {
 52930  		x.Attempts = 0
 52931  	} else {
 52932  		yyv13 := &x.Attempts
 52933  		yym14 := z.DecBinary()
 52934  		_ = yym14
 52935  		if false {
 52936  		} else {
 52937  			*((*int)(yyv13)) = int(r.DecodeInt(codecSelferBitsize100))
 52938  		}
 52939  	}
 52940  	yyj12++
 52941  	if yyhl12 {
 52942  		yyb12 = yyj12 > l
 52943  	} else {
 52944  		yyb12 = r.CheckBreak()
 52945  	}
 52946  	if yyb12 {
 52947  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52948  		return
 52949  	}
 52950  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52951  	if r.TryDecodeAsNil() {
 52952  		x.Interval = 0
 52953  	} else {
 52954  		yyv15 := &x.Interval
 52955  		yym16 := z.DecBinary()
 52956  		_ = yym16
 52957  		if false {
 52958  		} else if z.HasExtensions() && z.DecExt(yyv15) {
 52959  		} else {
 52960  			*((*int64)(yyv15)) = int64(r.DecodeInt(64))
 52961  		}
 52962  	}
 52963  	yyj12++
 52964  	if yyhl12 {
 52965  		yyb12 = yyj12 > l
 52966  	} else {
 52967  		yyb12 = r.CheckBreak()
 52968  	}
 52969  	if yyb12 {
 52970  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52971  		return
 52972  	}
 52973  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52974  	if r.TryDecodeAsNil() {
 52975  		x.Delay = 0
 52976  	} else {
 52977  		yyv17 := &x.Delay
 52978  		yym18 := z.DecBinary()
 52979  		_ = yym18
 52980  		if false {
 52981  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 52982  		} else {
 52983  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 52984  		}
 52985  	}
 52986  	yyj12++
 52987  	if yyhl12 {
 52988  		yyb12 = yyj12 > l
 52989  	} else {
 52990  		yyb12 = r.CheckBreak()
 52991  	}
 52992  	if yyb12 {
 52993  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 52994  		return
 52995  	}
 52996  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 52997  	if r.TryDecodeAsNil() {
 52998  		x.Mode = ""
 52999  	} else {
 53000  		yyv19 := &x.Mode
 53001  		yym20 := z.DecBinary()
 53002  		_ = yym20
 53003  		if false {
 53004  		} else {
 53005  			*((*string)(yyv19)) = r.DecodeString()
 53006  		}
 53007  	}
 53008  	for {
 53009  		yyj12++
 53010  		if yyhl12 {
 53011  			yyb12 = yyj12 > l
 53012  		} else {
 53013  			yyb12 = r.CheckBreak()
 53014  		}
 53015  		if yyb12 {
 53016  			break
 53017  		}
 53018  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 53019  		z.DecStructFieldNotFound(yyj12-1, "")
 53020  	}
 53021  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 53022  }
 53023  
 53024  func (x *ReschedulePolicy) CodecEncodeSelf(e *codec1978.Encoder) {
 53025  	var h codecSelfer100
 53026  	z, r := codec1978.GenHelperEncoder(e)
 53027  	_, _, _ = h, z, r
 53028  	if x == nil {
 53029  		r.EncodeNil()
 53030  	} else {
 53031  		yym1 := z.EncBinary()
 53032  		_ = yym1
 53033  		if false {
 53034  		} else if z.HasExtensions() && z.EncExt(x) {
 53035  		} else {
 53036  			yysep2 := !z.EncBinary()
 53037  			yy2arr2 := z.EncBasicHandle().StructToArray
 53038  			var yyq2 [6]bool
 53039  			_, _, _ = yysep2, yyq2, yy2arr2
 53040  			const yyr2 bool = false
 53041  			var yynn2 int
 53042  			if yyr2 || yy2arr2 {
 53043  				r.EncodeArrayStart(6)
 53044  			} else {
 53045  				yynn2 = 6
 53046  				for _, b := range yyq2 {
 53047  					if b {
 53048  						yynn2++
 53049  					}
 53050  				}
 53051  				r.EncodeMapStart(yynn2)
 53052  				yynn2 = 0
 53053  			}
 53054  			if yyr2 || yy2arr2 {
 53055  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53056  				yym4 := z.EncBinary()
 53057  				_ = yym4
 53058  				if false {
 53059  				} else {
 53060  					r.EncodeInt(int64(x.Attempts))
 53061  				}
 53062  			} else {
 53063  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53064  				r.EncodeString(codecSelferC_UTF8100, string("Attempts"))
 53065  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53066  				yym5 := z.EncBinary()
 53067  				_ = yym5
 53068  				if false {
 53069  				} else {
 53070  					r.EncodeInt(int64(x.Attempts))
 53071  				}
 53072  			}
 53073  			if yyr2 || yy2arr2 {
 53074  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53075  				yym7 := z.EncBinary()
 53076  				_ = yym7
 53077  				if false {
 53078  				} else if z.HasExtensions() && z.EncExt(x.Interval) {
 53079  				} else {
 53080  					r.EncodeInt(int64(x.Interval))
 53081  				}
 53082  			} else {
 53083  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53084  				r.EncodeString(codecSelferC_UTF8100, string("Interval"))
 53085  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53086  				yym8 := z.EncBinary()
 53087  				_ = yym8
 53088  				if false {
 53089  				} else if z.HasExtensions() && z.EncExt(x.Interval) {
 53090  				} else {
 53091  					r.EncodeInt(int64(x.Interval))
 53092  				}
 53093  			}
 53094  			if yyr2 || yy2arr2 {
 53095  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53096  				yym10 := z.EncBinary()
 53097  				_ = yym10
 53098  				if false {
 53099  				} else if z.HasExtensions() && z.EncExt(x.Delay) {
 53100  				} else {
 53101  					r.EncodeInt(int64(x.Delay))
 53102  				}
 53103  			} else {
 53104  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53105  				r.EncodeString(codecSelferC_UTF8100, string("Delay"))
 53106  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53107  				yym11 := z.EncBinary()
 53108  				_ = yym11
 53109  				if false {
 53110  				} else if z.HasExtensions() && z.EncExt(x.Delay) {
 53111  				} else {
 53112  					r.EncodeInt(int64(x.Delay))
 53113  				}
 53114  			}
 53115  			if yyr2 || yy2arr2 {
 53116  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53117  				yym13 := z.EncBinary()
 53118  				_ = yym13
 53119  				if false {
 53120  				} else {
 53121  					r.EncodeString(codecSelferC_UTF8100, string(x.DelayFunction))
 53122  				}
 53123  			} else {
 53124  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53125  				r.EncodeString(codecSelferC_UTF8100, string("DelayFunction"))
 53126  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53127  				yym14 := z.EncBinary()
 53128  				_ = yym14
 53129  				if false {
 53130  				} else {
 53131  					r.EncodeString(codecSelferC_UTF8100, string(x.DelayFunction))
 53132  				}
 53133  			}
 53134  			if yyr2 || yy2arr2 {
 53135  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53136  				yym16 := z.EncBinary()
 53137  				_ = yym16
 53138  				if false {
 53139  				} else if z.HasExtensions() && z.EncExt(x.MaxDelay) {
 53140  				} else {
 53141  					r.EncodeInt(int64(x.MaxDelay))
 53142  				}
 53143  			} else {
 53144  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53145  				r.EncodeString(codecSelferC_UTF8100, string("MaxDelay"))
 53146  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53147  				yym17 := z.EncBinary()
 53148  				_ = yym17
 53149  				if false {
 53150  				} else if z.HasExtensions() && z.EncExt(x.MaxDelay) {
 53151  				} else {
 53152  					r.EncodeInt(int64(x.MaxDelay))
 53153  				}
 53154  			}
 53155  			if yyr2 || yy2arr2 {
 53156  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53157  				yym19 := z.EncBinary()
 53158  				_ = yym19
 53159  				if false {
 53160  				} else {
 53161  					r.EncodeBool(bool(x.Unlimited))
 53162  				}
 53163  			} else {
 53164  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53165  				r.EncodeString(codecSelferC_UTF8100, string("Unlimited"))
 53166  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53167  				yym20 := z.EncBinary()
 53168  				_ = yym20
 53169  				if false {
 53170  				} else {
 53171  					r.EncodeBool(bool(x.Unlimited))
 53172  				}
 53173  			}
 53174  			if yyr2 || yy2arr2 {
 53175  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 53176  			} else {
 53177  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 53178  			}
 53179  		}
 53180  	}
 53181  }
 53182  
 53183  func (x *ReschedulePolicy) CodecDecodeSelf(d *codec1978.Decoder) {
 53184  	var h codecSelfer100
 53185  	z, r := codec1978.GenHelperDecoder(d)
 53186  	_, _, _ = h, z, r
 53187  	yym1 := z.DecBinary()
 53188  	_ = yym1
 53189  	if false {
 53190  	} else if z.HasExtensions() && z.DecExt(x) {
 53191  	} else {
 53192  		yyct2 := r.ContainerType()
 53193  		if yyct2 == codecSelferValueTypeMap100 {
 53194  			yyl2 := r.ReadMapStart()
 53195  			if yyl2 == 0 {
 53196  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 53197  			} else {
 53198  				x.codecDecodeSelfFromMap(yyl2, d)
 53199  			}
 53200  		} else if yyct2 == codecSelferValueTypeArray100 {
 53201  			yyl2 := r.ReadArrayStart()
 53202  			if yyl2 == 0 {
 53203  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 53204  			} else {
 53205  				x.codecDecodeSelfFromArray(yyl2, d)
 53206  			}
 53207  		} else {
 53208  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 53209  		}
 53210  	}
 53211  }
 53212  
 53213  func (x *ReschedulePolicy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 53214  	var h codecSelfer100
 53215  	z, r := codec1978.GenHelperDecoder(d)
 53216  	_, _, _ = h, z, r
 53217  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 53218  	_ = yys3Slc
 53219  	var yyhl3 bool = l >= 0
 53220  	for yyj3 := 0; ; yyj3++ {
 53221  		if yyhl3 {
 53222  			if yyj3 >= l {
 53223  				break
 53224  			}
 53225  		} else {
 53226  			if r.CheckBreak() {
 53227  				break
 53228  			}
 53229  		}
 53230  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 53231  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 53232  		yys3 := string(yys3Slc)
 53233  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 53234  		switch yys3 {
 53235  		case "Attempts":
 53236  			if r.TryDecodeAsNil() {
 53237  				x.Attempts = 0
 53238  			} else {
 53239  				yyv4 := &x.Attempts
 53240  				yym5 := z.DecBinary()
 53241  				_ = yym5
 53242  				if false {
 53243  				} else {
 53244  					*((*int)(yyv4)) = int(r.DecodeInt(codecSelferBitsize100))
 53245  				}
 53246  			}
 53247  		case "Interval":
 53248  			if r.TryDecodeAsNil() {
 53249  				x.Interval = 0
 53250  			} else {
 53251  				yyv6 := &x.Interval
 53252  				yym7 := z.DecBinary()
 53253  				_ = yym7
 53254  				if false {
 53255  				} else if z.HasExtensions() && z.DecExt(yyv6) {
 53256  				} else {
 53257  					*((*int64)(yyv6)) = int64(r.DecodeInt(64))
 53258  				}
 53259  			}
 53260  		case "Delay":
 53261  			if r.TryDecodeAsNil() {
 53262  				x.Delay = 0
 53263  			} else {
 53264  				yyv8 := &x.Delay
 53265  				yym9 := z.DecBinary()
 53266  				_ = yym9
 53267  				if false {
 53268  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 53269  				} else {
 53270  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 53271  				}
 53272  			}
 53273  		case "DelayFunction":
 53274  			if r.TryDecodeAsNil() {
 53275  				x.DelayFunction = ""
 53276  			} else {
 53277  				yyv10 := &x.DelayFunction
 53278  				yym11 := z.DecBinary()
 53279  				_ = yym11
 53280  				if false {
 53281  				} else {
 53282  					*((*string)(yyv10)) = r.DecodeString()
 53283  				}
 53284  			}
 53285  		case "MaxDelay":
 53286  			if r.TryDecodeAsNil() {
 53287  				x.MaxDelay = 0
 53288  			} else {
 53289  				yyv12 := &x.MaxDelay
 53290  				yym13 := z.DecBinary()
 53291  				_ = yym13
 53292  				if false {
 53293  				} else if z.HasExtensions() && z.DecExt(yyv12) {
 53294  				} else {
 53295  					*((*int64)(yyv12)) = int64(r.DecodeInt(64))
 53296  				}
 53297  			}
 53298  		case "Unlimited":
 53299  			if r.TryDecodeAsNil() {
 53300  				x.Unlimited = false
 53301  			} else {
 53302  				yyv14 := &x.Unlimited
 53303  				yym15 := z.DecBinary()
 53304  				_ = yym15
 53305  				if false {
 53306  				} else {
 53307  					*((*bool)(yyv14)) = r.DecodeBool()
 53308  				}
 53309  			}
 53310  		default:
 53311  			z.DecStructFieldNotFound(-1, yys3)
 53312  		} // end switch yys3
 53313  	} // end for yyj3
 53314  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 53315  }
 53316  
 53317  func (x *ReschedulePolicy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 53318  	var h codecSelfer100
 53319  	z, r := codec1978.GenHelperDecoder(d)
 53320  	_, _, _ = h, z, r
 53321  	var yyj16 int
 53322  	var yyb16 bool
 53323  	var yyhl16 bool = l >= 0
 53324  	yyj16++
 53325  	if yyhl16 {
 53326  		yyb16 = yyj16 > l
 53327  	} else {
 53328  		yyb16 = r.CheckBreak()
 53329  	}
 53330  	if yyb16 {
 53331  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 53332  		return
 53333  	}
 53334  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 53335  	if r.TryDecodeAsNil() {
 53336  		x.Attempts = 0
 53337  	} else {
 53338  		yyv17 := &x.Attempts
 53339  		yym18 := z.DecBinary()
 53340  		_ = yym18
 53341  		if false {
 53342  		} else {
 53343  			*((*int)(yyv17)) = int(r.DecodeInt(codecSelferBitsize100))
 53344  		}
 53345  	}
 53346  	yyj16++
 53347  	if yyhl16 {
 53348  		yyb16 = yyj16 > l
 53349  	} else {
 53350  		yyb16 = r.CheckBreak()
 53351  	}
 53352  	if yyb16 {
 53353  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 53354  		return
 53355  	}
 53356  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 53357  	if r.TryDecodeAsNil() {
 53358  		x.Interval = 0
 53359  	} else {
 53360  		yyv19 := &x.Interval
 53361  		yym20 := z.DecBinary()
 53362  		_ = yym20
 53363  		if false {
 53364  		} else if z.HasExtensions() && z.DecExt(yyv19) {
 53365  		} else {
 53366  			*((*int64)(yyv19)) = int64(r.DecodeInt(64))
 53367  		}
 53368  	}
 53369  	yyj16++
 53370  	if yyhl16 {
 53371  		yyb16 = yyj16 > l
 53372  	} else {
 53373  		yyb16 = r.CheckBreak()
 53374  	}
 53375  	if yyb16 {
 53376  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 53377  		return
 53378  	}
 53379  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 53380  	if r.TryDecodeAsNil() {
 53381  		x.Delay = 0
 53382  	} else {
 53383  		yyv21 := &x.Delay
 53384  		yym22 := z.DecBinary()
 53385  		_ = yym22
 53386  		if false {
 53387  		} else if z.HasExtensions() && z.DecExt(yyv21) {
 53388  		} else {
 53389  			*((*int64)(yyv21)) = int64(r.DecodeInt(64))
 53390  		}
 53391  	}
 53392  	yyj16++
 53393  	if yyhl16 {
 53394  		yyb16 = yyj16 > l
 53395  	} else {
 53396  		yyb16 = r.CheckBreak()
 53397  	}
 53398  	if yyb16 {
 53399  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 53400  		return
 53401  	}
 53402  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 53403  	if r.TryDecodeAsNil() {
 53404  		x.DelayFunction = ""
 53405  	} else {
 53406  		yyv23 := &x.DelayFunction
 53407  		yym24 := z.DecBinary()
 53408  		_ = yym24
 53409  		if false {
 53410  		} else {
 53411  			*((*string)(yyv23)) = r.DecodeString()
 53412  		}
 53413  	}
 53414  	yyj16++
 53415  	if yyhl16 {
 53416  		yyb16 = yyj16 > l
 53417  	} else {
 53418  		yyb16 = r.CheckBreak()
 53419  	}
 53420  	if yyb16 {
 53421  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 53422  		return
 53423  	}
 53424  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 53425  	if r.TryDecodeAsNil() {
 53426  		x.MaxDelay = 0
 53427  	} else {
 53428  		yyv25 := &x.MaxDelay
 53429  		yym26 := z.DecBinary()
 53430  		_ = yym26
 53431  		if false {
 53432  		} else if z.HasExtensions() && z.DecExt(yyv25) {
 53433  		} else {
 53434  			*((*int64)(yyv25)) = int64(r.DecodeInt(64))
 53435  		}
 53436  	}
 53437  	yyj16++
 53438  	if yyhl16 {
 53439  		yyb16 = yyj16 > l
 53440  	} else {
 53441  		yyb16 = r.CheckBreak()
 53442  	}
 53443  	if yyb16 {
 53444  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 53445  		return
 53446  	}
 53447  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 53448  	if r.TryDecodeAsNil() {
 53449  		x.Unlimited = false
 53450  	} else {
 53451  		yyv27 := &x.Unlimited
 53452  		yym28 := z.DecBinary()
 53453  		_ = yym28
 53454  		if false {
 53455  		} else {
 53456  			*((*bool)(yyv27)) = r.DecodeBool()
 53457  		}
 53458  	}
 53459  	for {
 53460  		yyj16++
 53461  		if yyhl16 {
 53462  			yyb16 = yyj16 > l
 53463  		} else {
 53464  			yyb16 = r.CheckBreak()
 53465  		}
 53466  		if yyb16 {
 53467  			break
 53468  		}
 53469  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 53470  		z.DecStructFieldNotFound(yyj16-1, "")
 53471  	}
 53472  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 53473  }
 53474  
 53475  func (x *MigrateStrategy) CodecEncodeSelf(e *codec1978.Encoder) {
 53476  	var h codecSelfer100
 53477  	z, r := codec1978.GenHelperEncoder(e)
 53478  	_, _, _ = h, z, r
 53479  	if x == nil {
 53480  		r.EncodeNil()
 53481  	} else {
 53482  		yym1 := z.EncBinary()
 53483  		_ = yym1
 53484  		if false {
 53485  		} else if z.HasExtensions() && z.EncExt(x) {
 53486  		} else {
 53487  			yysep2 := !z.EncBinary()
 53488  			yy2arr2 := z.EncBasicHandle().StructToArray
 53489  			var yyq2 [4]bool
 53490  			_, _, _ = yysep2, yyq2, yy2arr2
 53491  			const yyr2 bool = false
 53492  			var yynn2 int
 53493  			if yyr2 || yy2arr2 {
 53494  				r.EncodeArrayStart(4)
 53495  			} else {
 53496  				yynn2 = 4
 53497  				for _, b := range yyq2 {
 53498  					if b {
 53499  						yynn2++
 53500  					}
 53501  				}
 53502  				r.EncodeMapStart(yynn2)
 53503  				yynn2 = 0
 53504  			}
 53505  			if yyr2 || yy2arr2 {
 53506  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53507  				yym4 := z.EncBinary()
 53508  				_ = yym4
 53509  				if false {
 53510  				} else {
 53511  					r.EncodeInt(int64(x.MaxParallel))
 53512  				}
 53513  			} else {
 53514  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53515  				r.EncodeString(codecSelferC_UTF8100, string("MaxParallel"))
 53516  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53517  				yym5 := z.EncBinary()
 53518  				_ = yym5
 53519  				if false {
 53520  				} else {
 53521  					r.EncodeInt(int64(x.MaxParallel))
 53522  				}
 53523  			}
 53524  			if yyr2 || yy2arr2 {
 53525  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53526  				yym7 := z.EncBinary()
 53527  				_ = yym7
 53528  				if false {
 53529  				} else {
 53530  					r.EncodeString(codecSelferC_UTF8100, string(x.HealthCheck))
 53531  				}
 53532  			} else {
 53533  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53534  				r.EncodeString(codecSelferC_UTF8100, string("HealthCheck"))
 53535  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53536  				yym8 := z.EncBinary()
 53537  				_ = yym8
 53538  				if false {
 53539  				} else {
 53540  					r.EncodeString(codecSelferC_UTF8100, string(x.HealthCheck))
 53541  				}
 53542  			}
 53543  			if yyr2 || yy2arr2 {
 53544  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53545  				yym10 := z.EncBinary()
 53546  				_ = yym10
 53547  				if false {
 53548  				} else if z.HasExtensions() && z.EncExt(x.MinHealthyTime) {
 53549  				} else {
 53550  					r.EncodeInt(int64(x.MinHealthyTime))
 53551  				}
 53552  			} else {
 53553  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53554  				r.EncodeString(codecSelferC_UTF8100, string("MinHealthyTime"))
 53555  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53556  				yym11 := z.EncBinary()
 53557  				_ = yym11
 53558  				if false {
 53559  				} else if z.HasExtensions() && z.EncExt(x.MinHealthyTime) {
 53560  				} else {
 53561  					r.EncodeInt(int64(x.MinHealthyTime))
 53562  				}
 53563  			}
 53564  			if yyr2 || yy2arr2 {
 53565  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53566  				yym13 := z.EncBinary()
 53567  				_ = yym13
 53568  				if false {
 53569  				} else if z.HasExtensions() && z.EncExt(x.HealthyDeadline) {
 53570  				} else {
 53571  					r.EncodeInt(int64(x.HealthyDeadline))
 53572  				}
 53573  			} else {
 53574  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53575  				r.EncodeString(codecSelferC_UTF8100, string("HealthyDeadline"))
 53576  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53577  				yym14 := z.EncBinary()
 53578  				_ = yym14
 53579  				if false {
 53580  				} else if z.HasExtensions() && z.EncExt(x.HealthyDeadline) {
 53581  				} else {
 53582  					r.EncodeInt(int64(x.HealthyDeadline))
 53583  				}
 53584  			}
 53585  			if yyr2 || yy2arr2 {
 53586  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 53587  			} else {
 53588  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 53589  			}
 53590  		}
 53591  	}
 53592  }
 53593  
 53594  func (x *MigrateStrategy) CodecDecodeSelf(d *codec1978.Decoder) {
 53595  	var h codecSelfer100
 53596  	z, r := codec1978.GenHelperDecoder(d)
 53597  	_, _, _ = h, z, r
 53598  	yym1 := z.DecBinary()
 53599  	_ = yym1
 53600  	if false {
 53601  	} else if z.HasExtensions() && z.DecExt(x) {
 53602  	} else {
 53603  		yyct2 := r.ContainerType()
 53604  		if yyct2 == codecSelferValueTypeMap100 {
 53605  			yyl2 := r.ReadMapStart()
 53606  			if yyl2 == 0 {
 53607  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 53608  			} else {
 53609  				x.codecDecodeSelfFromMap(yyl2, d)
 53610  			}
 53611  		} else if yyct2 == codecSelferValueTypeArray100 {
 53612  			yyl2 := r.ReadArrayStart()
 53613  			if yyl2 == 0 {
 53614  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 53615  			} else {
 53616  				x.codecDecodeSelfFromArray(yyl2, d)
 53617  			}
 53618  		} else {
 53619  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 53620  		}
 53621  	}
 53622  }
 53623  
 53624  func (x *MigrateStrategy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 53625  	var h codecSelfer100
 53626  	z, r := codec1978.GenHelperDecoder(d)
 53627  	_, _, _ = h, z, r
 53628  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 53629  	_ = yys3Slc
 53630  	var yyhl3 bool = l >= 0
 53631  	for yyj3 := 0; ; yyj3++ {
 53632  		if yyhl3 {
 53633  			if yyj3 >= l {
 53634  				break
 53635  			}
 53636  		} else {
 53637  			if r.CheckBreak() {
 53638  				break
 53639  			}
 53640  		}
 53641  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 53642  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 53643  		yys3 := string(yys3Slc)
 53644  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 53645  		switch yys3 {
 53646  		case "MaxParallel":
 53647  			if r.TryDecodeAsNil() {
 53648  				x.MaxParallel = 0
 53649  			} else {
 53650  				yyv4 := &x.MaxParallel
 53651  				yym5 := z.DecBinary()
 53652  				_ = yym5
 53653  				if false {
 53654  				} else {
 53655  					*((*int)(yyv4)) = int(r.DecodeInt(codecSelferBitsize100))
 53656  				}
 53657  			}
 53658  		case "HealthCheck":
 53659  			if r.TryDecodeAsNil() {
 53660  				x.HealthCheck = ""
 53661  			} else {
 53662  				yyv6 := &x.HealthCheck
 53663  				yym7 := z.DecBinary()
 53664  				_ = yym7
 53665  				if false {
 53666  				} else {
 53667  					*((*string)(yyv6)) = r.DecodeString()
 53668  				}
 53669  			}
 53670  		case "MinHealthyTime":
 53671  			if r.TryDecodeAsNil() {
 53672  				x.MinHealthyTime = 0
 53673  			} else {
 53674  				yyv8 := &x.MinHealthyTime
 53675  				yym9 := z.DecBinary()
 53676  				_ = yym9
 53677  				if false {
 53678  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 53679  				} else {
 53680  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 53681  				}
 53682  			}
 53683  		case "HealthyDeadline":
 53684  			if r.TryDecodeAsNil() {
 53685  				x.HealthyDeadline = 0
 53686  			} else {
 53687  				yyv10 := &x.HealthyDeadline
 53688  				yym11 := z.DecBinary()
 53689  				_ = yym11
 53690  				if false {
 53691  				} else if z.HasExtensions() && z.DecExt(yyv10) {
 53692  				} else {
 53693  					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
 53694  				}
 53695  			}
 53696  		default:
 53697  			z.DecStructFieldNotFound(-1, yys3)
 53698  		} // end switch yys3
 53699  	} // end for yyj3
 53700  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 53701  }
 53702  
 53703  func (x *MigrateStrategy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 53704  	var h codecSelfer100
 53705  	z, r := codec1978.GenHelperDecoder(d)
 53706  	_, _, _ = h, z, r
 53707  	var yyj12 int
 53708  	var yyb12 bool
 53709  	var yyhl12 bool = l >= 0
 53710  	yyj12++
 53711  	if yyhl12 {
 53712  		yyb12 = yyj12 > l
 53713  	} else {
 53714  		yyb12 = r.CheckBreak()
 53715  	}
 53716  	if yyb12 {
 53717  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 53718  		return
 53719  	}
 53720  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 53721  	if r.TryDecodeAsNil() {
 53722  		x.MaxParallel = 0
 53723  	} else {
 53724  		yyv13 := &x.MaxParallel
 53725  		yym14 := z.DecBinary()
 53726  		_ = yym14
 53727  		if false {
 53728  		} else {
 53729  			*((*int)(yyv13)) = int(r.DecodeInt(codecSelferBitsize100))
 53730  		}
 53731  	}
 53732  	yyj12++
 53733  	if yyhl12 {
 53734  		yyb12 = yyj12 > l
 53735  	} else {
 53736  		yyb12 = r.CheckBreak()
 53737  	}
 53738  	if yyb12 {
 53739  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 53740  		return
 53741  	}
 53742  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 53743  	if r.TryDecodeAsNil() {
 53744  		x.HealthCheck = ""
 53745  	} else {
 53746  		yyv15 := &x.HealthCheck
 53747  		yym16 := z.DecBinary()
 53748  		_ = yym16
 53749  		if false {
 53750  		} else {
 53751  			*((*string)(yyv15)) = r.DecodeString()
 53752  		}
 53753  	}
 53754  	yyj12++
 53755  	if yyhl12 {
 53756  		yyb12 = yyj12 > l
 53757  	} else {
 53758  		yyb12 = r.CheckBreak()
 53759  	}
 53760  	if yyb12 {
 53761  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 53762  		return
 53763  	}
 53764  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 53765  	if r.TryDecodeAsNil() {
 53766  		x.MinHealthyTime = 0
 53767  	} else {
 53768  		yyv17 := &x.MinHealthyTime
 53769  		yym18 := z.DecBinary()
 53770  		_ = yym18
 53771  		if false {
 53772  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 53773  		} else {
 53774  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 53775  		}
 53776  	}
 53777  	yyj12++
 53778  	if yyhl12 {
 53779  		yyb12 = yyj12 > l
 53780  	} else {
 53781  		yyb12 = r.CheckBreak()
 53782  	}
 53783  	if yyb12 {
 53784  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 53785  		return
 53786  	}
 53787  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 53788  	if r.TryDecodeAsNil() {
 53789  		x.HealthyDeadline = 0
 53790  	} else {
 53791  		yyv19 := &x.HealthyDeadline
 53792  		yym20 := z.DecBinary()
 53793  		_ = yym20
 53794  		if false {
 53795  		} else if z.HasExtensions() && z.DecExt(yyv19) {
 53796  		} else {
 53797  			*((*int64)(yyv19)) = int64(r.DecodeInt(64))
 53798  		}
 53799  	}
 53800  	for {
 53801  		yyj12++
 53802  		if yyhl12 {
 53803  			yyb12 = yyj12 > l
 53804  		} else {
 53805  			yyb12 = r.CheckBreak()
 53806  		}
 53807  		if yyb12 {
 53808  			break
 53809  		}
 53810  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 53811  		z.DecStructFieldNotFound(yyj12-1, "")
 53812  	}
 53813  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 53814  }
 53815  
 53816  func (x *TaskGroup) CodecEncodeSelf(e *codec1978.Encoder) {
 53817  	var h codecSelfer100
 53818  	z, r := codec1978.GenHelperEncoder(e)
 53819  	_, _, _ = h, z, r
 53820  	if x == nil {
 53821  		r.EncodeNil()
 53822  	} else {
 53823  		yym1 := z.EncBinary()
 53824  		_ = yym1
 53825  		if false {
 53826  		} else if z.HasExtensions() && z.EncExt(x) {
 53827  		} else {
 53828  			yysep2 := !z.EncBinary()
 53829  			yy2arr2 := z.EncBasicHandle().StructToArray
 53830  			var yyq2 [10]bool
 53831  			_, _, _ = yysep2, yyq2, yy2arr2
 53832  			const yyr2 bool = false
 53833  			var yynn2 int
 53834  			if yyr2 || yy2arr2 {
 53835  				r.EncodeArrayStart(10)
 53836  			} else {
 53837  				yynn2 = 10
 53838  				for _, b := range yyq2 {
 53839  					if b {
 53840  						yynn2++
 53841  					}
 53842  				}
 53843  				r.EncodeMapStart(yynn2)
 53844  				yynn2 = 0
 53845  			}
 53846  			if yyr2 || yy2arr2 {
 53847  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53848  				yym4 := z.EncBinary()
 53849  				_ = yym4
 53850  				if false {
 53851  				} else {
 53852  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 53853  				}
 53854  			} else {
 53855  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53856  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 53857  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53858  				yym5 := z.EncBinary()
 53859  				_ = yym5
 53860  				if false {
 53861  				} else {
 53862  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 53863  				}
 53864  			}
 53865  			if yyr2 || yy2arr2 {
 53866  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53867  				yym7 := z.EncBinary()
 53868  				_ = yym7
 53869  				if false {
 53870  				} else {
 53871  					r.EncodeInt(int64(x.Count))
 53872  				}
 53873  			} else {
 53874  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53875  				r.EncodeString(codecSelferC_UTF8100, string("Count"))
 53876  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53877  				yym8 := z.EncBinary()
 53878  				_ = yym8
 53879  				if false {
 53880  				} else {
 53881  					r.EncodeInt(int64(x.Count))
 53882  				}
 53883  			}
 53884  			if yyr2 || yy2arr2 {
 53885  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53886  				if x.Update == nil {
 53887  					r.EncodeNil()
 53888  				} else {
 53889  					x.Update.CodecEncodeSelf(e)
 53890  				}
 53891  			} else {
 53892  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53893  				r.EncodeString(codecSelferC_UTF8100, string("Update"))
 53894  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53895  				if x.Update == nil {
 53896  					r.EncodeNil()
 53897  				} else {
 53898  					x.Update.CodecEncodeSelf(e)
 53899  				}
 53900  			}
 53901  			if yyr2 || yy2arr2 {
 53902  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53903  				if x.Migrate == nil {
 53904  					r.EncodeNil()
 53905  				} else {
 53906  					x.Migrate.CodecEncodeSelf(e)
 53907  				}
 53908  			} else {
 53909  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53910  				r.EncodeString(codecSelferC_UTF8100, string("Migrate"))
 53911  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53912  				if x.Migrate == nil {
 53913  					r.EncodeNil()
 53914  				} else {
 53915  					x.Migrate.CodecEncodeSelf(e)
 53916  				}
 53917  			}
 53918  			if yyr2 || yy2arr2 {
 53919  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53920  				if x.Constraints == nil {
 53921  					r.EncodeNil()
 53922  				} else {
 53923  					yym16 := z.EncBinary()
 53924  					_ = yym16
 53925  					if false {
 53926  					} else {
 53927  						h.encSlicePtrtoConstraint(([]*Constraint)(x.Constraints), e)
 53928  					}
 53929  				}
 53930  			} else {
 53931  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53932  				r.EncodeString(codecSelferC_UTF8100, string("Constraints"))
 53933  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53934  				if x.Constraints == nil {
 53935  					r.EncodeNil()
 53936  				} else {
 53937  					yym17 := z.EncBinary()
 53938  					_ = yym17
 53939  					if false {
 53940  					} else {
 53941  						h.encSlicePtrtoConstraint(([]*Constraint)(x.Constraints), e)
 53942  					}
 53943  				}
 53944  			}
 53945  			if yyr2 || yy2arr2 {
 53946  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53947  				if x.RestartPolicy == nil {
 53948  					r.EncodeNil()
 53949  				} else {
 53950  					x.RestartPolicy.CodecEncodeSelf(e)
 53951  				}
 53952  			} else {
 53953  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53954  				r.EncodeString(codecSelferC_UTF8100, string("RestartPolicy"))
 53955  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53956  				if x.RestartPolicy == nil {
 53957  					r.EncodeNil()
 53958  				} else {
 53959  					x.RestartPolicy.CodecEncodeSelf(e)
 53960  				}
 53961  			}
 53962  			if yyr2 || yy2arr2 {
 53963  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53964  				if x.Tasks == nil {
 53965  					r.EncodeNil()
 53966  				} else {
 53967  					yym22 := z.EncBinary()
 53968  					_ = yym22
 53969  					if false {
 53970  					} else {
 53971  						h.encSlicePtrtoTask(([]*Task)(x.Tasks), e)
 53972  					}
 53973  				}
 53974  			} else {
 53975  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53976  				r.EncodeString(codecSelferC_UTF8100, string("Tasks"))
 53977  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 53978  				if x.Tasks == nil {
 53979  					r.EncodeNil()
 53980  				} else {
 53981  					yym23 := z.EncBinary()
 53982  					_ = yym23
 53983  					if false {
 53984  					} else {
 53985  						h.encSlicePtrtoTask(([]*Task)(x.Tasks), e)
 53986  					}
 53987  				}
 53988  			}
 53989  			if yyr2 || yy2arr2 {
 53990  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 53991  				if x.EphemeralDisk == nil {
 53992  					r.EncodeNil()
 53993  				} else {
 53994  					x.EphemeralDisk.CodecEncodeSelf(e)
 53995  				}
 53996  			} else {
 53997  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 53998  				r.EncodeString(codecSelferC_UTF8100, string("EphemeralDisk"))
 53999  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54000  				if x.EphemeralDisk == nil {
 54001  					r.EncodeNil()
 54002  				} else {
 54003  					x.EphemeralDisk.CodecEncodeSelf(e)
 54004  				}
 54005  			}
 54006  			if yyr2 || yy2arr2 {
 54007  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54008  				if x.Meta == nil {
 54009  					r.EncodeNil()
 54010  				} else {
 54011  					yym28 := z.EncBinary()
 54012  					_ = yym28
 54013  					if false {
 54014  					} else {
 54015  						z.F.EncMapStringStringV(x.Meta, false, e)
 54016  					}
 54017  				}
 54018  			} else {
 54019  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54020  				r.EncodeString(codecSelferC_UTF8100, string("Meta"))
 54021  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54022  				if x.Meta == nil {
 54023  					r.EncodeNil()
 54024  				} else {
 54025  					yym29 := z.EncBinary()
 54026  					_ = yym29
 54027  					if false {
 54028  					} else {
 54029  						z.F.EncMapStringStringV(x.Meta, false, e)
 54030  					}
 54031  				}
 54032  			}
 54033  			if yyr2 || yy2arr2 {
 54034  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54035  				if x.ReschedulePolicy == nil {
 54036  					r.EncodeNil()
 54037  				} else {
 54038  					x.ReschedulePolicy.CodecEncodeSelf(e)
 54039  				}
 54040  			} else {
 54041  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54042  				r.EncodeString(codecSelferC_UTF8100, string("ReschedulePolicy"))
 54043  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54044  				if x.ReschedulePolicy == nil {
 54045  					r.EncodeNil()
 54046  				} else {
 54047  					x.ReschedulePolicy.CodecEncodeSelf(e)
 54048  				}
 54049  			}
 54050  			if yyr2 || yy2arr2 {
 54051  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 54052  			} else {
 54053  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 54054  			}
 54055  		}
 54056  	}
 54057  }
 54058  
 54059  func (x *TaskGroup) CodecDecodeSelf(d *codec1978.Decoder) {
 54060  	var h codecSelfer100
 54061  	z, r := codec1978.GenHelperDecoder(d)
 54062  	_, _, _ = h, z, r
 54063  	yym1 := z.DecBinary()
 54064  	_ = yym1
 54065  	if false {
 54066  	} else if z.HasExtensions() && z.DecExt(x) {
 54067  	} else {
 54068  		yyct2 := r.ContainerType()
 54069  		if yyct2 == codecSelferValueTypeMap100 {
 54070  			yyl2 := r.ReadMapStart()
 54071  			if yyl2 == 0 {
 54072  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 54073  			} else {
 54074  				x.codecDecodeSelfFromMap(yyl2, d)
 54075  			}
 54076  		} else if yyct2 == codecSelferValueTypeArray100 {
 54077  			yyl2 := r.ReadArrayStart()
 54078  			if yyl2 == 0 {
 54079  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54080  			} else {
 54081  				x.codecDecodeSelfFromArray(yyl2, d)
 54082  			}
 54083  		} else {
 54084  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 54085  		}
 54086  	}
 54087  }
 54088  
 54089  func (x *TaskGroup) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 54090  	var h codecSelfer100
 54091  	z, r := codec1978.GenHelperDecoder(d)
 54092  	_, _, _ = h, z, r
 54093  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 54094  	_ = yys3Slc
 54095  	var yyhl3 bool = l >= 0
 54096  	for yyj3 := 0; ; yyj3++ {
 54097  		if yyhl3 {
 54098  			if yyj3 >= l {
 54099  				break
 54100  			}
 54101  		} else {
 54102  			if r.CheckBreak() {
 54103  				break
 54104  			}
 54105  		}
 54106  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 54107  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 54108  		yys3 := string(yys3Slc)
 54109  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 54110  		switch yys3 {
 54111  		case "Name":
 54112  			if r.TryDecodeAsNil() {
 54113  				x.Name = ""
 54114  			} else {
 54115  				yyv4 := &x.Name
 54116  				yym5 := z.DecBinary()
 54117  				_ = yym5
 54118  				if false {
 54119  				} else {
 54120  					*((*string)(yyv4)) = r.DecodeString()
 54121  				}
 54122  			}
 54123  		case "Count":
 54124  			if r.TryDecodeAsNil() {
 54125  				x.Count = 0
 54126  			} else {
 54127  				yyv6 := &x.Count
 54128  				yym7 := z.DecBinary()
 54129  				_ = yym7
 54130  				if false {
 54131  				} else {
 54132  					*((*int)(yyv6)) = int(r.DecodeInt(codecSelferBitsize100))
 54133  				}
 54134  			}
 54135  		case "Update":
 54136  			if r.TryDecodeAsNil() {
 54137  				if x.Update != nil {
 54138  					x.Update = nil
 54139  				}
 54140  			} else {
 54141  				if x.Update == nil {
 54142  					x.Update = new(UpdateStrategy)
 54143  				}
 54144  				x.Update.CodecDecodeSelf(d)
 54145  			}
 54146  		case "Migrate":
 54147  			if r.TryDecodeAsNil() {
 54148  				if x.Migrate != nil {
 54149  					x.Migrate = nil
 54150  				}
 54151  			} else {
 54152  				if x.Migrate == nil {
 54153  					x.Migrate = new(MigrateStrategy)
 54154  				}
 54155  				x.Migrate.CodecDecodeSelf(d)
 54156  			}
 54157  		case "Constraints":
 54158  			if r.TryDecodeAsNil() {
 54159  				x.Constraints = nil
 54160  			} else {
 54161  				yyv10 := &x.Constraints
 54162  				yym11 := z.DecBinary()
 54163  				_ = yym11
 54164  				if false {
 54165  				} else {
 54166  					h.decSlicePtrtoConstraint((*[]*Constraint)(yyv10), d)
 54167  				}
 54168  			}
 54169  		case "RestartPolicy":
 54170  			if r.TryDecodeAsNil() {
 54171  				if x.RestartPolicy != nil {
 54172  					x.RestartPolicy = nil
 54173  				}
 54174  			} else {
 54175  				if x.RestartPolicy == nil {
 54176  					x.RestartPolicy = new(RestartPolicy)
 54177  				}
 54178  				x.RestartPolicy.CodecDecodeSelf(d)
 54179  			}
 54180  		case "Tasks":
 54181  			if r.TryDecodeAsNil() {
 54182  				x.Tasks = nil
 54183  			} else {
 54184  				yyv13 := &x.Tasks
 54185  				yym14 := z.DecBinary()
 54186  				_ = yym14
 54187  				if false {
 54188  				} else {
 54189  					h.decSlicePtrtoTask((*[]*Task)(yyv13), d)
 54190  				}
 54191  			}
 54192  		case "EphemeralDisk":
 54193  			if r.TryDecodeAsNil() {
 54194  				if x.EphemeralDisk != nil {
 54195  					x.EphemeralDisk = nil
 54196  				}
 54197  			} else {
 54198  				if x.EphemeralDisk == nil {
 54199  					x.EphemeralDisk = new(EphemeralDisk)
 54200  				}
 54201  				x.EphemeralDisk.CodecDecodeSelf(d)
 54202  			}
 54203  		case "Meta":
 54204  			if r.TryDecodeAsNil() {
 54205  				x.Meta = nil
 54206  			} else {
 54207  				yyv16 := &x.Meta
 54208  				yym17 := z.DecBinary()
 54209  				_ = yym17
 54210  				if false {
 54211  				} else {
 54212  					z.F.DecMapStringStringX(yyv16, false, d)
 54213  				}
 54214  			}
 54215  		case "ReschedulePolicy":
 54216  			if r.TryDecodeAsNil() {
 54217  				if x.ReschedulePolicy != nil {
 54218  					x.ReschedulePolicy = nil
 54219  				}
 54220  			} else {
 54221  				if x.ReschedulePolicy == nil {
 54222  					x.ReschedulePolicy = new(ReschedulePolicy)
 54223  				}
 54224  				x.ReschedulePolicy.CodecDecodeSelf(d)
 54225  			}
 54226  		default:
 54227  			z.DecStructFieldNotFound(-1, yys3)
 54228  		} // end switch yys3
 54229  	} // end for yyj3
 54230  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 54231  }
 54232  
 54233  func (x *TaskGroup) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 54234  	var h codecSelfer100
 54235  	z, r := codec1978.GenHelperDecoder(d)
 54236  	_, _, _ = h, z, r
 54237  	var yyj19 int
 54238  	var yyb19 bool
 54239  	var yyhl19 bool = l >= 0
 54240  	yyj19++
 54241  	if yyhl19 {
 54242  		yyb19 = yyj19 > l
 54243  	} else {
 54244  		yyb19 = r.CheckBreak()
 54245  	}
 54246  	if yyb19 {
 54247  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54248  		return
 54249  	}
 54250  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 54251  	if r.TryDecodeAsNil() {
 54252  		x.Name = ""
 54253  	} else {
 54254  		yyv20 := &x.Name
 54255  		yym21 := z.DecBinary()
 54256  		_ = yym21
 54257  		if false {
 54258  		} else {
 54259  			*((*string)(yyv20)) = r.DecodeString()
 54260  		}
 54261  	}
 54262  	yyj19++
 54263  	if yyhl19 {
 54264  		yyb19 = yyj19 > l
 54265  	} else {
 54266  		yyb19 = r.CheckBreak()
 54267  	}
 54268  	if yyb19 {
 54269  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54270  		return
 54271  	}
 54272  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 54273  	if r.TryDecodeAsNil() {
 54274  		x.Count = 0
 54275  	} else {
 54276  		yyv22 := &x.Count
 54277  		yym23 := z.DecBinary()
 54278  		_ = yym23
 54279  		if false {
 54280  		} else {
 54281  			*((*int)(yyv22)) = int(r.DecodeInt(codecSelferBitsize100))
 54282  		}
 54283  	}
 54284  	yyj19++
 54285  	if yyhl19 {
 54286  		yyb19 = yyj19 > l
 54287  	} else {
 54288  		yyb19 = r.CheckBreak()
 54289  	}
 54290  	if yyb19 {
 54291  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54292  		return
 54293  	}
 54294  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 54295  	if r.TryDecodeAsNil() {
 54296  		if x.Update != nil {
 54297  			x.Update = nil
 54298  		}
 54299  	} else {
 54300  		if x.Update == nil {
 54301  			x.Update = new(UpdateStrategy)
 54302  		}
 54303  		x.Update.CodecDecodeSelf(d)
 54304  	}
 54305  	yyj19++
 54306  	if yyhl19 {
 54307  		yyb19 = yyj19 > l
 54308  	} else {
 54309  		yyb19 = r.CheckBreak()
 54310  	}
 54311  	if yyb19 {
 54312  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54313  		return
 54314  	}
 54315  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 54316  	if r.TryDecodeAsNil() {
 54317  		if x.Migrate != nil {
 54318  			x.Migrate = nil
 54319  		}
 54320  	} else {
 54321  		if x.Migrate == nil {
 54322  			x.Migrate = new(MigrateStrategy)
 54323  		}
 54324  		x.Migrate.CodecDecodeSelf(d)
 54325  	}
 54326  	yyj19++
 54327  	if yyhl19 {
 54328  		yyb19 = yyj19 > l
 54329  	} else {
 54330  		yyb19 = r.CheckBreak()
 54331  	}
 54332  	if yyb19 {
 54333  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54334  		return
 54335  	}
 54336  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 54337  	if r.TryDecodeAsNil() {
 54338  		x.Constraints = nil
 54339  	} else {
 54340  		yyv26 := &x.Constraints
 54341  		yym27 := z.DecBinary()
 54342  		_ = yym27
 54343  		if false {
 54344  		} else {
 54345  			h.decSlicePtrtoConstraint((*[]*Constraint)(yyv26), d)
 54346  		}
 54347  	}
 54348  	yyj19++
 54349  	if yyhl19 {
 54350  		yyb19 = yyj19 > l
 54351  	} else {
 54352  		yyb19 = r.CheckBreak()
 54353  	}
 54354  	if yyb19 {
 54355  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54356  		return
 54357  	}
 54358  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 54359  	if r.TryDecodeAsNil() {
 54360  		if x.RestartPolicy != nil {
 54361  			x.RestartPolicy = nil
 54362  		}
 54363  	} else {
 54364  		if x.RestartPolicy == nil {
 54365  			x.RestartPolicy = new(RestartPolicy)
 54366  		}
 54367  		x.RestartPolicy.CodecDecodeSelf(d)
 54368  	}
 54369  	yyj19++
 54370  	if yyhl19 {
 54371  		yyb19 = yyj19 > l
 54372  	} else {
 54373  		yyb19 = r.CheckBreak()
 54374  	}
 54375  	if yyb19 {
 54376  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54377  		return
 54378  	}
 54379  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 54380  	if r.TryDecodeAsNil() {
 54381  		x.Tasks = nil
 54382  	} else {
 54383  		yyv29 := &x.Tasks
 54384  		yym30 := z.DecBinary()
 54385  		_ = yym30
 54386  		if false {
 54387  		} else {
 54388  			h.decSlicePtrtoTask((*[]*Task)(yyv29), d)
 54389  		}
 54390  	}
 54391  	yyj19++
 54392  	if yyhl19 {
 54393  		yyb19 = yyj19 > l
 54394  	} else {
 54395  		yyb19 = r.CheckBreak()
 54396  	}
 54397  	if yyb19 {
 54398  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54399  		return
 54400  	}
 54401  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 54402  	if r.TryDecodeAsNil() {
 54403  		if x.EphemeralDisk != nil {
 54404  			x.EphemeralDisk = nil
 54405  		}
 54406  	} else {
 54407  		if x.EphemeralDisk == nil {
 54408  			x.EphemeralDisk = new(EphemeralDisk)
 54409  		}
 54410  		x.EphemeralDisk.CodecDecodeSelf(d)
 54411  	}
 54412  	yyj19++
 54413  	if yyhl19 {
 54414  		yyb19 = yyj19 > l
 54415  	} else {
 54416  		yyb19 = r.CheckBreak()
 54417  	}
 54418  	if yyb19 {
 54419  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54420  		return
 54421  	}
 54422  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 54423  	if r.TryDecodeAsNil() {
 54424  		x.Meta = nil
 54425  	} else {
 54426  		yyv32 := &x.Meta
 54427  		yym33 := z.DecBinary()
 54428  		_ = yym33
 54429  		if false {
 54430  		} else {
 54431  			z.F.DecMapStringStringX(yyv32, false, d)
 54432  		}
 54433  	}
 54434  	yyj19++
 54435  	if yyhl19 {
 54436  		yyb19 = yyj19 > l
 54437  	} else {
 54438  		yyb19 = r.CheckBreak()
 54439  	}
 54440  	if yyb19 {
 54441  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54442  		return
 54443  	}
 54444  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 54445  	if r.TryDecodeAsNil() {
 54446  		if x.ReschedulePolicy != nil {
 54447  			x.ReschedulePolicy = nil
 54448  		}
 54449  	} else {
 54450  		if x.ReschedulePolicy == nil {
 54451  			x.ReschedulePolicy = new(ReschedulePolicy)
 54452  		}
 54453  		x.ReschedulePolicy.CodecDecodeSelf(d)
 54454  	}
 54455  	for {
 54456  		yyj19++
 54457  		if yyhl19 {
 54458  			yyb19 = yyj19 > l
 54459  		} else {
 54460  			yyb19 = r.CheckBreak()
 54461  		}
 54462  		if yyb19 {
 54463  			break
 54464  		}
 54465  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 54466  		z.DecStructFieldNotFound(yyj19-1, "")
 54467  	}
 54468  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54469  }
 54470  
 54471  func (x *CheckRestart) CodecEncodeSelf(e *codec1978.Encoder) {
 54472  	var h codecSelfer100
 54473  	z, r := codec1978.GenHelperEncoder(e)
 54474  	_, _, _ = h, z, r
 54475  	if x == nil {
 54476  		r.EncodeNil()
 54477  	} else {
 54478  		yym1 := z.EncBinary()
 54479  		_ = yym1
 54480  		if false {
 54481  		} else if z.HasExtensions() && z.EncExt(x) {
 54482  		} else {
 54483  			yysep2 := !z.EncBinary()
 54484  			yy2arr2 := z.EncBasicHandle().StructToArray
 54485  			var yyq2 [3]bool
 54486  			_, _, _ = yysep2, yyq2, yy2arr2
 54487  			const yyr2 bool = false
 54488  			var yynn2 int
 54489  			if yyr2 || yy2arr2 {
 54490  				r.EncodeArrayStart(3)
 54491  			} else {
 54492  				yynn2 = 3
 54493  				for _, b := range yyq2 {
 54494  					if b {
 54495  						yynn2++
 54496  					}
 54497  				}
 54498  				r.EncodeMapStart(yynn2)
 54499  				yynn2 = 0
 54500  			}
 54501  			if yyr2 || yy2arr2 {
 54502  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54503  				yym4 := z.EncBinary()
 54504  				_ = yym4
 54505  				if false {
 54506  				} else {
 54507  					r.EncodeInt(int64(x.Limit))
 54508  				}
 54509  			} else {
 54510  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54511  				r.EncodeString(codecSelferC_UTF8100, string("Limit"))
 54512  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54513  				yym5 := z.EncBinary()
 54514  				_ = yym5
 54515  				if false {
 54516  				} else {
 54517  					r.EncodeInt(int64(x.Limit))
 54518  				}
 54519  			}
 54520  			if yyr2 || yy2arr2 {
 54521  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54522  				yym7 := z.EncBinary()
 54523  				_ = yym7
 54524  				if false {
 54525  				} else if z.HasExtensions() && z.EncExt(x.Grace) {
 54526  				} else {
 54527  					r.EncodeInt(int64(x.Grace))
 54528  				}
 54529  			} else {
 54530  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54531  				r.EncodeString(codecSelferC_UTF8100, string("Grace"))
 54532  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54533  				yym8 := z.EncBinary()
 54534  				_ = yym8
 54535  				if false {
 54536  				} else if z.HasExtensions() && z.EncExt(x.Grace) {
 54537  				} else {
 54538  					r.EncodeInt(int64(x.Grace))
 54539  				}
 54540  			}
 54541  			if yyr2 || yy2arr2 {
 54542  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54543  				yym10 := z.EncBinary()
 54544  				_ = yym10
 54545  				if false {
 54546  				} else {
 54547  					r.EncodeBool(bool(x.IgnoreWarnings))
 54548  				}
 54549  			} else {
 54550  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54551  				r.EncodeString(codecSelferC_UTF8100, string("IgnoreWarnings"))
 54552  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54553  				yym11 := z.EncBinary()
 54554  				_ = yym11
 54555  				if false {
 54556  				} else {
 54557  					r.EncodeBool(bool(x.IgnoreWarnings))
 54558  				}
 54559  			}
 54560  			if yyr2 || yy2arr2 {
 54561  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 54562  			} else {
 54563  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 54564  			}
 54565  		}
 54566  	}
 54567  }
 54568  
 54569  func (x *CheckRestart) CodecDecodeSelf(d *codec1978.Decoder) {
 54570  	var h codecSelfer100
 54571  	z, r := codec1978.GenHelperDecoder(d)
 54572  	_, _, _ = h, z, r
 54573  	yym1 := z.DecBinary()
 54574  	_ = yym1
 54575  	if false {
 54576  	} else if z.HasExtensions() && z.DecExt(x) {
 54577  	} else {
 54578  		yyct2 := r.ContainerType()
 54579  		if yyct2 == codecSelferValueTypeMap100 {
 54580  			yyl2 := r.ReadMapStart()
 54581  			if yyl2 == 0 {
 54582  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 54583  			} else {
 54584  				x.codecDecodeSelfFromMap(yyl2, d)
 54585  			}
 54586  		} else if yyct2 == codecSelferValueTypeArray100 {
 54587  			yyl2 := r.ReadArrayStart()
 54588  			if yyl2 == 0 {
 54589  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54590  			} else {
 54591  				x.codecDecodeSelfFromArray(yyl2, d)
 54592  			}
 54593  		} else {
 54594  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 54595  		}
 54596  	}
 54597  }
 54598  
 54599  func (x *CheckRestart) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 54600  	var h codecSelfer100
 54601  	z, r := codec1978.GenHelperDecoder(d)
 54602  	_, _, _ = h, z, r
 54603  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 54604  	_ = yys3Slc
 54605  	var yyhl3 bool = l >= 0
 54606  	for yyj3 := 0; ; yyj3++ {
 54607  		if yyhl3 {
 54608  			if yyj3 >= l {
 54609  				break
 54610  			}
 54611  		} else {
 54612  			if r.CheckBreak() {
 54613  				break
 54614  			}
 54615  		}
 54616  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 54617  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 54618  		yys3 := string(yys3Slc)
 54619  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 54620  		switch yys3 {
 54621  		case "Limit":
 54622  			if r.TryDecodeAsNil() {
 54623  				x.Limit = 0
 54624  			} else {
 54625  				yyv4 := &x.Limit
 54626  				yym5 := z.DecBinary()
 54627  				_ = yym5
 54628  				if false {
 54629  				} else {
 54630  					*((*int)(yyv4)) = int(r.DecodeInt(codecSelferBitsize100))
 54631  				}
 54632  			}
 54633  		case "Grace":
 54634  			if r.TryDecodeAsNil() {
 54635  				x.Grace = 0
 54636  			} else {
 54637  				yyv6 := &x.Grace
 54638  				yym7 := z.DecBinary()
 54639  				_ = yym7
 54640  				if false {
 54641  				} else if z.HasExtensions() && z.DecExt(yyv6) {
 54642  				} else {
 54643  					*((*int64)(yyv6)) = int64(r.DecodeInt(64))
 54644  				}
 54645  			}
 54646  		case "IgnoreWarnings":
 54647  			if r.TryDecodeAsNil() {
 54648  				x.IgnoreWarnings = false
 54649  			} else {
 54650  				yyv8 := &x.IgnoreWarnings
 54651  				yym9 := z.DecBinary()
 54652  				_ = yym9
 54653  				if false {
 54654  				} else {
 54655  					*((*bool)(yyv8)) = r.DecodeBool()
 54656  				}
 54657  			}
 54658  		default:
 54659  			z.DecStructFieldNotFound(-1, yys3)
 54660  		} // end switch yys3
 54661  	} // end for yyj3
 54662  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 54663  }
 54664  
 54665  func (x *CheckRestart) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 54666  	var h codecSelfer100
 54667  	z, r := codec1978.GenHelperDecoder(d)
 54668  	_, _, _ = h, z, r
 54669  	var yyj10 int
 54670  	var yyb10 bool
 54671  	var yyhl10 bool = l >= 0
 54672  	yyj10++
 54673  	if yyhl10 {
 54674  		yyb10 = yyj10 > l
 54675  	} else {
 54676  		yyb10 = r.CheckBreak()
 54677  	}
 54678  	if yyb10 {
 54679  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54680  		return
 54681  	}
 54682  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 54683  	if r.TryDecodeAsNil() {
 54684  		x.Limit = 0
 54685  	} else {
 54686  		yyv11 := &x.Limit
 54687  		yym12 := z.DecBinary()
 54688  		_ = yym12
 54689  		if false {
 54690  		} else {
 54691  			*((*int)(yyv11)) = int(r.DecodeInt(codecSelferBitsize100))
 54692  		}
 54693  	}
 54694  	yyj10++
 54695  	if yyhl10 {
 54696  		yyb10 = yyj10 > l
 54697  	} else {
 54698  		yyb10 = r.CheckBreak()
 54699  	}
 54700  	if yyb10 {
 54701  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54702  		return
 54703  	}
 54704  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 54705  	if r.TryDecodeAsNil() {
 54706  		x.Grace = 0
 54707  	} else {
 54708  		yyv13 := &x.Grace
 54709  		yym14 := z.DecBinary()
 54710  		_ = yym14
 54711  		if false {
 54712  		} else if z.HasExtensions() && z.DecExt(yyv13) {
 54713  		} else {
 54714  			*((*int64)(yyv13)) = int64(r.DecodeInt(64))
 54715  		}
 54716  	}
 54717  	yyj10++
 54718  	if yyhl10 {
 54719  		yyb10 = yyj10 > l
 54720  	} else {
 54721  		yyb10 = r.CheckBreak()
 54722  	}
 54723  	if yyb10 {
 54724  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54725  		return
 54726  	}
 54727  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 54728  	if r.TryDecodeAsNil() {
 54729  		x.IgnoreWarnings = false
 54730  	} else {
 54731  		yyv15 := &x.IgnoreWarnings
 54732  		yym16 := z.DecBinary()
 54733  		_ = yym16
 54734  		if false {
 54735  		} else {
 54736  			*((*bool)(yyv15)) = r.DecodeBool()
 54737  		}
 54738  	}
 54739  	for {
 54740  		yyj10++
 54741  		if yyhl10 {
 54742  			yyb10 = yyj10 > l
 54743  		} else {
 54744  			yyb10 = r.CheckBreak()
 54745  		}
 54746  		if yyb10 {
 54747  			break
 54748  		}
 54749  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 54750  		z.DecStructFieldNotFound(yyj10-1, "")
 54751  	}
 54752  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 54753  }
 54754  
 54755  func (x *ServiceCheck) CodecEncodeSelf(e *codec1978.Encoder) {
 54756  	var h codecSelfer100
 54757  	z, r := codec1978.GenHelperEncoder(e)
 54758  	_, _, _ = h, z, r
 54759  	if x == nil {
 54760  		r.EncodeNil()
 54761  	} else {
 54762  		yym1 := z.EncBinary()
 54763  		_ = yym1
 54764  		if false {
 54765  		} else if z.HasExtensions() && z.EncExt(x) {
 54766  		} else {
 54767  			yysep2 := !z.EncBinary()
 54768  			yy2arr2 := z.EncBasicHandle().StructToArray
 54769  			var yyq2 [15]bool
 54770  			_, _, _ = yysep2, yyq2, yy2arr2
 54771  			const yyr2 bool = false
 54772  			var yynn2 int
 54773  			if yyr2 || yy2arr2 {
 54774  				r.EncodeArrayStart(15)
 54775  			} else {
 54776  				yynn2 = 15
 54777  				for _, b := range yyq2 {
 54778  					if b {
 54779  						yynn2++
 54780  					}
 54781  				}
 54782  				r.EncodeMapStart(yynn2)
 54783  				yynn2 = 0
 54784  			}
 54785  			if yyr2 || yy2arr2 {
 54786  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54787  				yym4 := z.EncBinary()
 54788  				_ = yym4
 54789  				if false {
 54790  				} else {
 54791  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 54792  				}
 54793  			} else {
 54794  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54795  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 54796  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54797  				yym5 := z.EncBinary()
 54798  				_ = yym5
 54799  				if false {
 54800  				} else {
 54801  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 54802  				}
 54803  			}
 54804  			if yyr2 || yy2arr2 {
 54805  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54806  				yym7 := z.EncBinary()
 54807  				_ = yym7
 54808  				if false {
 54809  				} else {
 54810  					r.EncodeString(codecSelferC_UTF8100, string(x.Type))
 54811  				}
 54812  			} else {
 54813  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54814  				r.EncodeString(codecSelferC_UTF8100, string("Type"))
 54815  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54816  				yym8 := z.EncBinary()
 54817  				_ = yym8
 54818  				if false {
 54819  				} else {
 54820  					r.EncodeString(codecSelferC_UTF8100, string(x.Type))
 54821  				}
 54822  			}
 54823  			if yyr2 || yy2arr2 {
 54824  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54825  				yym10 := z.EncBinary()
 54826  				_ = yym10
 54827  				if false {
 54828  				} else {
 54829  					r.EncodeString(codecSelferC_UTF8100, string(x.Command))
 54830  				}
 54831  			} else {
 54832  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54833  				r.EncodeString(codecSelferC_UTF8100, string("Command"))
 54834  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54835  				yym11 := z.EncBinary()
 54836  				_ = yym11
 54837  				if false {
 54838  				} else {
 54839  					r.EncodeString(codecSelferC_UTF8100, string(x.Command))
 54840  				}
 54841  			}
 54842  			if yyr2 || yy2arr2 {
 54843  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54844  				if x.Args == nil {
 54845  					r.EncodeNil()
 54846  				} else {
 54847  					yym13 := z.EncBinary()
 54848  					_ = yym13
 54849  					if false {
 54850  					} else {
 54851  						z.F.EncSliceStringV(x.Args, false, e)
 54852  					}
 54853  				}
 54854  			} else {
 54855  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54856  				r.EncodeString(codecSelferC_UTF8100, string("Args"))
 54857  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54858  				if x.Args == nil {
 54859  					r.EncodeNil()
 54860  				} else {
 54861  					yym14 := z.EncBinary()
 54862  					_ = yym14
 54863  					if false {
 54864  					} else {
 54865  						z.F.EncSliceStringV(x.Args, false, e)
 54866  					}
 54867  				}
 54868  			}
 54869  			if yyr2 || yy2arr2 {
 54870  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54871  				yym16 := z.EncBinary()
 54872  				_ = yym16
 54873  				if false {
 54874  				} else {
 54875  					r.EncodeString(codecSelferC_UTF8100, string(x.Path))
 54876  				}
 54877  			} else {
 54878  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54879  				r.EncodeString(codecSelferC_UTF8100, string("Path"))
 54880  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54881  				yym17 := z.EncBinary()
 54882  				_ = yym17
 54883  				if false {
 54884  				} else {
 54885  					r.EncodeString(codecSelferC_UTF8100, string(x.Path))
 54886  				}
 54887  			}
 54888  			if yyr2 || yy2arr2 {
 54889  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54890  				yym19 := z.EncBinary()
 54891  				_ = yym19
 54892  				if false {
 54893  				} else {
 54894  					r.EncodeString(codecSelferC_UTF8100, string(x.Protocol))
 54895  				}
 54896  			} else {
 54897  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54898  				r.EncodeString(codecSelferC_UTF8100, string("Protocol"))
 54899  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54900  				yym20 := z.EncBinary()
 54901  				_ = yym20
 54902  				if false {
 54903  				} else {
 54904  					r.EncodeString(codecSelferC_UTF8100, string(x.Protocol))
 54905  				}
 54906  			}
 54907  			if yyr2 || yy2arr2 {
 54908  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54909  				yym22 := z.EncBinary()
 54910  				_ = yym22
 54911  				if false {
 54912  				} else {
 54913  					r.EncodeString(codecSelferC_UTF8100, string(x.PortLabel))
 54914  				}
 54915  			} else {
 54916  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54917  				r.EncodeString(codecSelferC_UTF8100, string("PortLabel"))
 54918  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54919  				yym23 := z.EncBinary()
 54920  				_ = yym23
 54921  				if false {
 54922  				} else {
 54923  					r.EncodeString(codecSelferC_UTF8100, string(x.PortLabel))
 54924  				}
 54925  			}
 54926  			if yyr2 || yy2arr2 {
 54927  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54928  				yym25 := z.EncBinary()
 54929  				_ = yym25
 54930  				if false {
 54931  				} else {
 54932  					r.EncodeString(codecSelferC_UTF8100, string(x.AddressMode))
 54933  				}
 54934  			} else {
 54935  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54936  				r.EncodeString(codecSelferC_UTF8100, string("AddressMode"))
 54937  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54938  				yym26 := z.EncBinary()
 54939  				_ = yym26
 54940  				if false {
 54941  				} else {
 54942  					r.EncodeString(codecSelferC_UTF8100, string(x.AddressMode))
 54943  				}
 54944  			}
 54945  			if yyr2 || yy2arr2 {
 54946  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54947  				yym28 := z.EncBinary()
 54948  				_ = yym28
 54949  				if false {
 54950  				} else if z.HasExtensions() && z.EncExt(x.Interval) {
 54951  				} else {
 54952  					r.EncodeInt(int64(x.Interval))
 54953  				}
 54954  			} else {
 54955  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54956  				r.EncodeString(codecSelferC_UTF8100, string("Interval"))
 54957  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54958  				yym29 := z.EncBinary()
 54959  				_ = yym29
 54960  				if false {
 54961  				} else if z.HasExtensions() && z.EncExt(x.Interval) {
 54962  				} else {
 54963  					r.EncodeInt(int64(x.Interval))
 54964  				}
 54965  			}
 54966  			if yyr2 || yy2arr2 {
 54967  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54968  				yym31 := z.EncBinary()
 54969  				_ = yym31
 54970  				if false {
 54971  				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
 54972  				} else {
 54973  					r.EncodeInt(int64(x.Timeout))
 54974  				}
 54975  			} else {
 54976  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54977  				r.EncodeString(codecSelferC_UTF8100, string("Timeout"))
 54978  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54979  				yym32 := z.EncBinary()
 54980  				_ = yym32
 54981  				if false {
 54982  				} else if z.HasExtensions() && z.EncExt(x.Timeout) {
 54983  				} else {
 54984  					r.EncodeInt(int64(x.Timeout))
 54985  				}
 54986  			}
 54987  			if yyr2 || yy2arr2 {
 54988  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 54989  				yym34 := z.EncBinary()
 54990  				_ = yym34
 54991  				if false {
 54992  				} else {
 54993  					r.EncodeString(codecSelferC_UTF8100, string(x.InitialStatus))
 54994  				}
 54995  			} else {
 54996  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 54997  				r.EncodeString(codecSelferC_UTF8100, string("InitialStatus"))
 54998  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 54999  				yym35 := z.EncBinary()
 55000  				_ = yym35
 55001  				if false {
 55002  				} else {
 55003  					r.EncodeString(codecSelferC_UTF8100, string(x.InitialStatus))
 55004  				}
 55005  			}
 55006  			if yyr2 || yy2arr2 {
 55007  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 55008  				yym37 := z.EncBinary()
 55009  				_ = yym37
 55010  				if false {
 55011  				} else {
 55012  					r.EncodeBool(bool(x.TLSSkipVerify))
 55013  				}
 55014  			} else {
 55015  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 55016  				r.EncodeString(codecSelferC_UTF8100, string("TLSSkipVerify"))
 55017  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 55018  				yym38 := z.EncBinary()
 55019  				_ = yym38
 55020  				if false {
 55021  				} else {
 55022  					r.EncodeBool(bool(x.TLSSkipVerify))
 55023  				}
 55024  			}
 55025  			if yyr2 || yy2arr2 {
 55026  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 55027  				yym40 := z.EncBinary()
 55028  				_ = yym40
 55029  				if false {
 55030  				} else {
 55031  					r.EncodeString(codecSelferC_UTF8100, string(x.Method))
 55032  				}
 55033  			} else {
 55034  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 55035  				r.EncodeString(codecSelferC_UTF8100, string("Method"))
 55036  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 55037  				yym41 := z.EncBinary()
 55038  				_ = yym41
 55039  				if false {
 55040  				} else {
 55041  					r.EncodeString(codecSelferC_UTF8100, string(x.Method))
 55042  				}
 55043  			}
 55044  			if yyr2 || yy2arr2 {
 55045  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 55046  				if x.Header == nil {
 55047  					r.EncodeNil()
 55048  				} else {
 55049  					yym43 := z.EncBinary()
 55050  					_ = yym43
 55051  					if false {
 55052  					} else {
 55053  						h.encMapstringSlicestring((map[string][]string)(x.Header), e)
 55054  					}
 55055  				}
 55056  			} else {
 55057  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 55058  				r.EncodeString(codecSelferC_UTF8100, string("Header"))
 55059  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 55060  				if x.Header == nil {
 55061  					r.EncodeNil()
 55062  				} else {
 55063  					yym44 := z.EncBinary()
 55064  					_ = yym44
 55065  					if false {
 55066  					} else {
 55067  						h.encMapstringSlicestring((map[string][]string)(x.Header), e)
 55068  					}
 55069  				}
 55070  			}
 55071  			if yyr2 || yy2arr2 {
 55072  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 55073  				if x.CheckRestart == nil {
 55074  					r.EncodeNil()
 55075  				} else {
 55076  					x.CheckRestart.CodecEncodeSelf(e)
 55077  				}
 55078  			} else {
 55079  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 55080  				r.EncodeString(codecSelferC_UTF8100, string("CheckRestart"))
 55081  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 55082  				if x.CheckRestart == nil {
 55083  					r.EncodeNil()
 55084  				} else {
 55085  					x.CheckRestart.CodecEncodeSelf(e)
 55086  				}
 55087  			}
 55088  			if yyr2 || yy2arr2 {
 55089  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 55090  			} else {
 55091  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 55092  			}
 55093  		}
 55094  	}
 55095  }
 55096  
 55097  func (x *ServiceCheck) CodecDecodeSelf(d *codec1978.Decoder) {
 55098  	var h codecSelfer100
 55099  	z, r := codec1978.GenHelperDecoder(d)
 55100  	_, _, _ = h, z, r
 55101  	yym1 := z.DecBinary()
 55102  	_ = yym1
 55103  	if false {
 55104  	} else if z.HasExtensions() && z.DecExt(x) {
 55105  	} else {
 55106  		yyct2 := r.ContainerType()
 55107  		if yyct2 == codecSelferValueTypeMap100 {
 55108  			yyl2 := r.ReadMapStart()
 55109  			if yyl2 == 0 {
 55110  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 55111  			} else {
 55112  				x.codecDecodeSelfFromMap(yyl2, d)
 55113  			}
 55114  		} else if yyct2 == codecSelferValueTypeArray100 {
 55115  			yyl2 := r.ReadArrayStart()
 55116  			if yyl2 == 0 {
 55117  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55118  			} else {
 55119  				x.codecDecodeSelfFromArray(yyl2, d)
 55120  			}
 55121  		} else {
 55122  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 55123  		}
 55124  	}
 55125  }
 55126  
 55127  func (x *ServiceCheck) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 55128  	var h codecSelfer100
 55129  	z, r := codec1978.GenHelperDecoder(d)
 55130  	_, _, _ = h, z, r
 55131  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 55132  	_ = yys3Slc
 55133  	var yyhl3 bool = l >= 0
 55134  	for yyj3 := 0; ; yyj3++ {
 55135  		if yyhl3 {
 55136  			if yyj3 >= l {
 55137  				break
 55138  			}
 55139  		} else {
 55140  			if r.CheckBreak() {
 55141  				break
 55142  			}
 55143  		}
 55144  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 55145  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 55146  		yys3 := string(yys3Slc)
 55147  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 55148  		switch yys3 {
 55149  		case "Name":
 55150  			if r.TryDecodeAsNil() {
 55151  				x.Name = ""
 55152  			} else {
 55153  				yyv4 := &x.Name
 55154  				yym5 := z.DecBinary()
 55155  				_ = yym5
 55156  				if false {
 55157  				} else {
 55158  					*((*string)(yyv4)) = r.DecodeString()
 55159  				}
 55160  			}
 55161  		case "Type":
 55162  			if r.TryDecodeAsNil() {
 55163  				x.Type = ""
 55164  			} else {
 55165  				yyv6 := &x.Type
 55166  				yym7 := z.DecBinary()
 55167  				_ = yym7
 55168  				if false {
 55169  				} else {
 55170  					*((*string)(yyv6)) = r.DecodeString()
 55171  				}
 55172  			}
 55173  		case "Command":
 55174  			if r.TryDecodeAsNil() {
 55175  				x.Command = ""
 55176  			} else {
 55177  				yyv8 := &x.Command
 55178  				yym9 := z.DecBinary()
 55179  				_ = yym9
 55180  				if false {
 55181  				} else {
 55182  					*((*string)(yyv8)) = r.DecodeString()
 55183  				}
 55184  			}
 55185  		case "Args":
 55186  			if r.TryDecodeAsNil() {
 55187  				x.Args = nil
 55188  			} else {
 55189  				yyv10 := &x.Args
 55190  				yym11 := z.DecBinary()
 55191  				_ = yym11
 55192  				if false {
 55193  				} else {
 55194  					z.F.DecSliceStringX(yyv10, false, d)
 55195  				}
 55196  			}
 55197  		case "Path":
 55198  			if r.TryDecodeAsNil() {
 55199  				x.Path = ""
 55200  			} else {
 55201  				yyv12 := &x.Path
 55202  				yym13 := z.DecBinary()
 55203  				_ = yym13
 55204  				if false {
 55205  				} else {
 55206  					*((*string)(yyv12)) = r.DecodeString()
 55207  				}
 55208  			}
 55209  		case "Protocol":
 55210  			if r.TryDecodeAsNil() {
 55211  				x.Protocol = ""
 55212  			} else {
 55213  				yyv14 := &x.Protocol
 55214  				yym15 := z.DecBinary()
 55215  				_ = yym15
 55216  				if false {
 55217  				} else {
 55218  					*((*string)(yyv14)) = r.DecodeString()
 55219  				}
 55220  			}
 55221  		case "PortLabel":
 55222  			if r.TryDecodeAsNil() {
 55223  				x.PortLabel = ""
 55224  			} else {
 55225  				yyv16 := &x.PortLabel
 55226  				yym17 := z.DecBinary()
 55227  				_ = yym17
 55228  				if false {
 55229  				} else {
 55230  					*((*string)(yyv16)) = r.DecodeString()
 55231  				}
 55232  			}
 55233  		case "AddressMode":
 55234  			if r.TryDecodeAsNil() {
 55235  				x.AddressMode = ""
 55236  			} else {
 55237  				yyv18 := &x.AddressMode
 55238  				yym19 := z.DecBinary()
 55239  				_ = yym19
 55240  				if false {
 55241  				} else {
 55242  					*((*string)(yyv18)) = r.DecodeString()
 55243  				}
 55244  			}
 55245  		case "Interval":
 55246  			if r.TryDecodeAsNil() {
 55247  				x.Interval = 0
 55248  			} else {
 55249  				yyv20 := &x.Interval
 55250  				yym21 := z.DecBinary()
 55251  				_ = yym21
 55252  				if false {
 55253  				} else if z.HasExtensions() && z.DecExt(yyv20) {
 55254  				} else {
 55255  					*((*int64)(yyv20)) = int64(r.DecodeInt(64))
 55256  				}
 55257  			}
 55258  		case "Timeout":
 55259  			if r.TryDecodeAsNil() {
 55260  				x.Timeout = 0
 55261  			} else {
 55262  				yyv22 := &x.Timeout
 55263  				yym23 := z.DecBinary()
 55264  				_ = yym23
 55265  				if false {
 55266  				} else if z.HasExtensions() && z.DecExt(yyv22) {
 55267  				} else {
 55268  					*((*int64)(yyv22)) = int64(r.DecodeInt(64))
 55269  				}
 55270  			}
 55271  		case "InitialStatus":
 55272  			if r.TryDecodeAsNil() {
 55273  				x.InitialStatus = ""
 55274  			} else {
 55275  				yyv24 := &x.InitialStatus
 55276  				yym25 := z.DecBinary()
 55277  				_ = yym25
 55278  				if false {
 55279  				} else {
 55280  					*((*string)(yyv24)) = r.DecodeString()
 55281  				}
 55282  			}
 55283  		case "TLSSkipVerify":
 55284  			if r.TryDecodeAsNil() {
 55285  				x.TLSSkipVerify = false
 55286  			} else {
 55287  				yyv26 := &x.TLSSkipVerify
 55288  				yym27 := z.DecBinary()
 55289  				_ = yym27
 55290  				if false {
 55291  				} else {
 55292  					*((*bool)(yyv26)) = r.DecodeBool()
 55293  				}
 55294  			}
 55295  		case "Method":
 55296  			if r.TryDecodeAsNil() {
 55297  				x.Method = ""
 55298  			} else {
 55299  				yyv28 := &x.Method
 55300  				yym29 := z.DecBinary()
 55301  				_ = yym29
 55302  				if false {
 55303  				} else {
 55304  					*((*string)(yyv28)) = r.DecodeString()
 55305  				}
 55306  			}
 55307  		case "Header":
 55308  			if r.TryDecodeAsNil() {
 55309  				x.Header = nil
 55310  			} else {
 55311  				yyv30 := &x.Header
 55312  				yym31 := z.DecBinary()
 55313  				_ = yym31
 55314  				if false {
 55315  				} else {
 55316  					h.decMapstringSlicestring((*map[string][]string)(yyv30), d)
 55317  				}
 55318  			}
 55319  		case "CheckRestart":
 55320  			if r.TryDecodeAsNil() {
 55321  				if x.CheckRestart != nil {
 55322  					x.CheckRestart = nil
 55323  				}
 55324  			} else {
 55325  				if x.CheckRestart == nil {
 55326  					x.CheckRestart = new(CheckRestart)
 55327  				}
 55328  				x.CheckRestart.CodecDecodeSelf(d)
 55329  			}
 55330  		default:
 55331  			z.DecStructFieldNotFound(-1, yys3)
 55332  		} // end switch yys3
 55333  	} // end for yyj3
 55334  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 55335  }
 55336  
 55337  func (x *ServiceCheck) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 55338  	var h codecSelfer100
 55339  	z, r := codec1978.GenHelperDecoder(d)
 55340  	_, _, _ = h, z, r
 55341  	var yyj33 int
 55342  	var yyb33 bool
 55343  	var yyhl33 bool = l >= 0
 55344  	yyj33++
 55345  	if yyhl33 {
 55346  		yyb33 = yyj33 > l
 55347  	} else {
 55348  		yyb33 = r.CheckBreak()
 55349  	}
 55350  	if yyb33 {
 55351  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55352  		return
 55353  	}
 55354  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55355  	if r.TryDecodeAsNil() {
 55356  		x.Name = ""
 55357  	} else {
 55358  		yyv34 := &x.Name
 55359  		yym35 := z.DecBinary()
 55360  		_ = yym35
 55361  		if false {
 55362  		} else {
 55363  			*((*string)(yyv34)) = r.DecodeString()
 55364  		}
 55365  	}
 55366  	yyj33++
 55367  	if yyhl33 {
 55368  		yyb33 = yyj33 > l
 55369  	} else {
 55370  		yyb33 = r.CheckBreak()
 55371  	}
 55372  	if yyb33 {
 55373  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55374  		return
 55375  	}
 55376  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55377  	if r.TryDecodeAsNil() {
 55378  		x.Type = ""
 55379  	} else {
 55380  		yyv36 := &x.Type
 55381  		yym37 := z.DecBinary()
 55382  		_ = yym37
 55383  		if false {
 55384  		} else {
 55385  			*((*string)(yyv36)) = r.DecodeString()
 55386  		}
 55387  	}
 55388  	yyj33++
 55389  	if yyhl33 {
 55390  		yyb33 = yyj33 > l
 55391  	} else {
 55392  		yyb33 = r.CheckBreak()
 55393  	}
 55394  	if yyb33 {
 55395  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55396  		return
 55397  	}
 55398  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55399  	if r.TryDecodeAsNil() {
 55400  		x.Command = ""
 55401  	} else {
 55402  		yyv38 := &x.Command
 55403  		yym39 := z.DecBinary()
 55404  		_ = yym39
 55405  		if false {
 55406  		} else {
 55407  			*((*string)(yyv38)) = r.DecodeString()
 55408  		}
 55409  	}
 55410  	yyj33++
 55411  	if yyhl33 {
 55412  		yyb33 = yyj33 > l
 55413  	} else {
 55414  		yyb33 = r.CheckBreak()
 55415  	}
 55416  	if yyb33 {
 55417  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55418  		return
 55419  	}
 55420  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55421  	if r.TryDecodeAsNil() {
 55422  		x.Args = nil
 55423  	} else {
 55424  		yyv40 := &x.Args
 55425  		yym41 := z.DecBinary()
 55426  		_ = yym41
 55427  		if false {
 55428  		} else {
 55429  			z.F.DecSliceStringX(yyv40, false, d)
 55430  		}
 55431  	}
 55432  	yyj33++
 55433  	if yyhl33 {
 55434  		yyb33 = yyj33 > l
 55435  	} else {
 55436  		yyb33 = r.CheckBreak()
 55437  	}
 55438  	if yyb33 {
 55439  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55440  		return
 55441  	}
 55442  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55443  	if r.TryDecodeAsNil() {
 55444  		x.Path = ""
 55445  	} else {
 55446  		yyv42 := &x.Path
 55447  		yym43 := z.DecBinary()
 55448  		_ = yym43
 55449  		if false {
 55450  		} else {
 55451  			*((*string)(yyv42)) = r.DecodeString()
 55452  		}
 55453  	}
 55454  	yyj33++
 55455  	if yyhl33 {
 55456  		yyb33 = yyj33 > l
 55457  	} else {
 55458  		yyb33 = r.CheckBreak()
 55459  	}
 55460  	if yyb33 {
 55461  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55462  		return
 55463  	}
 55464  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55465  	if r.TryDecodeAsNil() {
 55466  		x.Protocol = ""
 55467  	} else {
 55468  		yyv44 := &x.Protocol
 55469  		yym45 := z.DecBinary()
 55470  		_ = yym45
 55471  		if false {
 55472  		} else {
 55473  			*((*string)(yyv44)) = r.DecodeString()
 55474  		}
 55475  	}
 55476  	yyj33++
 55477  	if yyhl33 {
 55478  		yyb33 = yyj33 > l
 55479  	} else {
 55480  		yyb33 = r.CheckBreak()
 55481  	}
 55482  	if yyb33 {
 55483  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55484  		return
 55485  	}
 55486  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55487  	if r.TryDecodeAsNil() {
 55488  		x.PortLabel = ""
 55489  	} else {
 55490  		yyv46 := &x.PortLabel
 55491  		yym47 := z.DecBinary()
 55492  		_ = yym47
 55493  		if false {
 55494  		} else {
 55495  			*((*string)(yyv46)) = r.DecodeString()
 55496  		}
 55497  	}
 55498  	yyj33++
 55499  	if yyhl33 {
 55500  		yyb33 = yyj33 > l
 55501  	} else {
 55502  		yyb33 = r.CheckBreak()
 55503  	}
 55504  	if yyb33 {
 55505  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55506  		return
 55507  	}
 55508  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55509  	if r.TryDecodeAsNil() {
 55510  		x.AddressMode = ""
 55511  	} else {
 55512  		yyv48 := &x.AddressMode
 55513  		yym49 := z.DecBinary()
 55514  		_ = yym49
 55515  		if false {
 55516  		} else {
 55517  			*((*string)(yyv48)) = r.DecodeString()
 55518  		}
 55519  	}
 55520  	yyj33++
 55521  	if yyhl33 {
 55522  		yyb33 = yyj33 > l
 55523  	} else {
 55524  		yyb33 = r.CheckBreak()
 55525  	}
 55526  	if yyb33 {
 55527  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55528  		return
 55529  	}
 55530  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55531  	if r.TryDecodeAsNil() {
 55532  		x.Interval = 0
 55533  	} else {
 55534  		yyv50 := &x.Interval
 55535  		yym51 := z.DecBinary()
 55536  		_ = yym51
 55537  		if false {
 55538  		} else if z.HasExtensions() && z.DecExt(yyv50) {
 55539  		} else {
 55540  			*((*int64)(yyv50)) = int64(r.DecodeInt(64))
 55541  		}
 55542  	}
 55543  	yyj33++
 55544  	if yyhl33 {
 55545  		yyb33 = yyj33 > l
 55546  	} else {
 55547  		yyb33 = r.CheckBreak()
 55548  	}
 55549  	if yyb33 {
 55550  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55551  		return
 55552  	}
 55553  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55554  	if r.TryDecodeAsNil() {
 55555  		x.Timeout = 0
 55556  	} else {
 55557  		yyv52 := &x.Timeout
 55558  		yym53 := z.DecBinary()
 55559  		_ = yym53
 55560  		if false {
 55561  		} else if z.HasExtensions() && z.DecExt(yyv52) {
 55562  		} else {
 55563  			*((*int64)(yyv52)) = int64(r.DecodeInt(64))
 55564  		}
 55565  	}
 55566  	yyj33++
 55567  	if yyhl33 {
 55568  		yyb33 = yyj33 > l
 55569  	} else {
 55570  		yyb33 = r.CheckBreak()
 55571  	}
 55572  	if yyb33 {
 55573  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55574  		return
 55575  	}
 55576  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55577  	if r.TryDecodeAsNil() {
 55578  		x.InitialStatus = ""
 55579  	} else {
 55580  		yyv54 := &x.InitialStatus
 55581  		yym55 := z.DecBinary()
 55582  		_ = yym55
 55583  		if false {
 55584  		} else {
 55585  			*((*string)(yyv54)) = r.DecodeString()
 55586  		}
 55587  	}
 55588  	yyj33++
 55589  	if yyhl33 {
 55590  		yyb33 = yyj33 > l
 55591  	} else {
 55592  		yyb33 = r.CheckBreak()
 55593  	}
 55594  	if yyb33 {
 55595  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55596  		return
 55597  	}
 55598  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55599  	if r.TryDecodeAsNil() {
 55600  		x.TLSSkipVerify = false
 55601  	} else {
 55602  		yyv56 := &x.TLSSkipVerify
 55603  		yym57 := z.DecBinary()
 55604  		_ = yym57
 55605  		if false {
 55606  		} else {
 55607  			*((*bool)(yyv56)) = r.DecodeBool()
 55608  		}
 55609  	}
 55610  	yyj33++
 55611  	if yyhl33 {
 55612  		yyb33 = yyj33 > l
 55613  	} else {
 55614  		yyb33 = r.CheckBreak()
 55615  	}
 55616  	if yyb33 {
 55617  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55618  		return
 55619  	}
 55620  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55621  	if r.TryDecodeAsNil() {
 55622  		x.Method = ""
 55623  	} else {
 55624  		yyv58 := &x.Method
 55625  		yym59 := z.DecBinary()
 55626  		_ = yym59
 55627  		if false {
 55628  		} else {
 55629  			*((*string)(yyv58)) = r.DecodeString()
 55630  		}
 55631  	}
 55632  	yyj33++
 55633  	if yyhl33 {
 55634  		yyb33 = yyj33 > l
 55635  	} else {
 55636  		yyb33 = r.CheckBreak()
 55637  	}
 55638  	if yyb33 {
 55639  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55640  		return
 55641  	}
 55642  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55643  	if r.TryDecodeAsNil() {
 55644  		x.Header = nil
 55645  	} else {
 55646  		yyv60 := &x.Header
 55647  		yym61 := z.DecBinary()
 55648  		_ = yym61
 55649  		if false {
 55650  		} else {
 55651  			h.decMapstringSlicestring((*map[string][]string)(yyv60), d)
 55652  		}
 55653  	}
 55654  	yyj33++
 55655  	if yyhl33 {
 55656  		yyb33 = yyj33 > l
 55657  	} else {
 55658  		yyb33 = r.CheckBreak()
 55659  	}
 55660  	if yyb33 {
 55661  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55662  		return
 55663  	}
 55664  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55665  	if r.TryDecodeAsNil() {
 55666  		if x.CheckRestart != nil {
 55667  			x.CheckRestart = nil
 55668  		}
 55669  	} else {
 55670  		if x.CheckRestart == nil {
 55671  			x.CheckRestart = new(CheckRestart)
 55672  		}
 55673  		x.CheckRestart.CodecDecodeSelf(d)
 55674  	}
 55675  	for {
 55676  		yyj33++
 55677  		if yyhl33 {
 55678  			yyb33 = yyj33 > l
 55679  		} else {
 55680  			yyb33 = r.CheckBreak()
 55681  		}
 55682  		if yyb33 {
 55683  			break
 55684  		}
 55685  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55686  		z.DecStructFieldNotFound(yyj33-1, "")
 55687  	}
 55688  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55689  }
 55690  
 55691  func (x *Service) CodecEncodeSelf(e *codec1978.Encoder) {
 55692  	var h codecSelfer100
 55693  	z, r := codec1978.GenHelperEncoder(e)
 55694  	_, _, _ = h, z, r
 55695  	if x == nil {
 55696  		r.EncodeNil()
 55697  	} else {
 55698  		yym1 := z.EncBinary()
 55699  		_ = yym1
 55700  		if false {
 55701  		} else if z.HasExtensions() && z.EncExt(x) {
 55702  		} else {
 55703  			yysep2 := !z.EncBinary()
 55704  			yy2arr2 := z.EncBasicHandle().StructToArray
 55705  			var yyq2 [5]bool
 55706  			_, _, _ = yysep2, yyq2, yy2arr2
 55707  			const yyr2 bool = false
 55708  			var yynn2 int
 55709  			if yyr2 || yy2arr2 {
 55710  				r.EncodeArrayStart(5)
 55711  			} else {
 55712  				yynn2 = 5
 55713  				for _, b := range yyq2 {
 55714  					if b {
 55715  						yynn2++
 55716  					}
 55717  				}
 55718  				r.EncodeMapStart(yynn2)
 55719  				yynn2 = 0
 55720  			}
 55721  			if yyr2 || yy2arr2 {
 55722  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 55723  				yym4 := z.EncBinary()
 55724  				_ = yym4
 55725  				if false {
 55726  				} else {
 55727  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 55728  				}
 55729  			} else {
 55730  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 55731  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 55732  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 55733  				yym5 := z.EncBinary()
 55734  				_ = yym5
 55735  				if false {
 55736  				} else {
 55737  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 55738  				}
 55739  			}
 55740  			if yyr2 || yy2arr2 {
 55741  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 55742  				yym7 := z.EncBinary()
 55743  				_ = yym7
 55744  				if false {
 55745  				} else {
 55746  					r.EncodeString(codecSelferC_UTF8100, string(x.PortLabel))
 55747  				}
 55748  			} else {
 55749  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 55750  				r.EncodeString(codecSelferC_UTF8100, string("PortLabel"))
 55751  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 55752  				yym8 := z.EncBinary()
 55753  				_ = yym8
 55754  				if false {
 55755  				} else {
 55756  					r.EncodeString(codecSelferC_UTF8100, string(x.PortLabel))
 55757  				}
 55758  			}
 55759  			if yyr2 || yy2arr2 {
 55760  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 55761  				yym10 := z.EncBinary()
 55762  				_ = yym10
 55763  				if false {
 55764  				} else {
 55765  					r.EncodeString(codecSelferC_UTF8100, string(x.AddressMode))
 55766  				}
 55767  			} else {
 55768  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 55769  				r.EncodeString(codecSelferC_UTF8100, string("AddressMode"))
 55770  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 55771  				yym11 := z.EncBinary()
 55772  				_ = yym11
 55773  				if false {
 55774  				} else {
 55775  					r.EncodeString(codecSelferC_UTF8100, string(x.AddressMode))
 55776  				}
 55777  			}
 55778  			if yyr2 || yy2arr2 {
 55779  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 55780  				if x.Tags == nil {
 55781  					r.EncodeNil()
 55782  				} else {
 55783  					yym13 := z.EncBinary()
 55784  					_ = yym13
 55785  					if false {
 55786  					} else {
 55787  						z.F.EncSliceStringV(x.Tags, false, e)
 55788  					}
 55789  				}
 55790  			} else {
 55791  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 55792  				r.EncodeString(codecSelferC_UTF8100, string("Tags"))
 55793  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 55794  				if x.Tags == nil {
 55795  					r.EncodeNil()
 55796  				} else {
 55797  					yym14 := z.EncBinary()
 55798  					_ = yym14
 55799  					if false {
 55800  					} else {
 55801  						z.F.EncSliceStringV(x.Tags, false, e)
 55802  					}
 55803  				}
 55804  			}
 55805  			if yyr2 || yy2arr2 {
 55806  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 55807  				if x.Checks == nil {
 55808  					r.EncodeNil()
 55809  				} else {
 55810  					yym16 := z.EncBinary()
 55811  					_ = yym16
 55812  					if false {
 55813  					} else {
 55814  						h.encSlicePtrtoServiceCheck(([]*ServiceCheck)(x.Checks), e)
 55815  					}
 55816  				}
 55817  			} else {
 55818  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 55819  				r.EncodeString(codecSelferC_UTF8100, string("Checks"))
 55820  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 55821  				if x.Checks == nil {
 55822  					r.EncodeNil()
 55823  				} else {
 55824  					yym17 := z.EncBinary()
 55825  					_ = yym17
 55826  					if false {
 55827  					} else {
 55828  						h.encSlicePtrtoServiceCheck(([]*ServiceCheck)(x.Checks), e)
 55829  					}
 55830  				}
 55831  			}
 55832  			if yyr2 || yy2arr2 {
 55833  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 55834  			} else {
 55835  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 55836  			}
 55837  		}
 55838  	}
 55839  }
 55840  
 55841  func (x *Service) CodecDecodeSelf(d *codec1978.Decoder) {
 55842  	var h codecSelfer100
 55843  	z, r := codec1978.GenHelperDecoder(d)
 55844  	_, _, _ = h, z, r
 55845  	yym1 := z.DecBinary()
 55846  	_ = yym1
 55847  	if false {
 55848  	} else if z.HasExtensions() && z.DecExt(x) {
 55849  	} else {
 55850  		yyct2 := r.ContainerType()
 55851  		if yyct2 == codecSelferValueTypeMap100 {
 55852  			yyl2 := r.ReadMapStart()
 55853  			if yyl2 == 0 {
 55854  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 55855  			} else {
 55856  				x.codecDecodeSelfFromMap(yyl2, d)
 55857  			}
 55858  		} else if yyct2 == codecSelferValueTypeArray100 {
 55859  			yyl2 := r.ReadArrayStart()
 55860  			if yyl2 == 0 {
 55861  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55862  			} else {
 55863  				x.codecDecodeSelfFromArray(yyl2, d)
 55864  			}
 55865  		} else {
 55866  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 55867  		}
 55868  	}
 55869  }
 55870  
 55871  func (x *Service) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 55872  	var h codecSelfer100
 55873  	z, r := codec1978.GenHelperDecoder(d)
 55874  	_, _, _ = h, z, r
 55875  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 55876  	_ = yys3Slc
 55877  	var yyhl3 bool = l >= 0
 55878  	for yyj3 := 0; ; yyj3++ {
 55879  		if yyhl3 {
 55880  			if yyj3 >= l {
 55881  				break
 55882  			}
 55883  		} else {
 55884  			if r.CheckBreak() {
 55885  				break
 55886  			}
 55887  		}
 55888  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 55889  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 55890  		yys3 := string(yys3Slc)
 55891  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 55892  		switch yys3 {
 55893  		case "Name":
 55894  			if r.TryDecodeAsNil() {
 55895  				x.Name = ""
 55896  			} else {
 55897  				yyv4 := &x.Name
 55898  				yym5 := z.DecBinary()
 55899  				_ = yym5
 55900  				if false {
 55901  				} else {
 55902  					*((*string)(yyv4)) = r.DecodeString()
 55903  				}
 55904  			}
 55905  		case "PortLabel":
 55906  			if r.TryDecodeAsNil() {
 55907  				x.PortLabel = ""
 55908  			} else {
 55909  				yyv6 := &x.PortLabel
 55910  				yym7 := z.DecBinary()
 55911  				_ = yym7
 55912  				if false {
 55913  				} else {
 55914  					*((*string)(yyv6)) = r.DecodeString()
 55915  				}
 55916  			}
 55917  		case "AddressMode":
 55918  			if r.TryDecodeAsNil() {
 55919  				x.AddressMode = ""
 55920  			} else {
 55921  				yyv8 := &x.AddressMode
 55922  				yym9 := z.DecBinary()
 55923  				_ = yym9
 55924  				if false {
 55925  				} else {
 55926  					*((*string)(yyv8)) = r.DecodeString()
 55927  				}
 55928  			}
 55929  		case "Tags":
 55930  			if r.TryDecodeAsNil() {
 55931  				x.Tags = nil
 55932  			} else {
 55933  				yyv10 := &x.Tags
 55934  				yym11 := z.DecBinary()
 55935  				_ = yym11
 55936  				if false {
 55937  				} else {
 55938  					z.F.DecSliceStringX(yyv10, false, d)
 55939  				}
 55940  			}
 55941  		case "Checks":
 55942  			if r.TryDecodeAsNil() {
 55943  				x.Checks = nil
 55944  			} else {
 55945  				yyv12 := &x.Checks
 55946  				yym13 := z.DecBinary()
 55947  				_ = yym13
 55948  				if false {
 55949  				} else {
 55950  					h.decSlicePtrtoServiceCheck((*[]*ServiceCheck)(yyv12), d)
 55951  				}
 55952  			}
 55953  		default:
 55954  			z.DecStructFieldNotFound(-1, yys3)
 55955  		} // end switch yys3
 55956  	} // end for yyj3
 55957  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 55958  }
 55959  
 55960  func (x *Service) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 55961  	var h codecSelfer100
 55962  	z, r := codec1978.GenHelperDecoder(d)
 55963  	_, _, _ = h, z, r
 55964  	var yyj14 int
 55965  	var yyb14 bool
 55966  	var yyhl14 bool = l >= 0
 55967  	yyj14++
 55968  	if yyhl14 {
 55969  		yyb14 = yyj14 > l
 55970  	} else {
 55971  		yyb14 = r.CheckBreak()
 55972  	}
 55973  	if yyb14 {
 55974  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55975  		return
 55976  	}
 55977  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 55978  	if r.TryDecodeAsNil() {
 55979  		x.Name = ""
 55980  	} else {
 55981  		yyv15 := &x.Name
 55982  		yym16 := z.DecBinary()
 55983  		_ = yym16
 55984  		if false {
 55985  		} else {
 55986  			*((*string)(yyv15)) = r.DecodeString()
 55987  		}
 55988  	}
 55989  	yyj14++
 55990  	if yyhl14 {
 55991  		yyb14 = yyj14 > l
 55992  	} else {
 55993  		yyb14 = r.CheckBreak()
 55994  	}
 55995  	if yyb14 {
 55996  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 55997  		return
 55998  	}
 55999  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 56000  	if r.TryDecodeAsNil() {
 56001  		x.PortLabel = ""
 56002  	} else {
 56003  		yyv17 := &x.PortLabel
 56004  		yym18 := z.DecBinary()
 56005  		_ = yym18
 56006  		if false {
 56007  		} else {
 56008  			*((*string)(yyv17)) = r.DecodeString()
 56009  		}
 56010  	}
 56011  	yyj14++
 56012  	if yyhl14 {
 56013  		yyb14 = yyj14 > l
 56014  	} else {
 56015  		yyb14 = r.CheckBreak()
 56016  	}
 56017  	if yyb14 {
 56018  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 56019  		return
 56020  	}
 56021  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 56022  	if r.TryDecodeAsNil() {
 56023  		x.AddressMode = ""
 56024  	} else {
 56025  		yyv19 := &x.AddressMode
 56026  		yym20 := z.DecBinary()
 56027  		_ = yym20
 56028  		if false {
 56029  		} else {
 56030  			*((*string)(yyv19)) = r.DecodeString()
 56031  		}
 56032  	}
 56033  	yyj14++
 56034  	if yyhl14 {
 56035  		yyb14 = yyj14 > l
 56036  	} else {
 56037  		yyb14 = r.CheckBreak()
 56038  	}
 56039  	if yyb14 {
 56040  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 56041  		return
 56042  	}
 56043  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 56044  	if r.TryDecodeAsNil() {
 56045  		x.Tags = nil
 56046  	} else {
 56047  		yyv21 := &x.Tags
 56048  		yym22 := z.DecBinary()
 56049  		_ = yym22
 56050  		if false {
 56051  		} else {
 56052  			z.F.DecSliceStringX(yyv21, false, d)
 56053  		}
 56054  	}
 56055  	yyj14++
 56056  	if yyhl14 {
 56057  		yyb14 = yyj14 > l
 56058  	} else {
 56059  		yyb14 = r.CheckBreak()
 56060  	}
 56061  	if yyb14 {
 56062  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 56063  		return
 56064  	}
 56065  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 56066  	if r.TryDecodeAsNil() {
 56067  		x.Checks = nil
 56068  	} else {
 56069  		yyv23 := &x.Checks
 56070  		yym24 := z.DecBinary()
 56071  		_ = yym24
 56072  		if false {
 56073  		} else {
 56074  			h.decSlicePtrtoServiceCheck((*[]*ServiceCheck)(yyv23), d)
 56075  		}
 56076  	}
 56077  	for {
 56078  		yyj14++
 56079  		if yyhl14 {
 56080  			yyb14 = yyj14 > l
 56081  		} else {
 56082  			yyb14 = r.CheckBreak()
 56083  		}
 56084  		if yyb14 {
 56085  			break
 56086  		}
 56087  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 56088  		z.DecStructFieldNotFound(yyj14-1, "")
 56089  	}
 56090  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 56091  }
 56092  
 56093  func (x *LogConfig) CodecEncodeSelf(e *codec1978.Encoder) {
 56094  	var h codecSelfer100
 56095  	z, r := codec1978.GenHelperEncoder(e)
 56096  	_, _, _ = h, z, r
 56097  	if x == nil {
 56098  		r.EncodeNil()
 56099  	} else {
 56100  		yym1 := z.EncBinary()
 56101  		_ = yym1
 56102  		if false {
 56103  		} else if z.HasExtensions() && z.EncExt(x) {
 56104  		} else {
 56105  			yysep2 := !z.EncBinary()
 56106  			yy2arr2 := z.EncBasicHandle().StructToArray
 56107  			var yyq2 [2]bool
 56108  			_, _, _ = yysep2, yyq2, yy2arr2
 56109  			const yyr2 bool = false
 56110  			var yynn2 int
 56111  			if yyr2 || yy2arr2 {
 56112  				r.EncodeArrayStart(2)
 56113  			} else {
 56114  				yynn2 = 2
 56115  				for _, b := range yyq2 {
 56116  					if b {
 56117  						yynn2++
 56118  					}
 56119  				}
 56120  				r.EncodeMapStart(yynn2)
 56121  				yynn2 = 0
 56122  			}
 56123  			if yyr2 || yy2arr2 {
 56124  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56125  				yym4 := z.EncBinary()
 56126  				_ = yym4
 56127  				if false {
 56128  				} else {
 56129  					r.EncodeInt(int64(x.MaxFiles))
 56130  				}
 56131  			} else {
 56132  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56133  				r.EncodeString(codecSelferC_UTF8100, string("MaxFiles"))
 56134  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56135  				yym5 := z.EncBinary()
 56136  				_ = yym5
 56137  				if false {
 56138  				} else {
 56139  					r.EncodeInt(int64(x.MaxFiles))
 56140  				}
 56141  			}
 56142  			if yyr2 || yy2arr2 {
 56143  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56144  				yym7 := z.EncBinary()
 56145  				_ = yym7
 56146  				if false {
 56147  				} else {
 56148  					r.EncodeInt(int64(x.MaxFileSizeMB))
 56149  				}
 56150  			} else {
 56151  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56152  				r.EncodeString(codecSelferC_UTF8100, string("MaxFileSizeMB"))
 56153  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56154  				yym8 := z.EncBinary()
 56155  				_ = yym8
 56156  				if false {
 56157  				} else {
 56158  					r.EncodeInt(int64(x.MaxFileSizeMB))
 56159  				}
 56160  			}
 56161  			if yyr2 || yy2arr2 {
 56162  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 56163  			} else {
 56164  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 56165  			}
 56166  		}
 56167  	}
 56168  }
 56169  
 56170  func (x *LogConfig) CodecDecodeSelf(d *codec1978.Decoder) {
 56171  	var h codecSelfer100
 56172  	z, r := codec1978.GenHelperDecoder(d)
 56173  	_, _, _ = h, z, r
 56174  	yym1 := z.DecBinary()
 56175  	_ = yym1
 56176  	if false {
 56177  	} else if z.HasExtensions() && z.DecExt(x) {
 56178  	} else {
 56179  		yyct2 := r.ContainerType()
 56180  		if yyct2 == codecSelferValueTypeMap100 {
 56181  			yyl2 := r.ReadMapStart()
 56182  			if yyl2 == 0 {
 56183  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 56184  			} else {
 56185  				x.codecDecodeSelfFromMap(yyl2, d)
 56186  			}
 56187  		} else if yyct2 == codecSelferValueTypeArray100 {
 56188  			yyl2 := r.ReadArrayStart()
 56189  			if yyl2 == 0 {
 56190  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 56191  			} else {
 56192  				x.codecDecodeSelfFromArray(yyl2, d)
 56193  			}
 56194  		} else {
 56195  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 56196  		}
 56197  	}
 56198  }
 56199  
 56200  func (x *LogConfig) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 56201  	var h codecSelfer100
 56202  	z, r := codec1978.GenHelperDecoder(d)
 56203  	_, _, _ = h, z, r
 56204  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 56205  	_ = yys3Slc
 56206  	var yyhl3 bool = l >= 0
 56207  	for yyj3 := 0; ; yyj3++ {
 56208  		if yyhl3 {
 56209  			if yyj3 >= l {
 56210  				break
 56211  			}
 56212  		} else {
 56213  			if r.CheckBreak() {
 56214  				break
 56215  			}
 56216  		}
 56217  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 56218  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 56219  		yys3 := string(yys3Slc)
 56220  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 56221  		switch yys3 {
 56222  		case "MaxFiles":
 56223  			if r.TryDecodeAsNil() {
 56224  				x.MaxFiles = 0
 56225  			} else {
 56226  				yyv4 := &x.MaxFiles
 56227  				yym5 := z.DecBinary()
 56228  				_ = yym5
 56229  				if false {
 56230  				} else {
 56231  					*((*int)(yyv4)) = int(r.DecodeInt(codecSelferBitsize100))
 56232  				}
 56233  			}
 56234  		case "MaxFileSizeMB":
 56235  			if r.TryDecodeAsNil() {
 56236  				x.MaxFileSizeMB = 0
 56237  			} else {
 56238  				yyv6 := &x.MaxFileSizeMB
 56239  				yym7 := z.DecBinary()
 56240  				_ = yym7
 56241  				if false {
 56242  				} else {
 56243  					*((*int)(yyv6)) = int(r.DecodeInt(codecSelferBitsize100))
 56244  				}
 56245  			}
 56246  		default:
 56247  			z.DecStructFieldNotFound(-1, yys3)
 56248  		} // end switch yys3
 56249  	} // end for yyj3
 56250  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 56251  }
 56252  
 56253  func (x *LogConfig) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 56254  	var h codecSelfer100
 56255  	z, r := codec1978.GenHelperDecoder(d)
 56256  	_, _, _ = h, z, r
 56257  	var yyj8 int
 56258  	var yyb8 bool
 56259  	var yyhl8 bool = l >= 0
 56260  	yyj8++
 56261  	if yyhl8 {
 56262  		yyb8 = yyj8 > l
 56263  	} else {
 56264  		yyb8 = r.CheckBreak()
 56265  	}
 56266  	if yyb8 {
 56267  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 56268  		return
 56269  	}
 56270  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 56271  	if r.TryDecodeAsNil() {
 56272  		x.MaxFiles = 0
 56273  	} else {
 56274  		yyv9 := &x.MaxFiles
 56275  		yym10 := z.DecBinary()
 56276  		_ = yym10
 56277  		if false {
 56278  		} else {
 56279  			*((*int)(yyv9)) = int(r.DecodeInt(codecSelferBitsize100))
 56280  		}
 56281  	}
 56282  	yyj8++
 56283  	if yyhl8 {
 56284  		yyb8 = yyj8 > l
 56285  	} else {
 56286  		yyb8 = r.CheckBreak()
 56287  	}
 56288  	if yyb8 {
 56289  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 56290  		return
 56291  	}
 56292  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 56293  	if r.TryDecodeAsNil() {
 56294  		x.MaxFileSizeMB = 0
 56295  	} else {
 56296  		yyv11 := &x.MaxFileSizeMB
 56297  		yym12 := z.DecBinary()
 56298  		_ = yym12
 56299  		if false {
 56300  		} else {
 56301  			*((*int)(yyv11)) = int(r.DecodeInt(codecSelferBitsize100))
 56302  		}
 56303  	}
 56304  	for {
 56305  		yyj8++
 56306  		if yyhl8 {
 56307  			yyb8 = yyj8 > l
 56308  		} else {
 56309  			yyb8 = r.CheckBreak()
 56310  		}
 56311  		if yyb8 {
 56312  			break
 56313  		}
 56314  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 56315  		z.DecStructFieldNotFound(yyj8-1, "")
 56316  	}
 56317  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 56318  }
 56319  
 56320  func (x *Task) CodecEncodeSelf(e *codec1978.Encoder) {
 56321  	var h codecSelfer100
 56322  	z, r := codec1978.GenHelperEncoder(e)
 56323  	_, _, _ = h, z, r
 56324  	if x == nil {
 56325  		r.EncodeNil()
 56326  	} else {
 56327  		yym1 := z.EncBinary()
 56328  		_ = yym1
 56329  		if false {
 56330  		} else if z.HasExtensions() && z.EncExt(x) {
 56331  		} else {
 56332  			yysep2 := !z.EncBinary()
 56333  			yy2arr2 := z.EncBasicHandle().StructToArray
 56334  			var yyq2 [18]bool
 56335  			_, _, _ = yysep2, yyq2, yy2arr2
 56336  			const yyr2 bool = false
 56337  			var yynn2 int
 56338  			if yyr2 || yy2arr2 {
 56339  				r.EncodeArrayStart(18)
 56340  			} else {
 56341  				yynn2 = 18
 56342  				for _, b := range yyq2 {
 56343  					if b {
 56344  						yynn2++
 56345  					}
 56346  				}
 56347  				r.EncodeMapStart(yynn2)
 56348  				yynn2 = 0
 56349  			}
 56350  			if yyr2 || yy2arr2 {
 56351  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56352  				yym4 := z.EncBinary()
 56353  				_ = yym4
 56354  				if false {
 56355  				} else {
 56356  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 56357  				}
 56358  			} else {
 56359  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56360  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 56361  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56362  				yym5 := z.EncBinary()
 56363  				_ = yym5
 56364  				if false {
 56365  				} else {
 56366  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 56367  				}
 56368  			}
 56369  			if yyr2 || yy2arr2 {
 56370  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56371  				yym7 := z.EncBinary()
 56372  				_ = yym7
 56373  				if false {
 56374  				} else {
 56375  					r.EncodeString(codecSelferC_UTF8100, string(x.Driver))
 56376  				}
 56377  			} else {
 56378  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56379  				r.EncodeString(codecSelferC_UTF8100, string("Driver"))
 56380  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56381  				yym8 := z.EncBinary()
 56382  				_ = yym8
 56383  				if false {
 56384  				} else {
 56385  					r.EncodeString(codecSelferC_UTF8100, string(x.Driver))
 56386  				}
 56387  			}
 56388  			if yyr2 || yy2arr2 {
 56389  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56390  				yym10 := z.EncBinary()
 56391  				_ = yym10
 56392  				if false {
 56393  				} else {
 56394  					r.EncodeString(codecSelferC_UTF8100, string(x.User))
 56395  				}
 56396  			} else {
 56397  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56398  				r.EncodeString(codecSelferC_UTF8100, string("User"))
 56399  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56400  				yym11 := z.EncBinary()
 56401  				_ = yym11
 56402  				if false {
 56403  				} else {
 56404  					r.EncodeString(codecSelferC_UTF8100, string(x.User))
 56405  				}
 56406  			}
 56407  			if yyr2 || yy2arr2 {
 56408  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56409  				if x.Config == nil {
 56410  					r.EncodeNil()
 56411  				} else {
 56412  					yym13 := z.EncBinary()
 56413  					_ = yym13
 56414  					if false {
 56415  					} else {
 56416  						z.F.EncMapStringIntfV(x.Config, false, e)
 56417  					}
 56418  				}
 56419  			} else {
 56420  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56421  				r.EncodeString(codecSelferC_UTF8100, string("Config"))
 56422  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56423  				if x.Config == nil {
 56424  					r.EncodeNil()
 56425  				} else {
 56426  					yym14 := z.EncBinary()
 56427  					_ = yym14
 56428  					if false {
 56429  					} else {
 56430  						z.F.EncMapStringIntfV(x.Config, false, e)
 56431  					}
 56432  				}
 56433  			}
 56434  			if yyr2 || yy2arr2 {
 56435  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56436  				if x.Env == nil {
 56437  					r.EncodeNil()
 56438  				} else {
 56439  					yym16 := z.EncBinary()
 56440  					_ = yym16
 56441  					if false {
 56442  					} else {
 56443  						z.F.EncMapStringStringV(x.Env, false, e)
 56444  					}
 56445  				}
 56446  			} else {
 56447  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56448  				r.EncodeString(codecSelferC_UTF8100, string("Env"))
 56449  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56450  				if x.Env == nil {
 56451  					r.EncodeNil()
 56452  				} else {
 56453  					yym17 := z.EncBinary()
 56454  					_ = yym17
 56455  					if false {
 56456  					} else {
 56457  						z.F.EncMapStringStringV(x.Env, false, e)
 56458  					}
 56459  				}
 56460  			}
 56461  			if yyr2 || yy2arr2 {
 56462  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56463  				if x.Services == nil {
 56464  					r.EncodeNil()
 56465  				} else {
 56466  					yym19 := z.EncBinary()
 56467  					_ = yym19
 56468  					if false {
 56469  					} else {
 56470  						h.encSlicePtrtoService(([]*Service)(x.Services), e)
 56471  					}
 56472  				}
 56473  			} else {
 56474  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56475  				r.EncodeString(codecSelferC_UTF8100, string("Services"))
 56476  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56477  				if x.Services == nil {
 56478  					r.EncodeNil()
 56479  				} else {
 56480  					yym20 := z.EncBinary()
 56481  					_ = yym20
 56482  					if false {
 56483  					} else {
 56484  						h.encSlicePtrtoService(([]*Service)(x.Services), e)
 56485  					}
 56486  				}
 56487  			}
 56488  			if yyr2 || yy2arr2 {
 56489  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56490  				if x.Vault == nil {
 56491  					r.EncodeNil()
 56492  				} else {
 56493  					x.Vault.CodecEncodeSelf(e)
 56494  				}
 56495  			} else {
 56496  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56497  				r.EncodeString(codecSelferC_UTF8100, string("Vault"))
 56498  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56499  				if x.Vault == nil {
 56500  					r.EncodeNil()
 56501  				} else {
 56502  					x.Vault.CodecEncodeSelf(e)
 56503  				}
 56504  			}
 56505  			if yyr2 || yy2arr2 {
 56506  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56507  				if x.Templates == nil {
 56508  					r.EncodeNil()
 56509  				} else {
 56510  					yym25 := z.EncBinary()
 56511  					_ = yym25
 56512  					if false {
 56513  					} else {
 56514  						h.encSlicePtrtoTemplate(([]*Template)(x.Templates), e)
 56515  					}
 56516  				}
 56517  			} else {
 56518  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56519  				r.EncodeString(codecSelferC_UTF8100, string("Templates"))
 56520  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56521  				if x.Templates == nil {
 56522  					r.EncodeNil()
 56523  				} else {
 56524  					yym26 := z.EncBinary()
 56525  					_ = yym26
 56526  					if false {
 56527  					} else {
 56528  						h.encSlicePtrtoTemplate(([]*Template)(x.Templates), e)
 56529  					}
 56530  				}
 56531  			}
 56532  			if yyr2 || yy2arr2 {
 56533  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56534  				if x.Constraints == nil {
 56535  					r.EncodeNil()
 56536  				} else {
 56537  					yym28 := z.EncBinary()
 56538  					_ = yym28
 56539  					if false {
 56540  					} else {
 56541  						h.encSlicePtrtoConstraint(([]*Constraint)(x.Constraints), e)
 56542  					}
 56543  				}
 56544  			} else {
 56545  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56546  				r.EncodeString(codecSelferC_UTF8100, string("Constraints"))
 56547  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56548  				if x.Constraints == nil {
 56549  					r.EncodeNil()
 56550  				} else {
 56551  					yym29 := z.EncBinary()
 56552  					_ = yym29
 56553  					if false {
 56554  					} else {
 56555  						h.encSlicePtrtoConstraint(([]*Constraint)(x.Constraints), e)
 56556  					}
 56557  				}
 56558  			}
 56559  			if yyr2 || yy2arr2 {
 56560  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56561  				if x.Resources == nil {
 56562  					r.EncodeNil()
 56563  				} else {
 56564  					x.Resources.CodecEncodeSelf(e)
 56565  				}
 56566  			} else {
 56567  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56568  				r.EncodeString(codecSelferC_UTF8100, string("Resources"))
 56569  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56570  				if x.Resources == nil {
 56571  					r.EncodeNil()
 56572  				} else {
 56573  					x.Resources.CodecEncodeSelf(e)
 56574  				}
 56575  			}
 56576  			if yyr2 || yy2arr2 {
 56577  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56578  				if x.DispatchPayload == nil {
 56579  					r.EncodeNil()
 56580  				} else {
 56581  					x.DispatchPayload.CodecEncodeSelf(e)
 56582  				}
 56583  			} else {
 56584  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56585  				r.EncodeString(codecSelferC_UTF8100, string("DispatchPayload"))
 56586  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56587  				if x.DispatchPayload == nil {
 56588  					r.EncodeNil()
 56589  				} else {
 56590  					x.DispatchPayload.CodecEncodeSelf(e)
 56591  				}
 56592  			}
 56593  			if yyr2 || yy2arr2 {
 56594  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56595  				if x.Meta == nil {
 56596  					r.EncodeNil()
 56597  				} else {
 56598  					yym37 := z.EncBinary()
 56599  					_ = yym37
 56600  					if false {
 56601  					} else {
 56602  						z.F.EncMapStringStringV(x.Meta, false, e)
 56603  					}
 56604  				}
 56605  			} else {
 56606  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56607  				r.EncodeString(codecSelferC_UTF8100, string("Meta"))
 56608  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56609  				if x.Meta == nil {
 56610  					r.EncodeNil()
 56611  				} else {
 56612  					yym38 := z.EncBinary()
 56613  					_ = yym38
 56614  					if false {
 56615  					} else {
 56616  						z.F.EncMapStringStringV(x.Meta, false, e)
 56617  					}
 56618  				}
 56619  			}
 56620  			if yyr2 || yy2arr2 {
 56621  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56622  				yym40 := z.EncBinary()
 56623  				_ = yym40
 56624  				if false {
 56625  				} else if z.HasExtensions() && z.EncExt(x.KillTimeout) {
 56626  				} else {
 56627  					r.EncodeInt(int64(x.KillTimeout))
 56628  				}
 56629  			} else {
 56630  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56631  				r.EncodeString(codecSelferC_UTF8100, string("KillTimeout"))
 56632  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56633  				yym41 := z.EncBinary()
 56634  				_ = yym41
 56635  				if false {
 56636  				} else if z.HasExtensions() && z.EncExt(x.KillTimeout) {
 56637  				} else {
 56638  					r.EncodeInt(int64(x.KillTimeout))
 56639  				}
 56640  			}
 56641  			if yyr2 || yy2arr2 {
 56642  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56643  				if x.LogConfig == nil {
 56644  					r.EncodeNil()
 56645  				} else {
 56646  					x.LogConfig.CodecEncodeSelf(e)
 56647  				}
 56648  			} else {
 56649  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56650  				r.EncodeString(codecSelferC_UTF8100, string("LogConfig"))
 56651  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56652  				if x.LogConfig == nil {
 56653  					r.EncodeNil()
 56654  				} else {
 56655  					x.LogConfig.CodecEncodeSelf(e)
 56656  				}
 56657  			}
 56658  			if yyr2 || yy2arr2 {
 56659  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56660  				if x.Artifacts == nil {
 56661  					r.EncodeNil()
 56662  				} else {
 56663  					yym46 := z.EncBinary()
 56664  					_ = yym46
 56665  					if false {
 56666  					} else {
 56667  						h.encSlicePtrtoTaskArtifact(([]*TaskArtifact)(x.Artifacts), e)
 56668  					}
 56669  				}
 56670  			} else {
 56671  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56672  				r.EncodeString(codecSelferC_UTF8100, string("Artifacts"))
 56673  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56674  				if x.Artifacts == nil {
 56675  					r.EncodeNil()
 56676  				} else {
 56677  					yym47 := z.EncBinary()
 56678  					_ = yym47
 56679  					if false {
 56680  					} else {
 56681  						h.encSlicePtrtoTaskArtifact(([]*TaskArtifact)(x.Artifacts), e)
 56682  					}
 56683  				}
 56684  			}
 56685  			if yyr2 || yy2arr2 {
 56686  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56687  				yym49 := z.EncBinary()
 56688  				_ = yym49
 56689  				if false {
 56690  				} else {
 56691  					r.EncodeBool(bool(x.Leader))
 56692  				}
 56693  			} else {
 56694  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56695  				r.EncodeString(codecSelferC_UTF8100, string("Leader"))
 56696  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56697  				yym50 := z.EncBinary()
 56698  				_ = yym50
 56699  				if false {
 56700  				} else {
 56701  					r.EncodeBool(bool(x.Leader))
 56702  				}
 56703  			}
 56704  			if yyr2 || yy2arr2 {
 56705  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56706  				yym52 := z.EncBinary()
 56707  				_ = yym52
 56708  				if false {
 56709  				} else if z.HasExtensions() && z.EncExt(x.ShutdownDelay) {
 56710  				} else {
 56711  					r.EncodeInt(int64(x.ShutdownDelay))
 56712  				}
 56713  			} else {
 56714  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56715  				r.EncodeString(codecSelferC_UTF8100, string("ShutdownDelay"))
 56716  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56717  				yym53 := z.EncBinary()
 56718  				_ = yym53
 56719  				if false {
 56720  				} else if z.HasExtensions() && z.EncExt(x.ShutdownDelay) {
 56721  				} else {
 56722  					r.EncodeInt(int64(x.ShutdownDelay))
 56723  				}
 56724  			}
 56725  			if yyr2 || yy2arr2 {
 56726  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 56727  				yym55 := z.EncBinary()
 56728  				_ = yym55
 56729  				if false {
 56730  				} else {
 56731  					r.EncodeString(codecSelferC_UTF8100, string(x.KillSignal))
 56732  				}
 56733  			} else {
 56734  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 56735  				r.EncodeString(codecSelferC_UTF8100, string("KillSignal"))
 56736  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 56737  				yym56 := z.EncBinary()
 56738  				_ = yym56
 56739  				if false {
 56740  				} else {
 56741  					r.EncodeString(codecSelferC_UTF8100, string(x.KillSignal))
 56742  				}
 56743  			}
 56744  			if yyr2 || yy2arr2 {
 56745  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 56746  			} else {
 56747  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 56748  			}
 56749  		}
 56750  	}
 56751  }
 56752  
 56753  func (x *Task) CodecDecodeSelf(d *codec1978.Decoder) {
 56754  	var h codecSelfer100
 56755  	z, r := codec1978.GenHelperDecoder(d)
 56756  	_, _, _ = h, z, r
 56757  	yym1 := z.DecBinary()
 56758  	_ = yym1
 56759  	if false {
 56760  	} else if z.HasExtensions() && z.DecExt(x) {
 56761  	} else {
 56762  		yyct2 := r.ContainerType()
 56763  		if yyct2 == codecSelferValueTypeMap100 {
 56764  			yyl2 := r.ReadMapStart()
 56765  			if yyl2 == 0 {
 56766  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 56767  			} else {
 56768  				x.codecDecodeSelfFromMap(yyl2, d)
 56769  			}
 56770  		} else if yyct2 == codecSelferValueTypeArray100 {
 56771  			yyl2 := r.ReadArrayStart()
 56772  			if yyl2 == 0 {
 56773  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 56774  			} else {
 56775  				x.codecDecodeSelfFromArray(yyl2, d)
 56776  			}
 56777  		} else {
 56778  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 56779  		}
 56780  	}
 56781  }
 56782  
 56783  func (x *Task) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 56784  	var h codecSelfer100
 56785  	z, r := codec1978.GenHelperDecoder(d)
 56786  	_, _, _ = h, z, r
 56787  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 56788  	_ = yys3Slc
 56789  	var yyhl3 bool = l >= 0
 56790  	for yyj3 := 0; ; yyj3++ {
 56791  		if yyhl3 {
 56792  			if yyj3 >= l {
 56793  				break
 56794  			}
 56795  		} else {
 56796  			if r.CheckBreak() {
 56797  				break
 56798  			}
 56799  		}
 56800  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 56801  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 56802  		yys3 := string(yys3Slc)
 56803  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 56804  		switch yys3 {
 56805  		case "Name":
 56806  			if r.TryDecodeAsNil() {
 56807  				x.Name = ""
 56808  			} else {
 56809  				yyv4 := &x.Name
 56810  				yym5 := z.DecBinary()
 56811  				_ = yym5
 56812  				if false {
 56813  				} else {
 56814  					*((*string)(yyv4)) = r.DecodeString()
 56815  				}
 56816  			}
 56817  		case "Driver":
 56818  			if r.TryDecodeAsNil() {
 56819  				x.Driver = ""
 56820  			} else {
 56821  				yyv6 := &x.Driver
 56822  				yym7 := z.DecBinary()
 56823  				_ = yym7
 56824  				if false {
 56825  				} else {
 56826  					*((*string)(yyv6)) = r.DecodeString()
 56827  				}
 56828  			}
 56829  		case "User":
 56830  			if r.TryDecodeAsNil() {
 56831  				x.User = ""
 56832  			} else {
 56833  				yyv8 := &x.User
 56834  				yym9 := z.DecBinary()
 56835  				_ = yym9
 56836  				if false {
 56837  				} else {
 56838  					*((*string)(yyv8)) = r.DecodeString()
 56839  				}
 56840  			}
 56841  		case "Config":
 56842  			if r.TryDecodeAsNil() {
 56843  				x.Config = nil
 56844  			} else {
 56845  				yyv10 := &x.Config
 56846  				yym11 := z.DecBinary()
 56847  				_ = yym11
 56848  				if false {
 56849  				} else {
 56850  					z.F.DecMapStringIntfX(yyv10, false, d)
 56851  				}
 56852  			}
 56853  		case "Env":
 56854  			if r.TryDecodeAsNil() {
 56855  				x.Env = nil
 56856  			} else {
 56857  				yyv12 := &x.Env
 56858  				yym13 := z.DecBinary()
 56859  				_ = yym13
 56860  				if false {
 56861  				} else {
 56862  					z.F.DecMapStringStringX(yyv12, false, d)
 56863  				}
 56864  			}
 56865  		case "Services":
 56866  			if r.TryDecodeAsNil() {
 56867  				x.Services = nil
 56868  			} else {
 56869  				yyv14 := &x.Services
 56870  				yym15 := z.DecBinary()
 56871  				_ = yym15
 56872  				if false {
 56873  				} else {
 56874  					h.decSlicePtrtoService((*[]*Service)(yyv14), d)
 56875  				}
 56876  			}
 56877  		case "Vault":
 56878  			if r.TryDecodeAsNil() {
 56879  				if x.Vault != nil {
 56880  					x.Vault = nil
 56881  				}
 56882  			} else {
 56883  				if x.Vault == nil {
 56884  					x.Vault = new(Vault)
 56885  				}
 56886  				x.Vault.CodecDecodeSelf(d)
 56887  			}
 56888  		case "Templates":
 56889  			if r.TryDecodeAsNil() {
 56890  				x.Templates = nil
 56891  			} else {
 56892  				yyv17 := &x.Templates
 56893  				yym18 := z.DecBinary()
 56894  				_ = yym18
 56895  				if false {
 56896  				} else {
 56897  					h.decSlicePtrtoTemplate((*[]*Template)(yyv17), d)
 56898  				}
 56899  			}
 56900  		case "Constraints":
 56901  			if r.TryDecodeAsNil() {
 56902  				x.Constraints = nil
 56903  			} else {
 56904  				yyv19 := &x.Constraints
 56905  				yym20 := z.DecBinary()
 56906  				_ = yym20
 56907  				if false {
 56908  				} else {
 56909  					h.decSlicePtrtoConstraint((*[]*Constraint)(yyv19), d)
 56910  				}
 56911  			}
 56912  		case "Resources":
 56913  			if r.TryDecodeAsNil() {
 56914  				if x.Resources != nil {
 56915  					x.Resources = nil
 56916  				}
 56917  			} else {
 56918  				if x.Resources == nil {
 56919  					x.Resources = new(Resources)
 56920  				}
 56921  				x.Resources.CodecDecodeSelf(d)
 56922  			}
 56923  		case "DispatchPayload":
 56924  			if r.TryDecodeAsNil() {
 56925  				if x.DispatchPayload != nil {
 56926  					x.DispatchPayload = nil
 56927  				}
 56928  			} else {
 56929  				if x.DispatchPayload == nil {
 56930  					x.DispatchPayload = new(DispatchPayloadConfig)
 56931  				}
 56932  				x.DispatchPayload.CodecDecodeSelf(d)
 56933  			}
 56934  		case "Meta":
 56935  			if r.TryDecodeAsNil() {
 56936  				x.Meta = nil
 56937  			} else {
 56938  				yyv23 := &x.Meta
 56939  				yym24 := z.DecBinary()
 56940  				_ = yym24
 56941  				if false {
 56942  				} else {
 56943  					z.F.DecMapStringStringX(yyv23, false, d)
 56944  				}
 56945  			}
 56946  		case "KillTimeout":
 56947  			if r.TryDecodeAsNil() {
 56948  				x.KillTimeout = 0
 56949  			} else {
 56950  				yyv25 := &x.KillTimeout
 56951  				yym26 := z.DecBinary()
 56952  				_ = yym26
 56953  				if false {
 56954  				} else if z.HasExtensions() && z.DecExt(yyv25) {
 56955  				} else {
 56956  					*((*int64)(yyv25)) = int64(r.DecodeInt(64))
 56957  				}
 56958  			}
 56959  		case "LogConfig":
 56960  			if r.TryDecodeAsNil() {
 56961  				if x.LogConfig != nil {
 56962  					x.LogConfig = nil
 56963  				}
 56964  			} else {
 56965  				if x.LogConfig == nil {
 56966  					x.LogConfig = new(LogConfig)
 56967  				}
 56968  				x.LogConfig.CodecDecodeSelf(d)
 56969  			}
 56970  		case "Artifacts":
 56971  			if r.TryDecodeAsNil() {
 56972  				x.Artifacts = nil
 56973  			} else {
 56974  				yyv28 := &x.Artifacts
 56975  				yym29 := z.DecBinary()
 56976  				_ = yym29
 56977  				if false {
 56978  				} else {
 56979  					h.decSlicePtrtoTaskArtifact((*[]*TaskArtifact)(yyv28), d)
 56980  				}
 56981  			}
 56982  		case "Leader":
 56983  			if r.TryDecodeAsNil() {
 56984  				x.Leader = false
 56985  			} else {
 56986  				yyv30 := &x.Leader
 56987  				yym31 := z.DecBinary()
 56988  				_ = yym31
 56989  				if false {
 56990  				} else {
 56991  					*((*bool)(yyv30)) = r.DecodeBool()
 56992  				}
 56993  			}
 56994  		case "ShutdownDelay":
 56995  			if r.TryDecodeAsNil() {
 56996  				x.ShutdownDelay = 0
 56997  			} else {
 56998  				yyv32 := &x.ShutdownDelay
 56999  				yym33 := z.DecBinary()
 57000  				_ = yym33
 57001  				if false {
 57002  				} else if z.HasExtensions() && z.DecExt(yyv32) {
 57003  				} else {
 57004  					*((*int64)(yyv32)) = int64(r.DecodeInt(64))
 57005  				}
 57006  			}
 57007  		case "KillSignal":
 57008  			if r.TryDecodeAsNil() {
 57009  				x.KillSignal = ""
 57010  			} else {
 57011  				yyv34 := &x.KillSignal
 57012  				yym35 := z.DecBinary()
 57013  				_ = yym35
 57014  				if false {
 57015  				} else {
 57016  					*((*string)(yyv34)) = r.DecodeString()
 57017  				}
 57018  			}
 57019  		default:
 57020  			z.DecStructFieldNotFound(-1, yys3)
 57021  		} // end switch yys3
 57022  	} // end for yyj3
 57023  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 57024  }
 57025  
 57026  func (x *Task) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 57027  	var h codecSelfer100
 57028  	z, r := codec1978.GenHelperDecoder(d)
 57029  	_, _, _ = h, z, r
 57030  	var yyj36 int
 57031  	var yyb36 bool
 57032  	var yyhl36 bool = l >= 0
 57033  	yyj36++
 57034  	if yyhl36 {
 57035  		yyb36 = yyj36 > l
 57036  	} else {
 57037  		yyb36 = r.CheckBreak()
 57038  	}
 57039  	if yyb36 {
 57040  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57041  		return
 57042  	}
 57043  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57044  	if r.TryDecodeAsNil() {
 57045  		x.Name = ""
 57046  	} else {
 57047  		yyv37 := &x.Name
 57048  		yym38 := z.DecBinary()
 57049  		_ = yym38
 57050  		if false {
 57051  		} else {
 57052  			*((*string)(yyv37)) = r.DecodeString()
 57053  		}
 57054  	}
 57055  	yyj36++
 57056  	if yyhl36 {
 57057  		yyb36 = yyj36 > l
 57058  	} else {
 57059  		yyb36 = r.CheckBreak()
 57060  	}
 57061  	if yyb36 {
 57062  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57063  		return
 57064  	}
 57065  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57066  	if r.TryDecodeAsNil() {
 57067  		x.Driver = ""
 57068  	} else {
 57069  		yyv39 := &x.Driver
 57070  		yym40 := z.DecBinary()
 57071  		_ = yym40
 57072  		if false {
 57073  		} else {
 57074  			*((*string)(yyv39)) = r.DecodeString()
 57075  		}
 57076  	}
 57077  	yyj36++
 57078  	if yyhl36 {
 57079  		yyb36 = yyj36 > l
 57080  	} else {
 57081  		yyb36 = r.CheckBreak()
 57082  	}
 57083  	if yyb36 {
 57084  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57085  		return
 57086  	}
 57087  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57088  	if r.TryDecodeAsNil() {
 57089  		x.User = ""
 57090  	} else {
 57091  		yyv41 := &x.User
 57092  		yym42 := z.DecBinary()
 57093  		_ = yym42
 57094  		if false {
 57095  		} else {
 57096  			*((*string)(yyv41)) = r.DecodeString()
 57097  		}
 57098  	}
 57099  	yyj36++
 57100  	if yyhl36 {
 57101  		yyb36 = yyj36 > l
 57102  	} else {
 57103  		yyb36 = r.CheckBreak()
 57104  	}
 57105  	if yyb36 {
 57106  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57107  		return
 57108  	}
 57109  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57110  	if r.TryDecodeAsNil() {
 57111  		x.Config = nil
 57112  	} else {
 57113  		yyv43 := &x.Config
 57114  		yym44 := z.DecBinary()
 57115  		_ = yym44
 57116  		if false {
 57117  		} else {
 57118  			z.F.DecMapStringIntfX(yyv43, false, d)
 57119  		}
 57120  	}
 57121  	yyj36++
 57122  	if yyhl36 {
 57123  		yyb36 = yyj36 > l
 57124  	} else {
 57125  		yyb36 = r.CheckBreak()
 57126  	}
 57127  	if yyb36 {
 57128  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57129  		return
 57130  	}
 57131  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57132  	if r.TryDecodeAsNil() {
 57133  		x.Env = nil
 57134  	} else {
 57135  		yyv45 := &x.Env
 57136  		yym46 := z.DecBinary()
 57137  		_ = yym46
 57138  		if false {
 57139  		} else {
 57140  			z.F.DecMapStringStringX(yyv45, false, d)
 57141  		}
 57142  	}
 57143  	yyj36++
 57144  	if yyhl36 {
 57145  		yyb36 = yyj36 > l
 57146  	} else {
 57147  		yyb36 = r.CheckBreak()
 57148  	}
 57149  	if yyb36 {
 57150  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57151  		return
 57152  	}
 57153  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57154  	if r.TryDecodeAsNil() {
 57155  		x.Services = nil
 57156  	} else {
 57157  		yyv47 := &x.Services
 57158  		yym48 := z.DecBinary()
 57159  		_ = yym48
 57160  		if false {
 57161  		} else {
 57162  			h.decSlicePtrtoService((*[]*Service)(yyv47), d)
 57163  		}
 57164  	}
 57165  	yyj36++
 57166  	if yyhl36 {
 57167  		yyb36 = yyj36 > l
 57168  	} else {
 57169  		yyb36 = r.CheckBreak()
 57170  	}
 57171  	if yyb36 {
 57172  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57173  		return
 57174  	}
 57175  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57176  	if r.TryDecodeAsNil() {
 57177  		if x.Vault != nil {
 57178  			x.Vault = nil
 57179  		}
 57180  	} else {
 57181  		if x.Vault == nil {
 57182  			x.Vault = new(Vault)
 57183  		}
 57184  		x.Vault.CodecDecodeSelf(d)
 57185  	}
 57186  	yyj36++
 57187  	if yyhl36 {
 57188  		yyb36 = yyj36 > l
 57189  	} else {
 57190  		yyb36 = r.CheckBreak()
 57191  	}
 57192  	if yyb36 {
 57193  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57194  		return
 57195  	}
 57196  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57197  	if r.TryDecodeAsNil() {
 57198  		x.Templates = nil
 57199  	} else {
 57200  		yyv50 := &x.Templates
 57201  		yym51 := z.DecBinary()
 57202  		_ = yym51
 57203  		if false {
 57204  		} else {
 57205  			h.decSlicePtrtoTemplate((*[]*Template)(yyv50), d)
 57206  		}
 57207  	}
 57208  	yyj36++
 57209  	if yyhl36 {
 57210  		yyb36 = yyj36 > l
 57211  	} else {
 57212  		yyb36 = r.CheckBreak()
 57213  	}
 57214  	if yyb36 {
 57215  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57216  		return
 57217  	}
 57218  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57219  	if r.TryDecodeAsNil() {
 57220  		x.Constraints = nil
 57221  	} else {
 57222  		yyv52 := &x.Constraints
 57223  		yym53 := z.DecBinary()
 57224  		_ = yym53
 57225  		if false {
 57226  		} else {
 57227  			h.decSlicePtrtoConstraint((*[]*Constraint)(yyv52), d)
 57228  		}
 57229  	}
 57230  	yyj36++
 57231  	if yyhl36 {
 57232  		yyb36 = yyj36 > l
 57233  	} else {
 57234  		yyb36 = r.CheckBreak()
 57235  	}
 57236  	if yyb36 {
 57237  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57238  		return
 57239  	}
 57240  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57241  	if r.TryDecodeAsNil() {
 57242  		if x.Resources != nil {
 57243  			x.Resources = nil
 57244  		}
 57245  	} else {
 57246  		if x.Resources == nil {
 57247  			x.Resources = new(Resources)
 57248  		}
 57249  		x.Resources.CodecDecodeSelf(d)
 57250  	}
 57251  	yyj36++
 57252  	if yyhl36 {
 57253  		yyb36 = yyj36 > l
 57254  	} else {
 57255  		yyb36 = r.CheckBreak()
 57256  	}
 57257  	if yyb36 {
 57258  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57259  		return
 57260  	}
 57261  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57262  	if r.TryDecodeAsNil() {
 57263  		if x.DispatchPayload != nil {
 57264  			x.DispatchPayload = nil
 57265  		}
 57266  	} else {
 57267  		if x.DispatchPayload == nil {
 57268  			x.DispatchPayload = new(DispatchPayloadConfig)
 57269  		}
 57270  		x.DispatchPayload.CodecDecodeSelf(d)
 57271  	}
 57272  	yyj36++
 57273  	if yyhl36 {
 57274  		yyb36 = yyj36 > l
 57275  	} else {
 57276  		yyb36 = r.CheckBreak()
 57277  	}
 57278  	if yyb36 {
 57279  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57280  		return
 57281  	}
 57282  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57283  	if r.TryDecodeAsNil() {
 57284  		x.Meta = nil
 57285  	} else {
 57286  		yyv56 := &x.Meta
 57287  		yym57 := z.DecBinary()
 57288  		_ = yym57
 57289  		if false {
 57290  		} else {
 57291  			z.F.DecMapStringStringX(yyv56, false, d)
 57292  		}
 57293  	}
 57294  	yyj36++
 57295  	if yyhl36 {
 57296  		yyb36 = yyj36 > l
 57297  	} else {
 57298  		yyb36 = r.CheckBreak()
 57299  	}
 57300  	if yyb36 {
 57301  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57302  		return
 57303  	}
 57304  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57305  	if r.TryDecodeAsNil() {
 57306  		x.KillTimeout = 0
 57307  	} else {
 57308  		yyv58 := &x.KillTimeout
 57309  		yym59 := z.DecBinary()
 57310  		_ = yym59
 57311  		if false {
 57312  		} else if z.HasExtensions() && z.DecExt(yyv58) {
 57313  		} else {
 57314  			*((*int64)(yyv58)) = int64(r.DecodeInt(64))
 57315  		}
 57316  	}
 57317  	yyj36++
 57318  	if yyhl36 {
 57319  		yyb36 = yyj36 > l
 57320  	} else {
 57321  		yyb36 = r.CheckBreak()
 57322  	}
 57323  	if yyb36 {
 57324  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57325  		return
 57326  	}
 57327  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57328  	if r.TryDecodeAsNil() {
 57329  		if x.LogConfig != nil {
 57330  			x.LogConfig = nil
 57331  		}
 57332  	} else {
 57333  		if x.LogConfig == nil {
 57334  			x.LogConfig = new(LogConfig)
 57335  		}
 57336  		x.LogConfig.CodecDecodeSelf(d)
 57337  	}
 57338  	yyj36++
 57339  	if yyhl36 {
 57340  		yyb36 = yyj36 > l
 57341  	} else {
 57342  		yyb36 = r.CheckBreak()
 57343  	}
 57344  	if yyb36 {
 57345  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57346  		return
 57347  	}
 57348  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57349  	if r.TryDecodeAsNil() {
 57350  		x.Artifacts = nil
 57351  	} else {
 57352  		yyv61 := &x.Artifacts
 57353  		yym62 := z.DecBinary()
 57354  		_ = yym62
 57355  		if false {
 57356  		} else {
 57357  			h.decSlicePtrtoTaskArtifact((*[]*TaskArtifact)(yyv61), d)
 57358  		}
 57359  	}
 57360  	yyj36++
 57361  	if yyhl36 {
 57362  		yyb36 = yyj36 > l
 57363  	} else {
 57364  		yyb36 = r.CheckBreak()
 57365  	}
 57366  	if yyb36 {
 57367  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57368  		return
 57369  	}
 57370  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57371  	if r.TryDecodeAsNil() {
 57372  		x.Leader = false
 57373  	} else {
 57374  		yyv63 := &x.Leader
 57375  		yym64 := z.DecBinary()
 57376  		_ = yym64
 57377  		if false {
 57378  		} else {
 57379  			*((*bool)(yyv63)) = r.DecodeBool()
 57380  		}
 57381  	}
 57382  	yyj36++
 57383  	if yyhl36 {
 57384  		yyb36 = yyj36 > l
 57385  	} else {
 57386  		yyb36 = r.CheckBreak()
 57387  	}
 57388  	if yyb36 {
 57389  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57390  		return
 57391  	}
 57392  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57393  	if r.TryDecodeAsNil() {
 57394  		x.ShutdownDelay = 0
 57395  	} else {
 57396  		yyv65 := &x.ShutdownDelay
 57397  		yym66 := z.DecBinary()
 57398  		_ = yym66
 57399  		if false {
 57400  		} else if z.HasExtensions() && z.DecExt(yyv65) {
 57401  		} else {
 57402  			*((*int64)(yyv65)) = int64(r.DecodeInt(64))
 57403  		}
 57404  	}
 57405  	yyj36++
 57406  	if yyhl36 {
 57407  		yyb36 = yyj36 > l
 57408  	} else {
 57409  		yyb36 = r.CheckBreak()
 57410  	}
 57411  	if yyb36 {
 57412  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57413  		return
 57414  	}
 57415  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57416  	if r.TryDecodeAsNil() {
 57417  		x.KillSignal = ""
 57418  	} else {
 57419  		yyv67 := &x.KillSignal
 57420  		yym68 := z.DecBinary()
 57421  		_ = yym68
 57422  		if false {
 57423  		} else {
 57424  			*((*string)(yyv67)) = r.DecodeString()
 57425  		}
 57426  	}
 57427  	for {
 57428  		yyj36++
 57429  		if yyhl36 {
 57430  			yyb36 = yyj36 > l
 57431  		} else {
 57432  			yyb36 = r.CheckBreak()
 57433  		}
 57434  		if yyb36 {
 57435  			break
 57436  		}
 57437  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57438  		z.DecStructFieldNotFound(yyj36-1, "")
 57439  	}
 57440  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57441  }
 57442  
 57443  func (x *Template) CodecEncodeSelf(e *codec1978.Encoder) {
 57444  	var h codecSelfer100
 57445  	z, r := codec1978.GenHelperEncoder(e)
 57446  	_, _, _ = h, z, r
 57447  	if x == nil {
 57448  		r.EncodeNil()
 57449  	} else {
 57450  		yym1 := z.EncBinary()
 57451  		_ = yym1
 57452  		if false {
 57453  		} else if z.HasExtensions() && z.EncExt(x) {
 57454  		} else {
 57455  			yysep2 := !z.EncBinary()
 57456  			yy2arr2 := z.EncBasicHandle().StructToArray
 57457  			var yyq2 [11]bool
 57458  			_, _, _ = yysep2, yyq2, yy2arr2
 57459  			const yyr2 bool = false
 57460  			var yynn2 int
 57461  			if yyr2 || yy2arr2 {
 57462  				r.EncodeArrayStart(11)
 57463  			} else {
 57464  				yynn2 = 11
 57465  				for _, b := range yyq2 {
 57466  					if b {
 57467  						yynn2++
 57468  					}
 57469  				}
 57470  				r.EncodeMapStart(yynn2)
 57471  				yynn2 = 0
 57472  			}
 57473  			if yyr2 || yy2arr2 {
 57474  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 57475  				yym4 := z.EncBinary()
 57476  				_ = yym4
 57477  				if false {
 57478  				} else {
 57479  					r.EncodeString(codecSelferC_UTF8100, string(x.SourcePath))
 57480  				}
 57481  			} else {
 57482  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 57483  				r.EncodeString(codecSelferC_UTF8100, string("SourcePath"))
 57484  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 57485  				yym5 := z.EncBinary()
 57486  				_ = yym5
 57487  				if false {
 57488  				} else {
 57489  					r.EncodeString(codecSelferC_UTF8100, string(x.SourcePath))
 57490  				}
 57491  			}
 57492  			if yyr2 || yy2arr2 {
 57493  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 57494  				yym7 := z.EncBinary()
 57495  				_ = yym7
 57496  				if false {
 57497  				} else {
 57498  					r.EncodeString(codecSelferC_UTF8100, string(x.DestPath))
 57499  				}
 57500  			} else {
 57501  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 57502  				r.EncodeString(codecSelferC_UTF8100, string("DestPath"))
 57503  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 57504  				yym8 := z.EncBinary()
 57505  				_ = yym8
 57506  				if false {
 57507  				} else {
 57508  					r.EncodeString(codecSelferC_UTF8100, string(x.DestPath))
 57509  				}
 57510  			}
 57511  			if yyr2 || yy2arr2 {
 57512  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 57513  				yym10 := z.EncBinary()
 57514  				_ = yym10
 57515  				if false {
 57516  				} else {
 57517  					r.EncodeString(codecSelferC_UTF8100, string(x.EmbeddedTmpl))
 57518  				}
 57519  			} else {
 57520  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 57521  				r.EncodeString(codecSelferC_UTF8100, string("EmbeddedTmpl"))
 57522  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 57523  				yym11 := z.EncBinary()
 57524  				_ = yym11
 57525  				if false {
 57526  				} else {
 57527  					r.EncodeString(codecSelferC_UTF8100, string(x.EmbeddedTmpl))
 57528  				}
 57529  			}
 57530  			if yyr2 || yy2arr2 {
 57531  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 57532  				yym13 := z.EncBinary()
 57533  				_ = yym13
 57534  				if false {
 57535  				} else {
 57536  					r.EncodeString(codecSelferC_UTF8100, string(x.ChangeMode))
 57537  				}
 57538  			} else {
 57539  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 57540  				r.EncodeString(codecSelferC_UTF8100, string("ChangeMode"))
 57541  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 57542  				yym14 := z.EncBinary()
 57543  				_ = yym14
 57544  				if false {
 57545  				} else {
 57546  					r.EncodeString(codecSelferC_UTF8100, string(x.ChangeMode))
 57547  				}
 57548  			}
 57549  			if yyr2 || yy2arr2 {
 57550  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 57551  				yym16 := z.EncBinary()
 57552  				_ = yym16
 57553  				if false {
 57554  				} else {
 57555  					r.EncodeString(codecSelferC_UTF8100, string(x.ChangeSignal))
 57556  				}
 57557  			} else {
 57558  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 57559  				r.EncodeString(codecSelferC_UTF8100, string("ChangeSignal"))
 57560  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 57561  				yym17 := z.EncBinary()
 57562  				_ = yym17
 57563  				if false {
 57564  				} else {
 57565  					r.EncodeString(codecSelferC_UTF8100, string(x.ChangeSignal))
 57566  				}
 57567  			}
 57568  			if yyr2 || yy2arr2 {
 57569  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 57570  				yym19 := z.EncBinary()
 57571  				_ = yym19
 57572  				if false {
 57573  				} else if z.HasExtensions() && z.EncExt(x.Splay) {
 57574  				} else {
 57575  					r.EncodeInt(int64(x.Splay))
 57576  				}
 57577  			} else {
 57578  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 57579  				r.EncodeString(codecSelferC_UTF8100, string("Splay"))
 57580  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 57581  				yym20 := z.EncBinary()
 57582  				_ = yym20
 57583  				if false {
 57584  				} else if z.HasExtensions() && z.EncExt(x.Splay) {
 57585  				} else {
 57586  					r.EncodeInt(int64(x.Splay))
 57587  				}
 57588  			}
 57589  			if yyr2 || yy2arr2 {
 57590  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 57591  				yym22 := z.EncBinary()
 57592  				_ = yym22
 57593  				if false {
 57594  				} else {
 57595  					r.EncodeString(codecSelferC_UTF8100, string(x.Perms))
 57596  				}
 57597  			} else {
 57598  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 57599  				r.EncodeString(codecSelferC_UTF8100, string("Perms"))
 57600  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 57601  				yym23 := z.EncBinary()
 57602  				_ = yym23
 57603  				if false {
 57604  				} else {
 57605  					r.EncodeString(codecSelferC_UTF8100, string(x.Perms))
 57606  				}
 57607  			}
 57608  			if yyr2 || yy2arr2 {
 57609  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 57610  				yym25 := z.EncBinary()
 57611  				_ = yym25
 57612  				if false {
 57613  				} else {
 57614  					r.EncodeString(codecSelferC_UTF8100, string(x.LeftDelim))
 57615  				}
 57616  			} else {
 57617  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 57618  				r.EncodeString(codecSelferC_UTF8100, string("LeftDelim"))
 57619  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 57620  				yym26 := z.EncBinary()
 57621  				_ = yym26
 57622  				if false {
 57623  				} else {
 57624  					r.EncodeString(codecSelferC_UTF8100, string(x.LeftDelim))
 57625  				}
 57626  			}
 57627  			if yyr2 || yy2arr2 {
 57628  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 57629  				yym28 := z.EncBinary()
 57630  				_ = yym28
 57631  				if false {
 57632  				} else {
 57633  					r.EncodeString(codecSelferC_UTF8100, string(x.RightDelim))
 57634  				}
 57635  			} else {
 57636  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 57637  				r.EncodeString(codecSelferC_UTF8100, string("RightDelim"))
 57638  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 57639  				yym29 := z.EncBinary()
 57640  				_ = yym29
 57641  				if false {
 57642  				} else {
 57643  					r.EncodeString(codecSelferC_UTF8100, string(x.RightDelim))
 57644  				}
 57645  			}
 57646  			if yyr2 || yy2arr2 {
 57647  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 57648  				yym31 := z.EncBinary()
 57649  				_ = yym31
 57650  				if false {
 57651  				} else {
 57652  					r.EncodeBool(bool(x.Envvars))
 57653  				}
 57654  			} else {
 57655  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 57656  				r.EncodeString(codecSelferC_UTF8100, string("Envvars"))
 57657  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 57658  				yym32 := z.EncBinary()
 57659  				_ = yym32
 57660  				if false {
 57661  				} else {
 57662  					r.EncodeBool(bool(x.Envvars))
 57663  				}
 57664  			}
 57665  			if yyr2 || yy2arr2 {
 57666  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 57667  				yym34 := z.EncBinary()
 57668  				_ = yym34
 57669  				if false {
 57670  				} else if z.HasExtensions() && z.EncExt(x.VaultGrace) {
 57671  				} else {
 57672  					r.EncodeInt(int64(x.VaultGrace))
 57673  				}
 57674  			} else {
 57675  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 57676  				r.EncodeString(codecSelferC_UTF8100, string("VaultGrace"))
 57677  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 57678  				yym35 := z.EncBinary()
 57679  				_ = yym35
 57680  				if false {
 57681  				} else if z.HasExtensions() && z.EncExt(x.VaultGrace) {
 57682  				} else {
 57683  					r.EncodeInt(int64(x.VaultGrace))
 57684  				}
 57685  			}
 57686  			if yyr2 || yy2arr2 {
 57687  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 57688  			} else {
 57689  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 57690  			}
 57691  		}
 57692  	}
 57693  }
 57694  
 57695  func (x *Template) CodecDecodeSelf(d *codec1978.Decoder) {
 57696  	var h codecSelfer100
 57697  	z, r := codec1978.GenHelperDecoder(d)
 57698  	_, _, _ = h, z, r
 57699  	yym1 := z.DecBinary()
 57700  	_ = yym1
 57701  	if false {
 57702  	} else if z.HasExtensions() && z.DecExt(x) {
 57703  	} else {
 57704  		yyct2 := r.ContainerType()
 57705  		if yyct2 == codecSelferValueTypeMap100 {
 57706  			yyl2 := r.ReadMapStart()
 57707  			if yyl2 == 0 {
 57708  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 57709  			} else {
 57710  				x.codecDecodeSelfFromMap(yyl2, d)
 57711  			}
 57712  		} else if yyct2 == codecSelferValueTypeArray100 {
 57713  			yyl2 := r.ReadArrayStart()
 57714  			if yyl2 == 0 {
 57715  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57716  			} else {
 57717  				x.codecDecodeSelfFromArray(yyl2, d)
 57718  			}
 57719  		} else {
 57720  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 57721  		}
 57722  	}
 57723  }
 57724  
 57725  func (x *Template) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 57726  	var h codecSelfer100
 57727  	z, r := codec1978.GenHelperDecoder(d)
 57728  	_, _, _ = h, z, r
 57729  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 57730  	_ = yys3Slc
 57731  	var yyhl3 bool = l >= 0
 57732  	for yyj3 := 0; ; yyj3++ {
 57733  		if yyhl3 {
 57734  			if yyj3 >= l {
 57735  				break
 57736  			}
 57737  		} else {
 57738  			if r.CheckBreak() {
 57739  				break
 57740  			}
 57741  		}
 57742  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 57743  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 57744  		yys3 := string(yys3Slc)
 57745  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 57746  		switch yys3 {
 57747  		case "SourcePath":
 57748  			if r.TryDecodeAsNil() {
 57749  				x.SourcePath = ""
 57750  			} else {
 57751  				yyv4 := &x.SourcePath
 57752  				yym5 := z.DecBinary()
 57753  				_ = yym5
 57754  				if false {
 57755  				} else {
 57756  					*((*string)(yyv4)) = r.DecodeString()
 57757  				}
 57758  			}
 57759  		case "DestPath":
 57760  			if r.TryDecodeAsNil() {
 57761  				x.DestPath = ""
 57762  			} else {
 57763  				yyv6 := &x.DestPath
 57764  				yym7 := z.DecBinary()
 57765  				_ = yym7
 57766  				if false {
 57767  				} else {
 57768  					*((*string)(yyv6)) = r.DecodeString()
 57769  				}
 57770  			}
 57771  		case "EmbeddedTmpl":
 57772  			if r.TryDecodeAsNil() {
 57773  				x.EmbeddedTmpl = ""
 57774  			} else {
 57775  				yyv8 := &x.EmbeddedTmpl
 57776  				yym9 := z.DecBinary()
 57777  				_ = yym9
 57778  				if false {
 57779  				} else {
 57780  					*((*string)(yyv8)) = r.DecodeString()
 57781  				}
 57782  			}
 57783  		case "ChangeMode":
 57784  			if r.TryDecodeAsNil() {
 57785  				x.ChangeMode = ""
 57786  			} else {
 57787  				yyv10 := &x.ChangeMode
 57788  				yym11 := z.DecBinary()
 57789  				_ = yym11
 57790  				if false {
 57791  				} else {
 57792  					*((*string)(yyv10)) = r.DecodeString()
 57793  				}
 57794  			}
 57795  		case "ChangeSignal":
 57796  			if r.TryDecodeAsNil() {
 57797  				x.ChangeSignal = ""
 57798  			} else {
 57799  				yyv12 := &x.ChangeSignal
 57800  				yym13 := z.DecBinary()
 57801  				_ = yym13
 57802  				if false {
 57803  				} else {
 57804  					*((*string)(yyv12)) = r.DecodeString()
 57805  				}
 57806  			}
 57807  		case "Splay":
 57808  			if r.TryDecodeAsNil() {
 57809  				x.Splay = 0
 57810  			} else {
 57811  				yyv14 := &x.Splay
 57812  				yym15 := z.DecBinary()
 57813  				_ = yym15
 57814  				if false {
 57815  				} else if z.HasExtensions() && z.DecExt(yyv14) {
 57816  				} else {
 57817  					*((*int64)(yyv14)) = int64(r.DecodeInt(64))
 57818  				}
 57819  			}
 57820  		case "Perms":
 57821  			if r.TryDecodeAsNil() {
 57822  				x.Perms = ""
 57823  			} else {
 57824  				yyv16 := &x.Perms
 57825  				yym17 := z.DecBinary()
 57826  				_ = yym17
 57827  				if false {
 57828  				} else {
 57829  					*((*string)(yyv16)) = r.DecodeString()
 57830  				}
 57831  			}
 57832  		case "LeftDelim":
 57833  			if r.TryDecodeAsNil() {
 57834  				x.LeftDelim = ""
 57835  			} else {
 57836  				yyv18 := &x.LeftDelim
 57837  				yym19 := z.DecBinary()
 57838  				_ = yym19
 57839  				if false {
 57840  				} else {
 57841  					*((*string)(yyv18)) = r.DecodeString()
 57842  				}
 57843  			}
 57844  		case "RightDelim":
 57845  			if r.TryDecodeAsNil() {
 57846  				x.RightDelim = ""
 57847  			} else {
 57848  				yyv20 := &x.RightDelim
 57849  				yym21 := z.DecBinary()
 57850  				_ = yym21
 57851  				if false {
 57852  				} else {
 57853  					*((*string)(yyv20)) = r.DecodeString()
 57854  				}
 57855  			}
 57856  		case "Envvars":
 57857  			if r.TryDecodeAsNil() {
 57858  				x.Envvars = false
 57859  			} else {
 57860  				yyv22 := &x.Envvars
 57861  				yym23 := z.DecBinary()
 57862  				_ = yym23
 57863  				if false {
 57864  				} else {
 57865  					*((*bool)(yyv22)) = r.DecodeBool()
 57866  				}
 57867  			}
 57868  		case "VaultGrace":
 57869  			if r.TryDecodeAsNil() {
 57870  				x.VaultGrace = 0
 57871  			} else {
 57872  				yyv24 := &x.VaultGrace
 57873  				yym25 := z.DecBinary()
 57874  				_ = yym25
 57875  				if false {
 57876  				} else if z.HasExtensions() && z.DecExt(yyv24) {
 57877  				} else {
 57878  					*((*int64)(yyv24)) = int64(r.DecodeInt(64))
 57879  				}
 57880  			}
 57881  		default:
 57882  			z.DecStructFieldNotFound(-1, yys3)
 57883  		} // end switch yys3
 57884  	} // end for yyj3
 57885  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 57886  }
 57887  
 57888  func (x *Template) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 57889  	var h codecSelfer100
 57890  	z, r := codec1978.GenHelperDecoder(d)
 57891  	_, _, _ = h, z, r
 57892  	var yyj26 int
 57893  	var yyb26 bool
 57894  	var yyhl26 bool = l >= 0
 57895  	yyj26++
 57896  	if yyhl26 {
 57897  		yyb26 = yyj26 > l
 57898  	} else {
 57899  		yyb26 = r.CheckBreak()
 57900  	}
 57901  	if yyb26 {
 57902  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57903  		return
 57904  	}
 57905  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57906  	if r.TryDecodeAsNil() {
 57907  		x.SourcePath = ""
 57908  	} else {
 57909  		yyv27 := &x.SourcePath
 57910  		yym28 := z.DecBinary()
 57911  		_ = yym28
 57912  		if false {
 57913  		} else {
 57914  			*((*string)(yyv27)) = r.DecodeString()
 57915  		}
 57916  	}
 57917  	yyj26++
 57918  	if yyhl26 {
 57919  		yyb26 = yyj26 > l
 57920  	} else {
 57921  		yyb26 = r.CheckBreak()
 57922  	}
 57923  	if yyb26 {
 57924  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57925  		return
 57926  	}
 57927  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57928  	if r.TryDecodeAsNil() {
 57929  		x.DestPath = ""
 57930  	} else {
 57931  		yyv29 := &x.DestPath
 57932  		yym30 := z.DecBinary()
 57933  		_ = yym30
 57934  		if false {
 57935  		} else {
 57936  			*((*string)(yyv29)) = r.DecodeString()
 57937  		}
 57938  	}
 57939  	yyj26++
 57940  	if yyhl26 {
 57941  		yyb26 = yyj26 > l
 57942  	} else {
 57943  		yyb26 = r.CheckBreak()
 57944  	}
 57945  	if yyb26 {
 57946  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57947  		return
 57948  	}
 57949  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57950  	if r.TryDecodeAsNil() {
 57951  		x.EmbeddedTmpl = ""
 57952  	} else {
 57953  		yyv31 := &x.EmbeddedTmpl
 57954  		yym32 := z.DecBinary()
 57955  		_ = yym32
 57956  		if false {
 57957  		} else {
 57958  			*((*string)(yyv31)) = r.DecodeString()
 57959  		}
 57960  	}
 57961  	yyj26++
 57962  	if yyhl26 {
 57963  		yyb26 = yyj26 > l
 57964  	} else {
 57965  		yyb26 = r.CheckBreak()
 57966  	}
 57967  	if yyb26 {
 57968  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57969  		return
 57970  	}
 57971  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57972  	if r.TryDecodeAsNil() {
 57973  		x.ChangeMode = ""
 57974  	} else {
 57975  		yyv33 := &x.ChangeMode
 57976  		yym34 := z.DecBinary()
 57977  		_ = yym34
 57978  		if false {
 57979  		} else {
 57980  			*((*string)(yyv33)) = r.DecodeString()
 57981  		}
 57982  	}
 57983  	yyj26++
 57984  	if yyhl26 {
 57985  		yyb26 = yyj26 > l
 57986  	} else {
 57987  		yyb26 = r.CheckBreak()
 57988  	}
 57989  	if yyb26 {
 57990  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 57991  		return
 57992  	}
 57993  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 57994  	if r.TryDecodeAsNil() {
 57995  		x.ChangeSignal = ""
 57996  	} else {
 57997  		yyv35 := &x.ChangeSignal
 57998  		yym36 := z.DecBinary()
 57999  		_ = yym36
 58000  		if false {
 58001  		} else {
 58002  			*((*string)(yyv35)) = r.DecodeString()
 58003  		}
 58004  	}
 58005  	yyj26++
 58006  	if yyhl26 {
 58007  		yyb26 = yyj26 > l
 58008  	} else {
 58009  		yyb26 = r.CheckBreak()
 58010  	}
 58011  	if yyb26 {
 58012  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58013  		return
 58014  	}
 58015  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 58016  	if r.TryDecodeAsNil() {
 58017  		x.Splay = 0
 58018  	} else {
 58019  		yyv37 := &x.Splay
 58020  		yym38 := z.DecBinary()
 58021  		_ = yym38
 58022  		if false {
 58023  		} else if z.HasExtensions() && z.DecExt(yyv37) {
 58024  		} else {
 58025  			*((*int64)(yyv37)) = int64(r.DecodeInt(64))
 58026  		}
 58027  	}
 58028  	yyj26++
 58029  	if yyhl26 {
 58030  		yyb26 = yyj26 > l
 58031  	} else {
 58032  		yyb26 = r.CheckBreak()
 58033  	}
 58034  	if yyb26 {
 58035  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58036  		return
 58037  	}
 58038  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 58039  	if r.TryDecodeAsNil() {
 58040  		x.Perms = ""
 58041  	} else {
 58042  		yyv39 := &x.Perms
 58043  		yym40 := z.DecBinary()
 58044  		_ = yym40
 58045  		if false {
 58046  		} else {
 58047  			*((*string)(yyv39)) = r.DecodeString()
 58048  		}
 58049  	}
 58050  	yyj26++
 58051  	if yyhl26 {
 58052  		yyb26 = yyj26 > l
 58053  	} else {
 58054  		yyb26 = r.CheckBreak()
 58055  	}
 58056  	if yyb26 {
 58057  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58058  		return
 58059  	}
 58060  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 58061  	if r.TryDecodeAsNil() {
 58062  		x.LeftDelim = ""
 58063  	} else {
 58064  		yyv41 := &x.LeftDelim
 58065  		yym42 := z.DecBinary()
 58066  		_ = yym42
 58067  		if false {
 58068  		} else {
 58069  			*((*string)(yyv41)) = r.DecodeString()
 58070  		}
 58071  	}
 58072  	yyj26++
 58073  	if yyhl26 {
 58074  		yyb26 = yyj26 > l
 58075  	} else {
 58076  		yyb26 = r.CheckBreak()
 58077  	}
 58078  	if yyb26 {
 58079  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58080  		return
 58081  	}
 58082  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 58083  	if r.TryDecodeAsNil() {
 58084  		x.RightDelim = ""
 58085  	} else {
 58086  		yyv43 := &x.RightDelim
 58087  		yym44 := z.DecBinary()
 58088  		_ = yym44
 58089  		if false {
 58090  		} else {
 58091  			*((*string)(yyv43)) = r.DecodeString()
 58092  		}
 58093  	}
 58094  	yyj26++
 58095  	if yyhl26 {
 58096  		yyb26 = yyj26 > l
 58097  	} else {
 58098  		yyb26 = r.CheckBreak()
 58099  	}
 58100  	if yyb26 {
 58101  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58102  		return
 58103  	}
 58104  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 58105  	if r.TryDecodeAsNil() {
 58106  		x.Envvars = false
 58107  	} else {
 58108  		yyv45 := &x.Envvars
 58109  		yym46 := z.DecBinary()
 58110  		_ = yym46
 58111  		if false {
 58112  		} else {
 58113  			*((*bool)(yyv45)) = r.DecodeBool()
 58114  		}
 58115  	}
 58116  	yyj26++
 58117  	if yyhl26 {
 58118  		yyb26 = yyj26 > l
 58119  	} else {
 58120  		yyb26 = r.CheckBreak()
 58121  	}
 58122  	if yyb26 {
 58123  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58124  		return
 58125  	}
 58126  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 58127  	if r.TryDecodeAsNil() {
 58128  		x.VaultGrace = 0
 58129  	} else {
 58130  		yyv47 := &x.VaultGrace
 58131  		yym48 := z.DecBinary()
 58132  		_ = yym48
 58133  		if false {
 58134  		} else if z.HasExtensions() && z.DecExt(yyv47) {
 58135  		} else {
 58136  			*((*int64)(yyv47)) = int64(r.DecodeInt(64))
 58137  		}
 58138  	}
 58139  	for {
 58140  		yyj26++
 58141  		if yyhl26 {
 58142  			yyb26 = yyj26 > l
 58143  		} else {
 58144  			yyb26 = r.CheckBreak()
 58145  		}
 58146  		if yyb26 {
 58147  			break
 58148  		}
 58149  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 58150  		z.DecStructFieldNotFound(yyj26-1, "")
 58151  	}
 58152  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58153  }
 58154  
 58155  func (x *TaskState) CodecEncodeSelf(e *codec1978.Encoder) {
 58156  	var h codecSelfer100
 58157  	z, r := codec1978.GenHelperEncoder(e)
 58158  	_, _, _ = h, z, r
 58159  	if x == nil {
 58160  		r.EncodeNil()
 58161  	} else {
 58162  		yym1 := z.EncBinary()
 58163  		_ = yym1
 58164  		if false {
 58165  		} else if z.HasExtensions() && z.EncExt(x) {
 58166  		} else {
 58167  			yysep2 := !z.EncBinary()
 58168  			yy2arr2 := z.EncBasicHandle().StructToArray
 58169  			var yyq2 [7]bool
 58170  			_, _, _ = yysep2, yyq2, yy2arr2
 58171  			const yyr2 bool = false
 58172  			var yynn2 int
 58173  			if yyr2 || yy2arr2 {
 58174  				r.EncodeArrayStart(7)
 58175  			} else {
 58176  				yynn2 = 7
 58177  				for _, b := range yyq2 {
 58178  					if b {
 58179  						yynn2++
 58180  					}
 58181  				}
 58182  				r.EncodeMapStart(yynn2)
 58183  				yynn2 = 0
 58184  			}
 58185  			if yyr2 || yy2arr2 {
 58186  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58187  				yym4 := z.EncBinary()
 58188  				_ = yym4
 58189  				if false {
 58190  				} else {
 58191  					r.EncodeString(codecSelferC_UTF8100, string(x.State))
 58192  				}
 58193  			} else {
 58194  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58195  				r.EncodeString(codecSelferC_UTF8100, string("State"))
 58196  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58197  				yym5 := z.EncBinary()
 58198  				_ = yym5
 58199  				if false {
 58200  				} else {
 58201  					r.EncodeString(codecSelferC_UTF8100, string(x.State))
 58202  				}
 58203  			}
 58204  			if yyr2 || yy2arr2 {
 58205  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58206  				yym7 := z.EncBinary()
 58207  				_ = yym7
 58208  				if false {
 58209  				} else {
 58210  					r.EncodeBool(bool(x.Failed))
 58211  				}
 58212  			} else {
 58213  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58214  				r.EncodeString(codecSelferC_UTF8100, string("Failed"))
 58215  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58216  				yym8 := z.EncBinary()
 58217  				_ = yym8
 58218  				if false {
 58219  				} else {
 58220  					r.EncodeBool(bool(x.Failed))
 58221  				}
 58222  			}
 58223  			if yyr2 || yy2arr2 {
 58224  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58225  				yym10 := z.EncBinary()
 58226  				_ = yym10
 58227  				if false {
 58228  				} else {
 58229  					r.EncodeUint(uint64(x.Restarts))
 58230  				}
 58231  			} else {
 58232  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58233  				r.EncodeString(codecSelferC_UTF8100, string("Restarts"))
 58234  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58235  				yym11 := z.EncBinary()
 58236  				_ = yym11
 58237  				if false {
 58238  				} else {
 58239  					r.EncodeUint(uint64(x.Restarts))
 58240  				}
 58241  			}
 58242  			if yyr2 || yy2arr2 {
 58243  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58244  				yy13 := &x.LastRestart
 58245  				yym14 := z.EncBinary()
 58246  				_ = yym14
 58247  				if false {
 58248  				} else if yym15 := z.TimeRtidIfBinc(); yym15 != 0 {
 58249  					r.EncodeBuiltin(yym15, yy13)
 58250  				} else if z.HasExtensions() && z.EncExt(yy13) {
 58251  				} else if yym14 {
 58252  					z.EncBinaryMarshal(yy13)
 58253  				} else if !yym14 && z.IsJSONHandle() {
 58254  					z.EncJSONMarshal(yy13)
 58255  				} else {
 58256  					z.EncFallback(yy13)
 58257  				}
 58258  			} else {
 58259  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58260  				r.EncodeString(codecSelferC_UTF8100, string("LastRestart"))
 58261  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58262  				yy16 := &x.LastRestart
 58263  				yym17 := z.EncBinary()
 58264  				_ = yym17
 58265  				if false {
 58266  				} else if yym18 := z.TimeRtidIfBinc(); yym18 != 0 {
 58267  					r.EncodeBuiltin(yym18, yy16)
 58268  				} else if z.HasExtensions() && z.EncExt(yy16) {
 58269  				} else if yym17 {
 58270  					z.EncBinaryMarshal(yy16)
 58271  				} else if !yym17 && z.IsJSONHandle() {
 58272  					z.EncJSONMarshal(yy16)
 58273  				} else {
 58274  					z.EncFallback(yy16)
 58275  				}
 58276  			}
 58277  			if yyr2 || yy2arr2 {
 58278  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58279  				yy20 := &x.StartedAt
 58280  				yym21 := z.EncBinary()
 58281  				_ = yym21
 58282  				if false {
 58283  				} else if yym22 := z.TimeRtidIfBinc(); yym22 != 0 {
 58284  					r.EncodeBuiltin(yym22, yy20)
 58285  				} else if z.HasExtensions() && z.EncExt(yy20) {
 58286  				} else if yym21 {
 58287  					z.EncBinaryMarshal(yy20)
 58288  				} else if !yym21 && z.IsJSONHandle() {
 58289  					z.EncJSONMarshal(yy20)
 58290  				} else {
 58291  					z.EncFallback(yy20)
 58292  				}
 58293  			} else {
 58294  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58295  				r.EncodeString(codecSelferC_UTF8100, string("StartedAt"))
 58296  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58297  				yy23 := &x.StartedAt
 58298  				yym24 := z.EncBinary()
 58299  				_ = yym24
 58300  				if false {
 58301  				} else if yym25 := z.TimeRtidIfBinc(); yym25 != 0 {
 58302  					r.EncodeBuiltin(yym25, yy23)
 58303  				} else if z.HasExtensions() && z.EncExt(yy23) {
 58304  				} else if yym24 {
 58305  					z.EncBinaryMarshal(yy23)
 58306  				} else if !yym24 && z.IsJSONHandle() {
 58307  					z.EncJSONMarshal(yy23)
 58308  				} else {
 58309  					z.EncFallback(yy23)
 58310  				}
 58311  			}
 58312  			if yyr2 || yy2arr2 {
 58313  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58314  				yy27 := &x.FinishedAt
 58315  				yym28 := z.EncBinary()
 58316  				_ = yym28
 58317  				if false {
 58318  				} else if yym29 := z.TimeRtidIfBinc(); yym29 != 0 {
 58319  					r.EncodeBuiltin(yym29, yy27)
 58320  				} else if z.HasExtensions() && z.EncExt(yy27) {
 58321  				} else if yym28 {
 58322  					z.EncBinaryMarshal(yy27)
 58323  				} else if !yym28 && z.IsJSONHandle() {
 58324  					z.EncJSONMarshal(yy27)
 58325  				} else {
 58326  					z.EncFallback(yy27)
 58327  				}
 58328  			} else {
 58329  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58330  				r.EncodeString(codecSelferC_UTF8100, string("FinishedAt"))
 58331  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58332  				yy30 := &x.FinishedAt
 58333  				yym31 := z.EncBinary()
 58334  				_ = yym31
 58335  				if false {
 58336  				} else if yym32 := z.TimeRtidIfBinc(); yym32 != 0 {
 58337  					r.EncodeBuiltin(yym32, yy30)
 58338  				} else if z.HasExtensions() && z.EncExt(yy30) {
 58339  				} else if yym31 {
 58340  					z.EncBinaryMarshal(yy30)
 58341  				} else if !yym31 && z.IsJSONHandle() {
 58342  					z.EncJSONMarshal(yy30)
 58343  				} else {
 58344  					z.EncFallback(yy30)
 58345  				}
 58346  			}
 58347  			if yyr2 || yy2arr2 {
 58348  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58349  				if x.Events == nil {
 58350  					r.EncodeNil()
 58351  				} else {
 58352  					yym34 := z.EncBinary()
 58353  					_ = yym34
 58354  					if false {
 58355  					} else {
 58356  						h.encSlicePtrtoTaskEvent(([]*TaskEvent)(x.Events), e)
 58357  					}
 58358  				}
 58359  			} else {
 58360  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58361  				r.EncodeString(codecSelferC_UTF8100, string("Events"))
 58362  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58363  				if x.Events == nil {
 58364  					r.EncodeNil()
 58365  				} else {
 58366  					yym35 := z.EncBinary()
 58367  					_ = yym35
 58368  					if false {
 58369  					} else {
 58370  						h.encSlicePtrtoTaskEvent(([]*TaskEvent)(x.Events), e)
 58371  					}
 58372  				}
 58373  			}
 58374  			if yyr2 || yy2arr2 {
 58375  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 58376  			} else {
 58377  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 58378  			}
 58379  		}
 58380  	}
 58381  }
 58382  
 58383  func (x *TaskState) CodecDecodeSelf(d *codec1978.Decoder) {
 58384  	var h codecSelfer100
 58385  	z, r := codec1978.GenHelperDecoder(d)
 58386  	_, _, _ = h, z, r
 58387  	yym1 := z.DecBinary()
 58388  	_ = yym1
 58389  	if false {
 58390  	} else if z.HasExtensions() && z.DecExt(x) {
 58391  	} else {
 58392  		yyct2 := r.ContainerType()
 58393  		if yyct2 == codecSelferValueTypeMap100 {
 58394  			yyl2 := r.ReadMapStart()
 58395  			if yyl2 == 0 {
 58396  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 58397  			} else {
 58398  				x.codecDecodeSelfFromMap(yyl2, d)
 58399  			}
 58400  		} else if yyct2 == codecSelferValueTypeArray100 {
 58401  			yyl2 := r.ReadArrayStart()
 58402  			if yyl2 == 0 {
 58403  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58404  			} else {
 58405  				x.codecDecodeSelfFromArray(yyl2, d)
 58406  			}
 58407  		} else {
 58408  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 58409  		}
 58410  	}
 58411  }
 58412  
 58413  func (x *TaskState) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 58414  	var h codecSelfer100
 58415  	z, r := codec1978.GenHelperDecoder(d)
 58416  	_, _, _ = h, z, r
 58417  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 58418  	_ = yys3Slc
 58419  	var yyhl3 bool = l >= 0
 58420  	for yyj3 := 0; ; yyj3++ {
 58421  		if yyhl3 {
 58422  			if yyj3 >= l {
 58423  				break
 58424  			}
 58425  		} else {
 58426  			if r.CheckBreak() {
 58427  				break
 58428  			}
 58429  		}
 58430  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 58431  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 58432  		yys3 := string(yys3Slc)
 58433  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 58434  		switch yys3 {
 58435  		case "State":
 58436  			if r.TryDecodeAsNil() {
 58437  				x.State = ""
 58438  			} else {
 58439  				yyv4 := &x.State
 58440  				yym5 := z.DecBinary()
 58441  				_ = yym5
 58442  				if false {
 58443  				} else {
 58444  					*((*string)(yyv4)) = r.DecodeString()
 58445  				}
 58446  			}
 58447  		case "Failed":
 58448  			if r.TryDecodeAsNil() {
 58449  				x.Failed = false
 58450  			} else {
 58451  				yyv6 := &x.Failed
 58452  				yym7 := z.DecBinary()
 58453  				_ = yym7
 58454  				if false {
 58455  				} else {
 58456  					*((*bool)(yyv6)) = r.DecodeBool()
 58457  				}
 58458  			}
 58459  		case "Restarts":
 58460  			if r.TryDecodeAsNil() {
 58461  				x.Restarts = 0
 58462  			} else {
 58463  				yyv8 := &x.Restarts
 58464  				yym9 := z.DecBinary()
 58465  				_ = yym9
 58466  				if false {
 58467  				} else {
 58468  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 58469  				}
 58470  			}
 58471  		case "LastRestart":
 58472  			if r.TryDecodeAsNil() {
 58473  				x.LastRestart = time.Time{}
 58474  			} else {
 58475  				yyv10 := &x.LastRestart
 58476  				yym11 := z.DecBinary()
 58477  				_ = yym11
 58478  				if false {
 58479  				} else if yym12 := z.TimeRtidIfBinc(); yym12 != 0 {
 58480  					r.DecodeBuiltin(yym12, yyv10)
 58481  				} else if z.HasExtensions() && z.DecExt(yyv10) {
 58482  				} else if yym11 {
 58483  					z.DecBinaryUnmarshal(yyv10)
 58484  				} else if !yym11 && z.IsJSONHandle() {
 58485  					z.DecJSONUnmarshal(yyv10)
 58486  				} else {
 58487  					z.DecFallback(yyv10, false)
 58488  				}
 58489  			}
 58490  		case "StartedAt":
 58491  			if r.TryDecodeAsNil() {
 58492  				x.StartedAt = time.Time{}
 58493  			} else {
 58494  				yyv13 := &x.StartedAt
 58495  				yym14 := z.DecBinary()
 58496  				_ = yym14
 58497  				if false {
 58498  				} else if yym15 := z.TimeRtidIfBinc(); yym15 != 0 {
 58499  					r.DecodeBuiltin(yym15, yyv13)
 58500  				} else if z.HasExtensions() && z.DecExt(yyv13) {
 58501  				} else if yym14 {
 58502  					z.DecBinaryUnmarshal(yyv13)
 58503  				} else if !yym14 && z.IsJSONHandle() {
 58504  					z.DecJSONUnmarshal(yyv13)
 58505  				} else {
 58506  					z.DecFallback(yyv13, false)
 58507  				}
 58508  			}
 58509  		case "FinishedAt":
 58510  			if r.TryDecodeAsNil() {
 58511  				x.FinishedAt = time.Time{}
 58512  			} else {
 58513  				yyv16 := &x.FinishedAt
 58514  				yym17 := z.DecBinary()
 58515  				_ = yym17
 58516  				if false {
 58517  				} else if yym18 := z.TimeRtidIfBinc(); yym18 != 0 {
 58518  					r.DecodeBuiltin(yym18, yyv16)
 58519  				} else if z.HasExtensions() && z.DecExt(yyv16) {
 58520  				} else if yym17 {
 58521  					z.DecBinaryUnmarshal(yyv16)
 58522  				} else if !yym17 && z.IsJSONHandle() {
 58523  					z.DecJSONUnmarshal(yyv16)
 58524  				} else {
 58525  					z.DecFallback(yyv16, false)
 58526  				}
 58527  			}
 58528  		case "Events":
 58529  			if r.TryDecodeAsNil() {
 58530  				x.Events = nil
 58531  			} else {
 58532  				yyv19 := &x.Events
 58533  				yym20 := z.DecBinary()
 58534  				_ = yym20
 58535  				if false {
 58536  				} else {
 58537  					h.decSlicePtrtoTaskEvent((*[]*TaskEvent)(yyv19), d)
 58538  				}
 58539  			}
 58540  		default:
 58541  			z.DecStructFieldNotFound(-1, yys3)
 58542  		} // end switch yys3
 58543  	} // end for yyj3
 58544  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 58545  }
 58546  
 58547  func (x *TaskState) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 58548  	var h codecSelfer100
 58549  	z, r := codec1978.GenHelperDecoder(d)
 58550  	_, _, _ = h, z, r
 58551  	var yyj21 int
 58552  	var yyb21 bool
 58553  	var yyhl21 bool = l >= 0
 58554  	yyj21++
 58555  	if yyhl21 {
 58556  		yyb21 = yyj21 > l
 58557  	} else {
 58558  		yyb21 = r.CheckBreak()
 58559  	}
 58560  	if yyb21 {
 58561  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58562  		return
 58563  	}
 58564  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 58565  	if r.TryDecodeAsNil() {
 58566  		x.State = ""
 58567  	} else {
 58568  		yyv22 := &x.State
 58569  		yym23 := z.DecBinary()
 58570  		_ = yym23
 58571  		if false {
 58572  		} else {
 58573  			*((*string)(yyv22)) = r.DecodeString()
 58574  		}
 58575  	}
 58576  	yyj21++
 58577  	if yyhl21 {
 58578  		yyb21 = yyj21 > l
 58579  	} else {
 58580  		yyb21 = r.CheckBreak()
 58581  	}
 58582  	if yyb21 {
 58583  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58584  		return
 58585  	}
 58586  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 58587  	if r.TryDecodeAsNil() {
 58588  		x.Failed = false
 58589  	} else {
 58590  		yyv24 := &x.Failed
 58591  		yym25 := z.DecBinary()
 58592  		_ = yym25
 58593  		if false {
 58594  		} else {
 58595  			*((*bool)(yyv24)) = r.DecodeBool()
 58596  		}
 58597  	}
 58598  	yyj21++
 58599  	if yyhl21 {
 58600  		yyb21 = yyj21 > l
 58601  	} else {
 58602  		yyb21 = r.CheckBreak()
 58603  	}
 58604  	if yyb21 {
 58605  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58606  		return
 58607  	}
 58608  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 58609  	if r.TryDecodeAsNil() {
 58610  		x.Restarts = 0
 58611  	} else {
 58612  		yyv26 := &x.Restarts
 58613  		yym27 := z.DecBinary()
 58614  		_ = yym27
 58615  		if false {
 58616  		} else {
 58617  			*((*uint64)(yyv26)) = uint64(r.DecodeUint(64))
 58618  		}
 58619  	}
 58620  	yyj21++
 58621  	if yyhl21 {
 58622  		yyb21 = yyj21 > l
 58623  	} else {
 58624  		yyb21 = r.CheckBreak()
 58625  	}
 58626  	if yyb21 {
 58627  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58628  		return
 58629  	}
 58630  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 58631  	if r.TryDecodeAsNil() {
 58632  		x.LastRestart = time.Time{}
 58633  	} else {
 58634  		yyv28 := &x.LastRestart
 58635  		yym29 := z.DecBinary()
 58636  		_ = yym29
 58637  		if false {
 58638  		} else if yym30 := z.TimeRtidIfBinc(); yym30 != 0 {
 58639  			r.DecodeBuiltin(yym30, yyv28)
 58640  		} else if z.HasExtensions() && z.DecExt(yyv28) {
 58641  		} else if yym29 {
 58642  			z.DecBinaryUnmarshal(yyv28)
 58643  		} else if !yym29 && z.IsJSONHandle() {
 58644  			z.DecJSONUnmarshal(yyv28)
 58645  		} else {
 58646  			z.DecFallback(yyv28, false)
 58647  		}
 58648  	}
 58649  	yyj21++
 58650  	if yyhl21 {
 58651  		yyb21 = yyj21 > l
 58652  	} else {
 58653  		yyb21 = r.CheckBreak()
 58654  	}
 58655  	if yyb21 {
 58656  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58657  		return
 58658  	}
 58659  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 58660  	if r.TryDecodeAsNil() {
 58661  		x.StartedAt = time.Time{}
 58662  	} else {
 58663  		yyv31 := &x.StartedAt
 58664  		yym32 := z.DecBinary()
 58665  		_ = yym32
 58666  		if false {
 58667  		} else if yym33 := z.TimeRtidIfBinc(); yym33 != 0 {
 58668  			r.DecodeBuiltin(yym33, yyv31)
 58669  		} else if z.HasExtensions() && z.DecExt(yyv31) {
 58670  		} else if yym32 {
 58671  			z.DecBinaryUnmarshal(yyv31)
 58672  		} else if !yym32 && z.IsJSONHandle() {
 58673  			z.DecJSONUnmarshal(yyv31)
 58674  		} else {
 58675  			z.DecFallback(yyv31, false)
 58676  		}
 58677  	}
 58678  	yyj21++
 58679  	if yyhl21 {
 58680  		yyb21 = yyj21 > l
 58681  	} else {
 58682  		yyb21 = r.CheckBreak()
 58683  	}
 58684  	if yyb21 {
 58685  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58686  		return
 58687  	}
 58688  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 58689  	if r.TryDecodeAsNil() {
 58690  		x.FinishedAt = time.Time{}
 58691  	} else {
 58692  		yyv34 := &x.FinishedAt
 58693  		yym35 := z.DecBinary()
 58694  		_ = yym35
 58695  		if false {
 58696  		} else if yym36 := z.TimeRtidIfBinc(); yym36 != 0 {
 58697  			r.DecodeBuiltin(yym36, yyv34)
 58698  		} else if z.HasExtensions() && z.DecExt(yyv34) {
 58699  		} else if yym35 {
 58700  			z.DecBinaryUnmarshal(yyv34)
 58701  		} else if !yym35 && z.IsJSONHandle() {
 58702  			z.DecJSONUnmarshal(yyv34)
 58703  		} else {
 58704  			z.DecFallback(yyv34, false)
 58705  		}
 58706  	}
 58707  	yyj21++
 58708  	if yyhl21 {
 58709  		yyb21 = yyj21 > l
 58710  	} else {
 58711  		yyb21 = r.CheckBreak()
 58712  	}
 58713  	if yyb21 {
 58714  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58715  		return
 58716  	}
 58717  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 58718  	if r.TryDecodeAsNil() {
 58719  		x.Events = nil
 58720  	} else {
 58721  		yyv37 := &x.Events
 58722  		yym38 := z.DecBinary()
 58723  		_ = yym38
 58724  		if false {
 58725  		} else {
 58726  			h.decSlicePtrtoTaskEvent((*[]*TaskEvent)(yyv37), d)
 58727  		}
 58728  	}
 58729  	for {
 58730  		yyj21++
 58731  		if yyhl21 {
 58732  			yyb21 = yyj21 > l
 58733  		} else {
 58734  			yyb21 = r.CheckBreak()
 58735  		}
 58736  		if yyb21 {
 58737  			break
 58738  		}
 58739  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 58740  		z.DecStructFieldNotFound(yyj21-1, "")
 58741  	}
 58742  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 58743  }
 58744  
 58745  func (x *TaskEvent) CodecEncodeSelf(e *codec1978.Encoder) {
 58746  	var h codecSelfer100
 58747  	z, r := codec1978.GenHelperEncoder(e)
 58748  	_, _, _ = h, z, r
 58749  	if x == nil {
 58750  		r.EncodeNil()
 58751  	} else {
 58752  		yym1 := z.EncBinary()
 58753  		_ = yym1
 58754  		if false {
 58755  		} else if z.HasExtensions() && z.EncExt(x) {
 58756  		} else {
 58757  			yysep2 := !z.EncBinary()
 58758  			yy2arr2 := z.EncBasicHandle().StructToArray
 58759  			var yyq2 [24]bool
 58760  			_, _, _ = yysep2, yyq2, yy2arr2
 58761  			const yyr2 bool = false
 58762  			var yynn2 int
 58763  			if yyr2 || yy2arr2 {
 58764  				r.EncodeArrayStart(24)
 58765  			} else {
 58766  				yynn2 = 24
 58767  				for _, b := range yyq2 {
 58768  					if b {
 58769  						yynn2++
 58770  					}
 58771  				}
 58772  				r.EncodeMapStart(yynn2)
 58773  				yynn2 = 0
 58774  			}
 58775  			if yyr2 || yy2arr2 {
 58776  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58777  				yym4 := z.EncBinary()
 58778  				_ = yym4
 58779  				if false {
 58780  				} else {
 58781  					r.EncodeString(codecSelferC_UTF8100, string(x.Type))
 58782  				}
 58783  			} else {
 58784  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58785  				r.EncodeString(codecSelferC_UTF8100, string("Type"))
 58786  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58787  				yym5 := z.EncBinary()
 58788  				_ = yym5
 58789  				if false {
 58790  				} else {
 58791  					r.EncodeString(codecSelferC_UTF8100, string(x.Type))
 58792  				}
 58793  			}
 58794  			if yyr2 || yy2arr2 {
 58795  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58796  				yym7 := z.EncBinary()
 58797  				_ = yym7
 58798  				if false {
 58799  				} else {
 58800  					r.EncodeInt(int64(x.Time))
 58801  				}
 58802  			} else {
 58803  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58804  				r.EncodeString(codecSelferC_UTF8100, string("Time"))
 58805  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58806  				yym8 := z.EncBinary()
 58807  				_ = yym8
 58808  				if false {
 58809  				} else {
 58810  					r.EncodeInt(int64(x.Time))
 58811  				}
 58812  			}
 58813  			if yyr2 || yy2arr2 {
 58814  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58815  				yym10 := z.EncBinary()
 58816  				_ = yym10
 58817  				if false {
 58818  				} else {
 58819  					r.EncodeString(codecSelferC_UTF8100, string(x.Message))
 58820  				}
 58821  			} else {
 58822  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58823  				r.EncodeString(codecSelferC_UTF8100, string("Message"))
 58824  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58825  				yym11 := z.EncBinary()
 58826  				_ = yym11
 58827  				if false {
 58828  				} else {
 58829  					r.EncodeString(codecSelferC_UTF8100, string(x.Message))
 58830  				}
 58831  			}
 58832  			if yyr2 || yy2arr2 {
 58833  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58834  				yym13 := z.EncBinary()
 58835  				_ = yym13
 58836  				if false {
 58837  				} else {
 58838  					r.EncodeString(codecSelferC_UTF8100, string(x.DisplayMessage))
 58839  				}
 58840  			} else {
 58841  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58842  				r.EncodeString(codecSelferC_UTF8100, string("DisplayMessage"))
 58843  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58844  				yym14 := z.EncBinary()
 58845  				_ = yym14
 58846  				if false {
 58847  				} else {
 58848  					r.EncodeString(codecSelferC_UTF8100, string(x.DisplayMessage))
 58849  				}
 58850  			}
 58851  			if yyr2 || yy2arr2 {
 58852  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58853  				if x.Details == nil {
 58854  					r.EncodeNil()
 58855  				} else {
 58856  					yym16 := z.EncBinary()
 58857  					_ = yym16
 58858  					if false {
 58859  					} else {
 58860  						z.F.EncMapStringStringV(x.Details, false, e)
 58861  					}
 58862  				}
 58863  			} else {
 58864  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58865  				r.EncodeString(codecSelferC_UTF8100, string("Details"))
 58866  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58867  				if x.Details == nil {
 58868  					r.EncodeNil()
 58869  				} else {
 58870  					yym17 := z.EncBinary()
 58871  					_ = yym17
 58872  					if false {
 58873  					} else {
 58874  						z.F.EncMapStringStringV(x.Details, false, e)
 58875  					}
 58876  				}
 58877  			}
 58878  			if yyr2 || yy2arr2 {
 58879  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58880  				yym19 := z.EncBinary()
 58881  				_ = yym19
 58882  				if false {
 58883  				} else {
 58884  					r.EncodeBool(bool(x.FailsTask))
 58885  				}
 58886  			} else {
 58887  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58888  				r.EncodeString(codecSelferC_UTF8100, string("FailsTask"))
 58889  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58890  				yym20 := z.EncBinary()
 58891  				_ = yym20
 58892  				if false {
 58893  				} else {
 58894  					r.EncodeBool(bool(x.FailsTask))
 58895  				}
 58896  			}
 58897  			if yyr2 || yy2arr2 {
 58898  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58899  				yym22 := z.EncBinary()
 58900  				_ = yym22
 58901  				if false {
 58902  				} else {
 58903  					r.EncodeString(codecSelferC_UTF8100, string(x.RestartReason))
 58904  				}
 58905  			} else {
 58906  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58907  				r.EncodeString(codecSelferC_UTF8100, string("RestartReason"))
 58908  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58909  				yym23 := z.EncBinary()
 58910  				_ = yym23
 58911  				if false {
 58912  				} else {
 58913  					r.EncodeString(codecSelferC_UTF8100, string(x.RestartReason))
 58914  				}
 58915  			}
 58916  			if yyr2 || yy2arr2 {
 58917  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58918  				yym25 := z.EncBinary()
 58919  				_ = yym25
 58920  				if false {
 58921  				} else {
 58922  					r.EncodeString(codecSelferC_UTF8100, string(x.SetupError))
 58923  				}
 58924  			} else {
 58925  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58926  				r.EncodeString(codecSelferC_UTF8100, string("SetupError"))
 58927  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58928  				yym26 := z.EncBinary()
 58929  				_ = yym26
 58930  				if false {
 58931  				} else {
 58932  					r.EncodeString(codecSelferC_UTF8100, string(x.SetupError))
 58933  				}
 58934  			}
 58935  			if yyr2 || yy2arr2 {
 58936  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58937  				yym28 := z.EncBinary()
 58938  				_ = yym28
 58939  				if false {
 58940  				} else {
 58941  					r.EncodeString(codecSelferC_UTF8100, string(x.DriverError))
 58942  				}
 58943  			} else {
 58944  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58945  				r.EncodeString(codecSelferC_UTF8100, string("DriverError"))
 58946  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58947  				yym29 := z.EncBinary()
 58948  				_ = yym29
 58949  				if false {
 58950  				} else {
 58951  					r.EncodeString(codecSelferC_UTF8100, string(x.DriverError))
 58952  				}
 58953  			}
 58954  			if yyr2 || yy2arr2 {
 58955  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58956  				yym31 := z.EncBinary()
 58957  				_ = yym31
 58958  				if false {
 58959  				} else {
 58960  					r.EncodeInt(int64(x.ExitCode))
 58961  				}
 58962  			} else {
 58963  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58964  				r.EncodeString(codecSelferC_UTF8100, string("ExitCode"))
 58965  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58966  				yym32 := z.EncBinary()
 58967  				_ = yym32
 58968  				if false {
 58969  				} else {
 58970  					r.EncodeInt(int64(x.ExitCode))
 58971  				}
 58972  			}
 58973  			if yyr2 || yy2arr2 {
 58974  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58975  				yym34 := z.EncBinary()
 58976  				_ = yym34
 58977  				if false {
 58978  				} else {
 58979  					r.EncodeInt(int64(x.Signal))
 58980  				}
 58981  			} else {
 58982  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 58983  				r.EncodeString(codecSelferC_UTF8100, string("Signal"))
 58984  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 58985  				yym35 := z.EncBinary()
 58986  				_ = yym35
 58987  				if false {
 58988  				} else {
 58989  					r.EncodeInt(int64(x.Signal))
 58990  				}
 58991  			}
 58992  			if yyr2 || yy2arr2 {
 58993  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 58994  				yym37 := z.EncBinary()
 58995  				_ = yym37
 58996  				if false {
 58997  				} else if z.HasExtensions() && z.EncExt(x.KillTimeout) {
 58998  				} else {
 58999  					r.EncodeInt(int64(x.KillTimeout))
 59000  				}
 59001  			} else {
 59002  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 59003  				r.EncodeString(codecSelferC_UTF8100, string("KillTimeout"))
 59004  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 59005  				yym38 := z.EncBinary()
 59006  				_ = yym38
 59007  				if false {
 59008  				} else if z.HasExtensions() && z.EncExt(x.KillTimeout) {
 59009  				} else {
 59010  					r.EncodeInt(int64(x.KillTimeout))
 59011  				}
 59012  			}
 59013  			if yyr2 || yy2arr2 {
 59014  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 59015  				yym40 := z.EncBinary()
 59016  				_ = yym40
 59017  				if false {
 59018  				} else {
 59019  					r.EncodeString(codecSelferC_UTF8100, string(x.KillError))
 59020  				}
 59021  			} else {
 59022  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 59023  				r.EncodeString(codecSelferC_UTF8100, string("KillError"))
 59024  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 59025  				yym41 := z.EncBinary()
 59026  				_ = yym41
 59027  				if false {
 59028  				} else {
 59029  					r.EncodeString(codecSelferC_UTF8100, string(x.KillError))
 59030  				}
 59031  			}
 59032  			if yyr2 || yy2arr2 {
 59033  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 59034  				yym43 := z.EncBinary()
 59035  				_ = yym43
 59036  				if false {
 59037  				} else {
 59038  					r.EncodeString(codecSelferC_UTF8100, string(x.KillReason))
 59039  				}
 59040  			} else {
 59041  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 59042  				r.EncodeString(codecSelferC_UTF8100, string("KillReason"))
 59043  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 59044  				yym44 := z.EncBinary()
 59045  				_ = yym44
 59046  				if false {
 59047  				} else {
 59048  					r.EncodeString(codecSelferC_UTF8100, string(x.KillReason))
 59049  				}
 59050  			}
 59051  			if yyr2 || yy2arr2 {
 59052  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 59053  				yym46 := z.EncBinary()
 59054  				_ = yym46
 59055  				if false {
 59056  				} else {
 59057  					r.EncodeInt(int64(x.StartDelay))
 59058  				}
 59059  			} else {
 59060  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 59061  				r.EncodeString(codecSelferC_UTF8100, string("StartDelay"))
 59062  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 59063  				yym47 := z.EncBinary()
 59064  				_ = yym47
 59065  				if false {
 59066  				} else {
 59067  					r.EncodeInt(int64(x.StartDelay))
 59068  				}
 59069  			}
 59070  			if yyr2 || yy2arr2 {
 59071  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 59072  				yym49 := z.EncBinary()
 59073  				_ = yym49
 59074  				if false {
 59075  				} else {
 59076  					r.EncodeString(codecSelferC_UTF8100, string(x.DownloadError))
 59077  				}
 59078  			} else {
 59079  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 59080  				r.EncodeString(codecSelferC_UTF8100, string("DownloadError"))
 59081  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 59082  				yym50 := z.EncBinary()
 59083  				_ = yym50
 59084  				if false {
 59085  				} else {
 59086  					r.EncodeString(codecSelferC_UTF8100, string(x.DownloadError))
 59087  				}
 59088  			}
 59089  			if yyr2 || yy2arr2 {
 59090  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 59091  				yym52 := z.EncBinary()
 59092  				_ = yym52
 59093  				if false {
 59094  				} else {
 59095  					r.EncodeString(codecSelferC_UTF8100, string(x.ValidationError))
 59096  				}
 59097  			} else {
 59098  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 59099  				r.EncodeString(codecSelferC_UTF8100, string("ValidationError"))
 59100  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 59101  				yym53 := z.EncBinary()
 59102  				_ = yym53
 59103  				if false {
 59104  				} else {
 59105  					r.EncodeString(codecSelferC_UTF8100, string(x.ValidationError))
 59106  				}
 59107  			}
 59108  			if yyr2 || yy2arr2 {
 59109  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 59110  				yym55 := z.EncBinary()
 59111  				_ = yym55
 59112  				if false {
 59113  				} else {
 59114  					r.EncodeInt(int64(x.DiskLimit))
 59115  				}
 59116  			} else {
 59117  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 59118  				r.EncodeString(codecSelferC_UTF8100, string("DiskLimit"))
 59119  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 59120  				yym56 := z.EncBinary()
 59121  				_ = yym56
 59122  				if false {
 59123  				} else {
 59124  					r.EncodeInt(int64(x.DiskLimit))
 59125  				}
 59126  			}
 59127  			if yyr2 || yy2arr2 {
 59128  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 59129  				yym58 := z.EncBinary()
 59130  				_ = yym58
 59131  				if false {
 59132  				} else {
 59133  					r.EncodeString(codecSelferC_UTF8100, string(x.FailedSibling))
 59134  				}
 59135  			} else {
 59136  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 59137  				r.EncodeString(codecSelferC_UTF8100, string("FailedSibling"))
 59138  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 59139  				yym59 := z.EncBinary()
 59140  				_ = yym59
 59141  				if false {
 59142  				} else {
 59143  					r.EncodeString(codecSelferC_UTF8100, string(x.FailedSibling))
 59144  				}
 59145  			}
 59146  			if yyr2 || yy2arr2 {
 59147  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 59148  				yym61 := z.EncBinary()
 59149  				_ = yym61
 59150  				if false {
 59151  				} else {
 59152  					r.EncodeString(codecSelferC_UTF8100, string(x.VaultError))
 59153  				}
 59154  			} else {
 59155  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 59156  				r.EncodeString(codecSelferC_UTF8100, string("VaultError"))
 59157  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 59158  				yym62 := z.EncBinary()
 59159  				_ = yym62
 59160  				if false {
 59161  				} else {
 59162  					r.EncodeString(codecSelferC_UTF8100, string(x.VaultError))
 59163  				}
 59164  			}
 59165  			if yyr2 || yy2arr2 {
 59166  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 59167  				yym64 := z.EncBinary()
 59168  				_ = yym64
 59169  				if false {
 59170  				} else {
 59171  					r.EncodeString(codecSelferC_UTF8100, string(x.TaskSignalReason))
 59172  				}
 59173  			} else {
 59174  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 59175  				r.EncodeString(codecSelferC_UTF8100, string("TaskSignalReason"))
 59176  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 59177  				yym65 := z.EncBinary()
 59178  				_ = yym65
 59179  				if false {
 59180  				} else {
 59181  					r.EncodeString(codecSelferC_UTF8100, string(x.TaskSignalReason))
 59182  				}
 59183  			}
 59184  			if yyr2 || yy2arr2 {
 59185  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 59186  				yym67 := z.EncBinary()
 59187  				_ = yym67
 59188  				if false {
 59189  				} else {
 59190  					r.EncodeString(codecSelferC_UTF8100, string(x.TaskSignal))
 59191  				}
 59192  			} else {
 59193  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 59194  				r.EncodeString(codecSelferC_UTF8100, string("TaskSignal"))
 59195  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 59196  				yym68 := z.EncBinary()
 59197  				_ = yym68
 59198  				if false {
 59199  				} else {
 59200  					r.EncodeString(codecSelferC_UTF8100, string(x.TaskSignal))
 59201  				}
 59202  			}
 59203  			if yyr2 || yy2arr2 {
 59204  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 59205  				yym70 := z.EncBinary()
 59206  				_ = yym70
 59207  				if false {
 59208  				} else {
 59209  					r.EncodeString(codecSelferC_UTF8100, string(x.DriverMessage))
 59210  				}
 59211  			} else {
 59212  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 59213  				r.EncodeString(codecSelferC_UTF8100, string("DriverMessage"))
 59214  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 59215  				yym71 := z.EncBinary()
 59216  				_ = yym71
 59217  				if false {
 59218  				} else {
 59219  					r.EncodeString(codecSelferC_UTF8100, string(x.DriverMessage))
 59220  				}
 59221  			}
 59222  			if yyr2 || yy2arr2 {
 59223  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 59224  				yym73 := z.EncBinary()
 59225  				_ = yym73
 59226  				if false {
 59227  				} else {
 59228  					r.EncodeString(codecSelferC_UTF8100, string(x.GenericSource))
 59229  				}
 59230  			} else {
 59231  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 59232  				r.EncodeString(codecSelferC_UTF8100, string("GenericSource"))
 59233  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 59234  				yym74 := z.EncBinary()
 59235  				_ = yym74
 59236  				if false {
 59237  				} else {
 59238  					r.EncodeString(codecSelferC_UTF8100, string(x.GenericSource))
 59239  				}
 59240  			}
 59241  			if yyr2 || yy2arr2 {
 59242  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 59243  			} else {
 59244  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 59245  			}
 59246  		}
 59247  	}
 59248  }
 59249  
 59250  func (x *TaskEvent) CodecDecodeSelf(d *codec1978.Decoder) {
 59251  	var h codecSelfer100
 59252  	z, r := codec1978.GenHelperDecoder(d)
 59253  	_, _, _ = h, z, r
 59254  	yym1 := z.DecBinary()
 59255  	_ = yym1
 59256  	if false {
 59257  	} else if z.HasExtensions() && z.DecExt(x) {
 59258  	} else {
 59259  		yyct2 := r.ContainerType()
 59260  		if yyct2 == codecSelferValueTypeMap100 {
 59261  			yyl2 := r.ReadMapStart()
 59262  			if yyl2 == 0 {
 59263  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 59264  			} else {
 59265  				x.codecDecodeSelfFromMap(yyl2, d)
 59266  			}
 59267  		} else if yyct2 == codecSelferValueTypeArray100 {
 59268  			yyl2 := r.ReadArrayStart()
 59269  			if yyl2 == 0 {
 59270  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59271  			} else {
 59272  				x.codecDecodeSelfFromArray(yyl2, d)
 59273  			}
 59274  		} else {
 59275  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 59276  		}
 59277  	}
 59278  }
 59279  
 59280  func (x *TaskEvent) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 59281  	var h codecSelfer100
 59282  	z, r := codec1978.GenHelperDecoder(d)
 59283  	_, _, _ = h, z, r
 59284  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 59285  	_ = yys3Slc
 59286  	var yyhl3 bool = l >= 0
 59287  	for yyj3 := 0; ; yyj3++ {
 59288  		if yyhl3 {
 59289  			if yyj3 >= l {
 59290  				break
 59291  			}
 59292  		} else {
 59293  			if r.CheckBreak() {
 59294  				break
 59295  			}
 59296  		}
 59297  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 59298  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 59299  		yys3 := string(yys3Slc)
 59300  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 59301  		switch yys3 {
 59302  		case "Type":
 59303  			if r.TryDecodeAsNil() {
 59304  				x.Type = ""
 59305  			} else {
 59306  				yyv4 := &x.Type
 59307  				yym5 := z.DecBinary()
 59308  				_ = yym5
 59309  				if false {
 59310  				} else {
 59311  					*((*string)(yyv4)) = r.DecodeString()
 59312  				}
 59313  			}
 59314  		case "Time":
 59315  			if r.TryDecodeAsNil() {
 59316  				x.Time = 0
 59317  			} else {
 59318  				yyv6 := &x.Time
 59319  				yym7 := z.DecBinary()
 59320  				_ = yym7
 59321  				if false {
 59322  				} else {
 59323  					*((*int64)(yyv6)) = int64(r.DecodeInt(64))
 59324  				}
 59325  			}
 59326  		case "Message":
 59327  			if r.TryDecodeAsNil() {
 59328  				x.Message = ""
 59329  			} else {
 59330  				yyv8 := &x.Message
 59331  				yym9 := z.DecBinary()
 59332  				_ = yym9
 59333  				if false {
 59334  				} else {
 59335  					*((*string)(yyv8)) = r.DecodeString()
 59336  				}
 59337  			}
 59338  		case "DisplayMessage":
 59339  			if r.TryDecodeAsNil() {
 59340  				x.DisplayMessage = ""
 59341  			} else {
 59342  				yyv10 := &x.DisplayMessage
 59343  				yym11 := z.DecBinary()
 59344  				_ = yym11
 59345  				if false {
 59346  				} else {
 59347  					*((*string)(yyv10)) = r.DecodeString()
 59348  				}
 59349  			}
 59350  		case "Details":
 59351  			if r.TryDecodeAsNil() {
 59352  				x.Details = nil
 59353  			} else {
 59354  				yyv12 := &x.Details
 59355  				yym13 := z.DecBinary()
 59356  				_ = yym13
 59357  				if false {
 59358  				} else {
 59359  					z.F.DecMapStringStringX(yyv12, false, d)
 59360  				}
 59361  			}
 59362  		case "FailsTask":
 59363  			if r.TryDecodeAsNil() {
 59364  				x.FailsTask = false
 59365  			} else {
 59366  				yyv14 := &x.FailsTask
 59367  				yym15 := z.DecBinary()
 59368  				_ = yym15
 59369  				if false {
 59370  				} else {
 59371  					*((*bool)(yyv14)) = r.DecodeBool()
 59372  				}
 59373  			}
 59374  		case "RestartReason":
 59375  			if r.TryDecodeAsNil() {
 59376  				x.RestartReason = ""
 59377  			} else {
 59378  				yyv16 := &x.RestartReason
 59379  				yym17 := z.DecBinary()
 59380  				_ = yym17
 59381  				if false {
 59382  				} else {
 59383  					*((*string)(yyv16)) = r.DecodeString()
 59384  				}
 59385  			}
 59386  		case "SetupError":
 59387  			if r.TryDecodeAsNil() {
 59388  				x.SetupError = ""
 59389  			} else {
 59390  				yyv18 := &x.SetupError
 59391  				yym19 := z.DecBinary()
 59392  				_ = yym19
 59393  				if false {
 59394  				} else {
 59395  					*((*string)(yyv18)) = r.DecodeString()
 59396  				}
 59397  			}
 59398  		case "DriverError":
 59399  			if r.TryDecodeAsNil() {
 59400  				x.DriverError = ""
 59401  			} else {
 59402  				yyv20 := &x.DriverError
 59403  				yym21 := z.DecBinary()
 59404  				_ = yym21
 59405  				if false {
 59406  				} else {
 59407  					*((*string)(yyv20)) = r.DecodeString()
 59408  				}
 59409  			}
 59410  		case "ExitCode":
 59411  			if r.TryDecodeAsNil() {
 59412  				x.ExitCode = 0
 59413  			} else {
 59414  				yyv22 := &x.ExitCode
 59415  				yym23 := z.DecBinary()
 59416  				_ = yym23
 59417  				if false {
 59418  				} else {
 59419  					*((*int)(yyv22)) = int(r.DecodeInt(codecSelferBitsize100))
 59420  				}
 59421  			}
 59422  		case "Signal":
 59423  			if r.TryDecodeAsNil() {
 59424  				x.Signal = 0
 59425  			} else {
 59426  				yyv24 := &x.Signal
 59427  				yym25 := z.DecBinary()
 59428  				_ = yym25
 59429  				if false {
 59430  				} else {
 59431  					*((*int)(yyv24)) = int(r.DecodeInt(codecSelferBitsize100))
 59432  				}
 59433  			}
 59434  		case "KillTimeout":
 59435  			if r.TryDecodeAsNil() {
 59436  				x.KillTimeout = 0
 59437  			} else {
 59438  				yyv26 := &x.KillTimeout
 59439  				yym27 := z.DecBinary()
 59440  				_ = yym27
 59441  				if false {
 59442  				} else if z.HasExtensions() && z.DecExt(yyv26) {
 59443  				} else {
 59444  					*((*int64)(yyv26)) = int64(r.DecodeInt(64))
 59445  				}
 59446  			}
 59447  		case "KillError":
 59448  			if r.TryDecodeAsNil() {
 59449  				x.KillError = ""
 59450  			} else {
 59451  				yyv28 := &x.KillError
 59452  				yym29 := z.DecBinary()
 59453  				_ = yym29
 59454  				if false {
 59455  				} else {
 59456  					*((*string)(yyv28)) = r.DecodeString()
 59457  				}
 59458  			}
 59459  		case "KillReason":
 59460  			if r.TryDecodeAsNil() {
 59461  				x.KillReason = ""
 59462  			} else {
 59463  				yyv30 := &x.KillReason
 59464  				yym31 := z.DecBinary()
 59465  				_ = yym31
 59466  				if false {
 59467  				} else {
 59468  					*((*string)(yyv30)) = r.DecodeString()
 59469  				}
 59470  			}
 59471  		case "StartDelay":
 59472  			if r.TryDecodeAsNil() {
 59473  				x.StartDelay = 0
 59474  			} else {
 59475  				yyv32 := &x.StartDelay
 59476  				yym33 := z.DecBinary()
 59477  				_ = yym33
 59478  				if false {
 59479  				} else {
 59480  					*((*int64)(yyv32)) = int64(r.DecodeInt(64))
 59481  				}
 59482  			}
 59483  		case "DownloadError":
 59484  			if r.TryDecodeAsNil() {
 59485  				x.DownloadError = ""
 59486  			} else {
 59487  				yyv34 := &x.DownloadError
 59488  				yym35 := z.DecBinary()
 59489  				_ = yym35
 59490  				if false {
 59491  				} else {
 59492  					*((*string)(yyv34)) = r.DecodeString()
 59493  				}
 59494  			}
 59495  		case "ValidationError":
 59496  			if r.TryDecodeAsNil() {
 59497  				x.ValidationError = ""
 59498  			} else {
 59499  				yyv36 := &x.ValidationError
 59500  				yym37 := z.DecBinary()
 59501  				_ = yym37
 59502  				if false {
 59503  				} else {
 59504  					*((*string)(yyv36)) = r.DecodeString()
 59505  				}
 59506  			}
 59507  		case "DiskLimit":
 59508  			if r.TryDecodeAsNil() {
 59509  				x.DiskLimit = 0
 59510  			} else {
 59511  				yyv38 := &x.DiskLimit
 59512  				yym39 := z.DecBinary()
 59513  				_ = yym39
 59514  				if false {
 59515  				} else {
 59516  					*((*int64)(yyv38)) = int64(r.DecodeInt(64))
 59517  				}
 59518  			}
 59519  		case "FailedSibling":
 59520  			if r.TryDecodeAsNil() {
 59521  				x.FailedSibling = ""
 59522  			} else {
 59523  				yyv40 := &x.FailedSibling
 59524  				yym41 := z.DecBinary()
 59525  				_ = yym41
 59526  				if false {
 59527  				} else {
 59528  					*((*string)(yyv40)) = r.DecodeString()
 59529  				}
 59530  			}
 59531  		case "VaultError":
 59532  			if r.TryDecodeAsNil() {
 59533  				x.VaultError = ""
 59534  			} else {
 59535  				yyv42 := &x.VaultError
 59536  				yym43 := z.DecBinary()
 59537  				_ = yym43
 59538  				if false {
 59539  				} else {
 59540  					*((*string)(yyv42)) = r.DecodeString()
 59541  				}
 59542  			}
 59543  		case "TaskSignalReason":
 59544  			if r.TryDecodeAsNil() {
 59545  				x.TaskSignalReason = ""
 59546  			} else {
 59547  				yyv44 := &x.TaskSignalReason
 59548  				yym45 := z.DecBinary()
 59549  				_ = yym45
 59550  				if false {
 59551  				} else {
 59552  					*((*string)(yyv44)) = r.DecodeString()
 59553  				}
 59554  			}
 59555  		case "TaskSignal":
 59556  			if r.TryDecodeAsNil() {
 59557  				x.TaskSignal = ""
 59558  			} else {
 59559  				yyv46 := &x.TaskSignal
 59560  				yym47 := z.DecBinary()
 59561  				_ = yym47
 59562  				if false {
 59563  				} else {
 59564  					*((*string)(yyv46)) = r.DecodeString()
 59565  				}
 59566  			}
 59567  		case "DriverMessage":
 59568  			if r.TryDecodeAsNil() {
 59569  				x.DriverMessage = ""
 59570  			} else {
 59571  				yyv48 := &x.DriverMessage
 59572  				yym49 := z.DecBinary()
 59573  				_ = yym49
 59574  				if false {
 59575  				} else {
 59576  					*((*string)(yyv48)) = r.DecodeString()
 59577  				}
 59578  			}
 59579  		case "GenericSource":
 59580  			if r.TryDecodeAsNil() {
 59581  				x.GenericSource = ""
 59582  			} else {
 59583  				yyv50 := &x.GenericSource
 59584  				yym51 := z.DecBinary()
 59585  				_ = yym51
 59586  				if false {
 59587  				} else {
 59588  					*((*string)(yyv50)) = r.DecodeString()
 59589  				}
 59590  			}
 59591  		default:
 59592  			z.DecStructFieldNotFound(-1, yys3)
 59593  		} // end switch yys3
 59594  	} // end for yyj3
 59595  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 59596  }
 59597  
 59598  func (x *TaskEvent) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 59599  	var h codecSelfer100
 59600  	z, r := codec1978.GenHelperDecoder(d)
 59601  	_, _, _ = h, z, r
 59602  	var yyj52 int
 59603  	var yyb52 bool
 59604  	var yyhl52 bool = l >= 0
 59605  	yyj52++
 59606  	if yyhl52 {
 59607  		yyb52 = yyj52 > l
 59608  	} else {
 59609  		yyb52 = r.CheckBreak()
 59610  	}
 59611  	if yyb52 {
 59612  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59613  		return
 59614  	}
 59615  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59616  	if r.TryDecodeAsNil() {
 59617  		x.Type = ""
 59618  	} else {
 59619  		yyv53 := &x.Type
 59620  		yym54 := z.DecBinary()
 59621  		_ = yym54
 59622  		if false {
 59623  		} else {
 59624  			*((*string)(yyv53)) = r.DecodeString()
 59625  		}
 59626  	}
 59627  	yyj52++
 59628  	if yyhl52 {
 59629  		yyb52 = yyj52 > l
 59630  	} else {
 59631  		yyb52 = r.CheckBreak()
 59632  	}
 59633  	if yyb52 {
 59634  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59635  		return
 59636  	}
 59637  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59638  	if r.TryDecodeAsNil() {
 59639  		x.Time = 0
 59640  	} else {
 59641  		yyv55 := &x.Time
 59642  		yym56 := z.DecBinary()
 59643  		_ = yym56
 59644  		if false {
 59645  		} else {
 59646  			*((*int64)(yyv55)) = int64(r.DecodeInt(64))
 59647  		}
 59648  	}
 59649  	yyj52++
 59650  	if yyhl52 {
 59651  		yyb52 = yyj52 > l
 59652  	} else {
 59653  		yyb52 = r.CheckBreak()
 59654  	}
 59655  	if yyb52 {
 59656  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59657  		return
 59658  	}
 59659  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59660  	if r.TryDecodeAsNil() {
 59661  		x.Message = ""
 59662  	} else {
 59663  		yyv57 := &x.Message
 59664  		yym58 := z.DecBinary()
 59665  		_ = yym58
 59666  		if false {
 59667  		} else {
 59668  			*((*string)(yyv57)) = r.DecodeString()
 59669  		}
 59670  	}
 59671  	yyj52++
 59672  	if yyhl52 {
 59673  		yyb52 = yyj52 > l
 59674  	} else {
 59675  		yyb52 = r.CheckBreak()
 59676  	}
 59677  	if yyb52 {
 59678  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59679  		return
 59680  	}
 59681  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59682  	if r.TryDecodeAsNil() {
 59683  		x.DisplayMessage = ""
 59684  	} else {
 59685  		yyv59 := &x.DisplayMessage
 59686  		yym60 := z.DecBinary()
 59687  		_ = yym60
 59688  		if false {
 59689  		} else {
 59690  			*((*string)(yyv59)) = r.DecodeString()
 59691  		}
 59692  	}
 59693  	yyj52++
 59694  	if yyhl52 {
 59695  		yyb52 = yyj52 > l
 59696  	} else {
 59697  		yyb52 = r.CheckBreak()
 59698  	}
 59699  	if yyb52 {
 59700  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59701  		return
 59702  	}
 59703  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59704  	if r.TryDecodeAsNil() {
 59705  		x.Details = nil
 59706  	} else {
 59707  		yyv61 := &x.Details
 59708  		yym62 := z.DecBinary()
 59709  		_ = yym62
 59710  		if false {
 59711  		} else {
 59712  			z.F.DecMapStringStringX(yyv61, false, d)
 59713  		}
 59714  	}
 59715  	yyj52++
 59716  	if yyhl52 {
 59717  		yyb52 = yyj52 > l
 59718  	} else {
 59719  		yyb52 = r.CheckBreak()
 59720  	}
 59721  	if yyb52 {
 59722  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59723  		return
 59724  	}
 59725  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59726  	if r.TryDecodeAsNil() {
 59727  		x.FailsTask = false
 59728  	} else {
 59729  		yyv63 := &x.FailsTask
 59730  		yym64 := z.DecBinary()
 59731  		_ = yym64
 59732  		if false {
 59733  		} else {
 59734  			*((*bool)(yyv63)) = r.DecodeBool()
 59735  		}
 59736  	}
 59737  	yyj52++
 59738  	if yyhl52 {
 59739  		yyb52 = yyj52 > l
 59740  	} else {
 59741  		yyb52 = r.CheckBreak()
 59742  	}
 59743  	if yyb52 {
 59744  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59745  		return
 59746  	}
 59747  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59748  	if r.TryDecodeAsNil() {
 59749  		x.RestartReason = ""
 59750  	} else {
 59751  		yyv65 := &x.RestartReason
 59752  		yym66 := z.DecBinary()
 59753  		_ = yym66
 59754  		if false {
 59755  		} else {
 59756  			*((*string)(yyv65)) = r.DecodeString()
 59757  		}
 59758  	}
 59759  	yyj52++
 59760  	if yyhl52 {
 59761  		yyb52 = yyj52 > l
 59762  	} else {
 59763  		yyb52 = r.CheckBreak()
 59764  	}
 59765  	if yyb52 {
 59766  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59767  		return
 59768  	}
 59769  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59770  	if r.TryDecodeAsNil() {
 59771  		x.SetupError = ""
 59772  	} else {
 59773  		yyv67 := &x.SetupError
 59774  		yym68 := z.DecBinary()
 59775  		_ = yym68
 59776  		if false {
 59777  		} else {
 59778  			*((*string)(yyv67)) = r.DecodeString()
 59779  		}
 59780  	}
 59781  	yyj52++
 59782  	if yyhl52 {
 59783  		yyb52 = yyj52 > l
 59784  	} else {
 59785  		yyb52 = r.CheckBreak()
 59786  	}
 59787  	if yyb52 {
 59788  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59789  		return
 59790  	}
 59791  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59792  	if r.TryDecodeAsNil() {
 59793  		x.DriverError = ""
 59794  	} else {
 59795  		yyv69 := &x.DriverError
 59796  		yym70 := z.DecBinary()
 59797  		_ = yym70
 59798  		if false {
 59799  		} else {
 59800  			*((*string)(yyv69)) = r.DecodeString()
 59801  		}
 59802  	}
 59803  	yyj52++
 59804  	if yyhl52 {
 59805  		yyb52 = yyj52 > l
 59806  	} else {
 59807  		yyb52 = r.CheckBreak()
 59808  	}
 59809  	if yyb52 {
 59810  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59811  		return
 59812  	}
 59813  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59814  	if r.TryDecodeAsNil() {
 59815  		x.ExitCode = 0
 59816  	} else {
 59817  		yyv71 := &x.ExitCode
 59818  		yym72 := z.DecBinary()
 59819  		_ = yym72
 59820  		if false {
 59821  		} else {
 59822  			*((*int)(yyv71)) = int(r.DecodeInt(codecSelferBitsize100))
 59823  		}
 59824  	}
 59825  	yyj52++
 59826  	if yyhl52 {
 59827  		yyb52 = yyj52 > l
 59828  	} else {
 59829  		yyb52 = r.CheckBreak()
 59830  	}
 59831  	if yyb52 {
 59832  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59833  		return
 59834  	}
 59835  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59836  	if r.TryDecodeAsNil() {
 59837  		x.Signal = 0
 59838  	} else {
 59839  		yyv73 := &x.Signal
 59840  		yym74 := z.DecBinary()
 59841  		_ = yym74
 59842  		if false {
 59843  		} else {
 59844  			*((*int)(yyv73)) = int(r.DecodeInt(codecSelferBitsize100))
 59845  		}
 59846  	}
 59847  	yyj52++
 59848  	if yyhl52 {
 59849  		yyb52 = yyj52 > l
 59850  	} else {
 59851  		yyb52 = r.CheckBreak()
 59852  	}
 59853  	if yyb52 {
 59854  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59855  		return
 59856  	}
 59857  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59858  	if r.TryDecodeAsNil() {
 59859  		x.KillTimeout = 0
 59860  	} else {
 59861  		yyv75 := &x.KillTimeout
 59862  		yym76 := z.DecBinary()
 59863  		_ = yym76
 59864  		if false {
 59865  		} else if z.HasExtensions() && z.DecExt(yyv75) {
 59866  		} else {
 59867  			*((*int64)(yyv75)) = int64(r.DecodeInt(64))
 59868  		}
 59869  	}
 59870  	yyj52++
 59871  	if yyhl52 {
 59872  		yyb52 = yyj52 > l
 59873  	} else {
 59874  		yyb52 = r.CheckBreak()
 59875  	}
 59876  	if yyb52 {
 59877  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59878  		return
 59879  	}
 59880  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59881  	if r.TryDecodeAsNil() {
 59882  		x.KillError = ""
 59883  	} else {
 59884  		yyv77 := &x.KillError
 59885  		yym78 := z.DecBinary()
 59886  		_ = yym78
 59887  		if false {
 59888  		} else {
 59889  			*((*string)(yyv77)) = r.DecodeString()
 59890  		}
 59891  	}
 59892  	yyj52++
 59893  	if yyhl52 {
 59894  		yyb52 = yyj52 > l
 59895  	} else {
 59896  		yyb52 = r.CheckBreak()
 59897  	}
 59898  	if yyb52 {
 59899  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59900  		return
 59901  	}
 59902  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59903  	if r.TryDecodeAsNil() {
 59904  		x.KillReason = ""
 59905  	} else {
 59906  		yyv79 := &x.KillReason
 59907  		yym80 := z.DecBinary()
 59908  		_ = yym80
 59909  		if false {
 59910  		} else {
 59911  			*((*string)(yyv79)) = r.DecodeString()
 59912  		}
 59913  	}
 59914  	yyj52++
 59915  	if yyhl52 {
 59916  		yyb52 = yyj52 > l
 59917  	} else {
 59918  		yyb52 = r.CheckBreak()
 59919  	}
 59920  	if yyb52 {
 59921  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59922  		return
 59923  	}
 59924  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59925  	if r.TryDecodeAsNil() {
 59926  		x.StartDelay = 0
 59927  	} else {
 59928  		yyv81 := &x.StartDelay
 59929  		yym82 := z.DecBinary()
 59930  		_ = yym82
 59931  		if false {
 59932  		} else {
 59933  			*((*int64)(yyv81)) = int64(r.DecodeInt(64))
 59934  		}
 59935  	}
 59936  	yyj52++
 59937  	if yyhl52 {
 59938  		yyb52 = yyj52 > l
 59939  	} else {
 59940  		yyb52 = r.CheckBreak()
 59941  	}
 59942  	if yyb52 {
 59943  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59944  		return
 59945  	}
 59946  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59947  	if r.TryDecodeAsNil() {
 59948  		x.DownloadError = ""
 59949  	} else {
 59950  		yyv83 := &x.DownloadError
 59951  		yym84 := z.DecBinary()
 59952  		_ = yym84
 59953  		if false {
 59954  		} else {
 59955  			*((*string)(yyv83)) = r.DecodeString()
 59956  		}
 59957  	}
 59958  	yyj52++
 59959  	if yyhl52 {
 59960  		yyb52 = yyj52 > l
 59961  	} else {
 59962  		yyb52 = r.CheckBreak()
 59963  	}
 59964  	if yyb52 {
 59965  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59966  		return
 59967  	}
 59968  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59969  	if r.TryDecodeAsNil() {
 59970  		x.ValidationError = ""
 59971  	} else {
 59972  		yyv85 := &x.ValidationError
 59973  		yym86 := z.DecBinary()
 59974  		_ = yym86
 59975  		if false {
 59976  		} else {
 59977  			*((*string)(yyv85)) = r.DecodeString()
 59978  		}
 59979  	}
 59980  	yyj52++
 59981  	if yyhl52 {
 59982  		yyb52 = yyj52 > l
 59983  	} else {
 59984  		yyb52 = r.CheckBreak()
 59985  	}
 59986  	if yyb52 {
 59987  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 59988  		return
 59989  	}
 59990  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 59991  	if r.TryDecodeAsNil() {
 59992  		x.DiskLimit = 0
 59993  	} else {
 59994  		yyv87 := &x.DiskLimit
 59995  		yym88 := z.DecBinary()
 59996  		_ = yym88
 59997  		if false {
 59998  		} else {
 59999  			*((*int64)(yyv87)) = int64(r.DecodeInt(64))
 60000  		}
 60001  	}
 60002  	yyj52++
 60003  	if yyhl52 {
 60004  		yyb52 = yyj52 > l
 60005  	} else {
 60006  		yyb52 = r.CheckBreak()
 60007  	}
 60008  	if yyb52 {
 60009  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60010  		return
 60011  	}
 60012  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60013  	if r.TryDecodeAsNil() {
 60014  		x.FailedSibling = ""
 60015  	} else {
 60016  		yyv89 := &x.FailedSibling
 60017  		yym90 := z.DecBinary()
 60018  		_ = yym90
 60019  		if false {
 60020  		} else {
 60021  			*((*string)(yyv89)) = r.DecodeString()
 60022  		}
 60023  	}
 60024  	yyj52++
 60025  	if yyhl52 {
 60026  		yyb52 = yyj52 > l
 60027  	} else {
 60028  		yyb52 = r.CheckBreak()
 60029  	}
 60030  	if yyb52 {
 60031  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60032  		return
 60033  	}
 60034  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60035  	if r.TryDecodeAsNil() {
 60036  		x.VaultError = ""
 60037  	} else {
 60038  		yyv91 := &x.VaultError
 60039  		yym92 := z.DecBinary()
 60040  		_ = yym92
 60041  		if false {
 60042  		} else {
 60043  			*((*string)(yyv91)) = r.DecodeString()
 60044  		}
 60045  	}
 60046  	yyj52++
 60047  	if yyhl52 {
 60048  		yyb52 = yyj52 > l
 60049  	} else {
 60050  		yyb52 = r.CheckBreak()
 60051  	}
 60052  	if yyb52 {
 60053  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60054  		return
 60055  	}
 60056  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60057  	if r.TryDecodeAsNil() {
 60058  		x.TaskSignalReason = ""
 60059  	} else {
 60060  		yyv93 := &x.TaskSignalReason
 60061  		yym94 := z.DecBinary()
 60062  		_ = yym94
 60063  		if false {
 60064  		} else {
 60065  			*((*string)(yyv93)) = r.DecodeString()
 60066  		}
 60067  	}
 60068  	yyj52++
 60069  	if yyhl52 {
 60070  		yyb52 = yyj52 > l
 60071  	} else {
 60072  		yyb52 = r.CheckBreak()
 60073  	}
 60074  	if yyb52 {
 60075  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60076  		return
 60077  	}
 60078  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60079  	if r.TryDecodeAsNil() {
 60080  		x.TaskSignal = ""
 60081  	} else {
 60082  		yyv95 := &x.TaskSignal
 60083  		yym96 := z.DecBinary()
 60084  		_ = yym96
 60085  		if false {
 60086  		} else {
 60087  			*((*string)(yyv95)) = r.DecodeString()
 60088  		}
 60089  	}
 60090  	yyj52++
 60091  	if yyhl52 {
 60092  		yyb52 = yyj52 > l
 60093  	} else {
 60094  		yyb52 = r.CheckBreak()
 60095  	}
 60096  	if yyb52 {
 60097  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60098  		return
 60099  	}
 60100  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60101  	if r.TryDecodeAsNil() {
 60102  		x.DriverMessage = ""
 60103  	} else {
 60104  		yyv97 := &x.DriverMessage
 60105  		yym98 := z.DecBinary()
 60106  		_ = yym98
 60107  		if false {
 60108  		} else {
 60109  			*((*string)(yyv97)) = r.DecodeString()
 60110  		}
 60111  	}
 60112  	yyj52++
 60113  	if yyhl52 {
 60114  		yyb52 = yyj52 > l
 60115  	} else {
 60116  		yyb52 = r.CheckBreak()
 60117  	}
 60118  	if yyb52 {
 60119  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60120  		return
 60121  	}
 60122  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60123  	if r.TryDecodeAsNil() {
 60124  		x.GenericSource = ""
 60125  	} else {
 60126  		yyv99 := &x.GenericSource
 60127  		yym100 := z.DecBinary()
 60128  		_ = yym100
 60129  		if false {
 60130  		} else {
 60131  			*((*string)(yyv99)) = r.DecodeString()
 60132  		}
 60133  	}
 60134  	for {
 60135  		yyj52++
 60136  		if yyhl52 {
 60137  			yyb52 = yyj52 > l
 60138  		} else {
 60139  			yyb52 = r.CheckBreak()
 60140  		}
 60141  		if yyb52 {
 60142  			break
 60143  		}
 60144  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60145  		z.DecStructFieldNotFound(yyj52-1, "")
 60146  	}
 60147  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60148  }
 60149  
 60150  func (x *TaskArtifact) CodecEncodeSelf(e *codec1978.Encoder) {
 60151  	var h codecSelfer100
 60152  	z, r := codec1978.GenHelperEncoder(e)
 60153  	_, _, _ = h, z, r
 60154  	if x == nil {
 60155  		r.EncodeNil()
 60156  	} else {
 60157  		yym1 := z.EncBinary()
 60158  		_ = yym1
 60159  		if false {
 60160  		} else if z.HasExtensions() && z.EncExt(x) {
 60161  		} else {
 60162  			yysep2 := !z.EncBinary()
 60163  			yy2arr2 := z.EncBasicHandle().StructToArray
 60164  			var yyq2 [4]bool
 60165  			_, _, _ = yysep2, yyq2, yy2arr2
 60166  			const yyr2 bool = false
 60167  			var yynn2 int
 60168  			if yyr2 || yy2arr2 {
 60169  				r.EncodeArrayStart(4)
 60170  			} else {
 60171  				yynn2 = 4
 60172  				for _, b := range yyq2 {
 60173  					if b {
 60174  						yynn2++
 60175  					}
 60176  				}
 60177  				r.EncodeMapStart(yynn2)
 60178  				yynn2 = 0
 60179  			}
 60180  			if yyr2 || yy2arr2 {
 60181  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 60182  				yym4 := z.EncBinary()
 60183  				_ = yym4
 60184  				if false {
 60185  				} else {
 60186  					r.EncodeString(codecSelferC_UTF8100, string(x.GetterSource))
 60187  				}
 60188  			} else {
 60189  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 60190  				r.EncodeString(codecSelferC_UTF8100, string("GetterSource"))
 60191  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 60192  				yym5 := z.EncBinary()
 60193  				_ = yym5
 60194  				if false {
 60195  				} else {
 60196  					r.EncodeString(codecSelferC_UTF8100, string(x.GetterSource))
 60197  				}
 60198  			}
 60199  			if yyr2 || yy2arr2 {
 60200  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 60201  				if x.GetterOptions == nil {
 60202  					r.EncodeNil()
 60203  				} else {
 60204  					yym7 := z.EncBinary()
 60205  					_ = yym7
 60206  					if false {
 60207  					} else {
 60208  						z.F.EncMapStringStringV(x.GetterOptions, false, e)
 60209  					}
 60210  				}
 60211  			} else {
 60212  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 60213  				r.EncodeString(codecSelferC_UTF8100, string("GetterOptions"))
 60214  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 60215  				if x.GetterOptions == nil {
 60216  					r.EncodeNil()
 60217  				} else {
 60218  					yym8 := z.EncBinary()
 60219  					_ = yym8
 60220  					if false {
 60221  					} else {
 60222  						z.F.EncMapStringStringV(x.GetterOptions, false, e)
 60223  					}
 60224  				}
 60225  			}
 60226  			if yyr2 || yy2arr2 {
 60227  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 60228  				yym10 := z.EncBinary()
 60229  				_ = yym10
 60230  				if false {
 60231  				} else {
 60232  					r.EncodeString(codecSelferC_UTF8100, string(x.GetterMode))
 60233  				}
 60234  			} else {
 60235  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 60236  				r.EncodeString(codecSelferC_UTF8100, string("GetterMode"))
 60237  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 60238  				yym11 := z.EncBinary()
 60239  				_ = yym11
 60240  				if false {
 60241  				} else {
 60242  					r.EncodeString(codecSelferC_UTF8100, string(x.GetterMode))
 60243  				}
 60244  			}
 60245  			if yyr2 || yy2arr2 {
 60246  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 60247  				yym13 := z.EncBinary()
 60248  				_ = yym13
 60249  				if false {
 60250  				} else {
 60251  					r.EncodeString(codecSelferC_UTF8100, string(x.RelativeDest))
 60252  				}
 60253  			} else {
 60254  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 60255  				r.EncodeString(codecSelferC_UTF8100, string("RelativeDest"))
 60256  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 60257  				yym14 := z.EncBinary()
 60258  				_ = yym14
 60259  				if false {
 60260  				} else {
 60261  					r.EncodeString(codecSelferC_UTF8100, string(x.RelativeDest))
 60262  				}
 60263  			}
 60264  			if yyr2 || yy2arr2 {
 60265  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 60266  			} else {
 60267  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 60268  			}
 60269  		}
 60270  	}
 60271  }
 60272  
 60273  func (x *TaskArtifact) CodecDecodeSelf(d *codec1978.Decoder) {
 60274  	var h codecSelfer100
 60275  	z, r := codec1978.GenHelperDecoder(d)
 60276  	_, _, _ = h, z, r
 60277  	yym1 := z.DecBinary()
 60278  	_ = yym1
 60279  	if false {
 60280  	} else if z.HasExtensions() && z.DecExt(x) {
 60281  	} else {
 60282  		yyct2 := r.ContainerType()
 60283  		if yyct2 == codecSelferValueTypeMap100 {
 60284  			yyl2 := r.ReadMapStart()
 60285  			if yyl2 == 0 {
 60286  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 60287  			} else {
 60288  				x.codecDecodeSelfFromMap(yyl2, d)
 60289  			}
 60290  		} else if yyct2 == codecSelferValueTypeArray100 {
 60291  			yyl2 := r.ReadArrayStart()
 60292  			if yyl2 == 0 {
 60293  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60294  			} else {
 60295  				x.codecDecodeSelfFromArray(yyl2, d)
 60296  			}
 60297  		} else {
 60298  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 60299  		}
 60300  	}
 60301  }
 60302  
 60303  func (x *TaskArtifact) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 60304  	var h codecSelfer100
 60305  	z, r := codec1978.GenHelperDecoder(d)
 60306  	_, _, _ = h, z, r
 60307  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 60308  	_ = yys3Slc
 60309  	var yyhl3 bool = l >= 0
 60310  	for yyj3 := 0; ; yyj3++ {
 60311  		if yyhl3 {
 60312  			if yyj3 >= l {
 60313  				break
 60314  			}
 60315  		} else {
 60316  			if r.CheckBreak() {
 60317  				break
 60318  			}
 60319  		}
 60320  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 60321  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 60322  		yys3 := string(yys3Slc)
 60323  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 60324  		switch yys3 {
 60325  		case "GetterSource":
 60326  			if r.TryDecodeAsNil() {
 60327  				x.GetterSource = ""
 60328  			} else {
 60329  				yyv4 := &x.GetterSource
 60330  				yym5 := z.DecBinary()
 60331  				_ = yym5
 60332  				if false {
 60333  				} else {
 60334  					*((*string)(yyv4)) = r.DecodeString()
 60335  				}
 60336  			}
 60337  		case "GetterOptions":
 60338  			if r.TryDecodeAsNil() {
 60339  				x.GetterOptions = nil
 60340  			} else {
 60341  				yyv6 := &x.GetterOptions
 60342  				yym7 := z.DecBinary()
 60343  				_ = yym7
 60344  				if false {
 60345  				} else {
 60346  					z.F.DecMapStringStringX(yyv6, false, d)
 60347  				}
 60348  			}
 60349  		case "GetterMode":
 60350  			if r.TryDecodeAsNil() {
 60351  				x.GetterMode = ""
 60352  			} else {
 60353  				yyv8 := &x.GetterMode
 60354  				yym9 := z.DecBinary()
 60355  				_ = yym9
 60356  				if false {
 60357  				} else {
 60358  					*((*string)(yyv8)) = r.DecodeString()
 60359  				}
 60360  			}
 60361  		case "RelativeDest":
 60362  			if r.TryDecodeAsNil() {
 60363  				x.RelativeDest = ""
 60364  			} else {
 60365  				yyv10 := &x.RelativeDest
 60366  				yym11 := z.DecBinary()
 60367  				_ = yym11
 60368  				if false {
 60369  				} else {
 60370  					*((*string)(yyv10)) = r.DecodeString()
 60371  				}
 60372  			}
 60373  		default:
 60374  			z.DecStructFieldNotFound(-1, yys3)
 60375  		} // end switch yys3
 60376  	} // end for yyj3
 60377  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 60378  }
 60379  
 60380  func (x *TaskArtifact) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 60381  	var h codecSelfer100
 60382  	z, r := codec1978.GenHelperDecoder(d)
 60383  	_, _, _ = h, z, r
 60384  	var yyj12 int
 60385  	var yyb12 bool
 60386  	var yyhl12 bool = l >= 0
 60387  	yyj12++
 60388  	if yyhl12 {
 60389  		yyb12 = yyj12 > l
 60390  	} else {
 60391  		yyb12 = r.CheckBreak()
 60392  	}
 60393  	if yyb12 {
 60394  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60395  		return
 60396  	}
 60397  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60398  	if r.TryDecodeAsNil() {
 60399  		x.GetterSource = ""
 60400  	} else {
 60401  		yyv13 := &x.GetterSource
 60402  		yym14 := z.DecBinary()
 60403  		_ = yym14
 60404  		if false {
 60405  		} else {
 60406  			*((*string)(yyv13)) = r.DecodeString()
 60407  		}
 60408  	}
 60409  	yyj12++
 60410  	if yyhl12 {
 60411  		yyb12 = yyj12 > l
 60412  	} else {
 60413  		yyb12 = r.CheckBreak()
 60414  	}
 60415  	if yyb12 {
 60416  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60417  		return
 60418  	}
 60419  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60420  	if r.TryDecodeAsNil() {
 60421  		x.GetterOptions = nil
 60422  	} else {
 60423  		yyv15 := &x.GetterOptions
 60424  		yym16 := z.DecBinary()
 60425  		_ = yym16
 60426  		if false {
 60427  		} else {
 60428  			z.F.DecMapStringStringX(yyv15, false, d)
 60429  		}
 60430  	}
 60431  	yyj12++
 60432  	if yyhl12 {
 60433  		yyb12 = yyj12 > l
 60434  	} else {
 60435  		yyb12 = r.CheckBreak()
 60436  	}
 60437  	if yyb12 {
 60438  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60439  		return
 60440  	}
 60441  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60442  	if r.TryDecodeAsNil() {
 60443  		x.GetterMode = ""
 60444  	} else {
 60445  		yyv17 := &x.GetterMode
 60446  		yym18 := z.DecBinary()
 60447  		_ = yym18
 60448  		if false {
 60449  		} else {
 60450  			*((*string)(yyv17)) = r.DecodeString()
 60451  		}
 60452  	}
 60453  	yyj12++
 60454  	if yyhl12 {
 60455  		yyb12 = yyj12 > l
 60456  	} else {
 60457  		yyb12 = r.CheckBreak()
 60458  	}
 60459  	if yyb12 {
 60460  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60461  		return
 60462  	}
 60463  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60464  	if r.TryDecodeAsNil() {
 60465  		x.RelativeDest = ""
 60466  	} else {
 60467  		yyv19 := &x.RelativeDest
 60468  		yym20 := z.DecBinary()
 60469  		_ = yym20
 60470  		if false {
 60471  		} else {
 60472  			*((*string)(yyv19)) = r.DecodeString()
 60473  		}
 60474  	}
 60475  	for {
 60476  		yyj12++
 60477  		if yyhl12 {
 60478  			yyb12 = yyj12 > l
 60479  		} else {
 60480  			yyb12 = r.CheckBreak()
 60481  		}
 60482  		if yyb12 {
 60483  			break
 60484  		}
 60485  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60486  		z.DecStructFieldNotFound(yyj12-1, "")
 60487  	}
 60488  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60489  }
 60490  
 60491  func (x *Constraint) CodecEncodeSelf(e *codec1978.Encoder) {
 60492  	var h codecSelfer100
 60493  	z, r := codec1978.GenHelperEncoder(e)
 60494  	_, _, _ = h, z, r
 60495  	if x == nil {
 60496  		r.EncodeNil()
 60497  	} else {
 60498  		yym1 := z.EncBinary()
 60499  		_ = yym1
 60500  		if false {
 60501  		} else if z.HasExtensions() && z.EncExt(x) {
 60502  		} else {
 60503  			yysep2 := !z.EncBinary()
 60504  			yy2arr2 := z.EncBasicHandle().StructToArray
 60505  			var yyq2 [3]bool
 60506  			_, _, _ = yysep2, yyq2, yy2arr2
 60507  			const yyr2 bool = false
 60508  			var yynn2 int
 60509  			if yyr2 || yy2arr2 {
 60510  				r.EncodeArrayStart(3)
 60511  			} else {
 60512  				yynn2 = 3
 60513  				for _, b := range yyq2 {
 60514  					if b {
 60515  						yynn2++
 60516  					}
 60517  				}
 60518  				r.EncodeMapStart(yynn2)
 60519  				yynn2 = 0
 60520  			}
 60521  			if yyr2 || yy2arr2 {
 60522  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 60523  				yym4 := z.EncBinary()
 60524  				_ = yym4
 60525  				if false {
 60526  				} else {
 60527  					r.EncodeString(codecSelferC_UTF8100, string(x.LTarget))
 60528  				}
 60529  			} else {
 60530  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 60531  				r.EncodeString(codecSelferC_UTF8100, string("LTarget"))
 60532  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 60533  				yym5 := z.EncBinary()
 60534  				_ = yym5
 60535  				if false {
 60536  				} else {
 60537  					r.EncodeString(codecSelferC_UTF8100, string(x.LTarget))
 60538  				}
 60539  			}
 60540  			if yyr2 || yy2arr2 {
 60541  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 60542  				yym7 := z.EncBinary()
 60543  				_ = yym7
 60544  				if false {
 60545  				} else {
 60546  					r.EncodeString(codecSelferC_UTF8100, string(x.RTarget))
 60547  				}
 60548  			} else {
 60549  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 60550  				r.EncodeString(codecSelferC_UTF8100, string("RTarget"))
 60551  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 60552  				yym8 := z.EncBinary()
 60553  				_ = yym8
 60554  				if false {
 60555  				} else {
 60556  					r.EncodeString(codecSelferC_UTF8100, string(x.RTarget))
 60557  				}
 60558  			}
 60559  			if yyr2 || yy2arr2 {
 60560  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 60561  				yym10 := z.EncBinary()
 60562  				_ = yym10
 60563  				if false {
 60564  				} else {
 60565  					r.EncodeString(codecSelferC_UTF8100, string(x.Operand))
 60566  				}
 60567  			} else {
 60568  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 60569  				r.EncodeString(codecSelferC_UTF8100, string("Operand"))
 60570  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 60571  				yym11 := z.EncBinary()
 60572  				_ = yym11
 60573  				if false {
 60574  				} else {
 60575  					r.EncodeString(codecSelferC_UTF8100, string(x.Operand))
 60576  				}
 60577  			}
 60578  			if yyr2 || yy2arr2 {
 60579  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 60580  			} else {
 60581  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 60582  			}
 60583  		}
 60584  	}
 60585  }
 60586  
 60587  func (x *Constraint) CodecDecodeSelf(d *codec1978.Decoder) {
 60588  	var h codecSelfer100
 60589  	z, r := codec1978.GenHelperDecoder(d)
 60590  	_, _, _ = h, z, r
 60591  	yym1 := z.DecBinary()
 60592  	_ = yym1
 60593  	if false {
 60594  	} else if z.HasExtensions() && z.DecExt(x) {
 60595  	} else {
 60596  		yyct2 := r.ContainerType()
 60597  		if yyct2 == codecSelferValueTypeMap100 {
 60598  			yyl2 := r.ReadMapStart()
 60599  			if yyl2 == 0 {
 60600  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 60601  			} else {
 60602  				x.codecDecodeSelfFromMap(yyl2, d)
 60603  			}
 60604  		} else if yyct2 == codecSelferValueTypeArray100 {
 60605  			yyl2 := r.ReadArrayStart()
 60606  			if yyl2 == 0 {
 60607  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60608  			} else {
 60609  				x.codecDecodeSelfFromArray(yyl2, d)
 60610  			}
 60611  		} else {
 60612  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 60613  		}
 60614  	}
 60615  }
 60616  
 60617  func (x *Constraint) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 60618  	var h codecSelfer100
 60619  	z, r := codec1978.GenHelperDecoder(d)
 60620  	_, _, _ = h, z, r
 60621  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 60622  	_ = yys3Slc
 60623  	var yyhl3 bool = l >= 0
 60624  	for yyj3 := 0; ; yyj3++ {
 60625  		if yyhl3 {
 60626  			if yyj3 >= l {
 60627  				break
 60628  			}
 60629  		} else {
 60630  			if r.CheckBreak() {
 60631  				break
 60632  			}
 60633  		}
 60634  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 60635  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 60636  		yys3 := string(yys3Slc)
 60637  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 60638  		switch yys3 {
 60639  		case "LTarget":
 60640  			if r.TryDecodeAsNil() {
 60641  				x.LTarget = ""
 60642  			} else {
 60643  				yyv4 := &x.LTarget
 60644  				yym5 := z.DecBinary()
 60645  				_ = yym5
 60646  				if false {
 60647  				} else {
 60648  					*((*string)(yyv4)) = r.DecodeString()
 60649  				}
 60650  			}
 60651  		case "RTarget":
 60652  			if r.TryDecodeAsNil() {
 60653  				x.RTarget = ""
 60654  			} else {
 60655  				yyv6 := &x.RTarget
 60656  				yym7 := z.DecBinary()
 60657  				_ = yym7
 60658  				if false {
 60659  				} else {
 60660  					*((*string)(yyv6)) = r.DecodeString()
 60661  				}
 60662  			}
 60663  		case "Operand":
 60664  			if r.TryDecodeAsNil() {
 60665  				x.Operand = ""
 60666  			} else {
 60667  				yyv8 := &x.Operand
 60668  				yym9 := z.DecBinary()
 60669  				_ = yym9
 60670  				if false {
 60671  				} else {
 60672  					*((*string)(yyv8)) = r.DecodeString()
 60673  				}
 60674  			}
 60675  		default:
 60676  			z.DecStructFieldNotFound(-1, yys3)
 60677  		} // end switch yys3
 60678  	} // end for yyj3
 60679  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 60680  }
 60681  
 60682  func (x *Constraint) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 60683  	var h codecSelfer100
 60684  	z, r := codec1978.GenHelperDecoder(d)
 60685  	_, _, _ = h, z, r
 60686  	var yyj10 int
 60687  	var yyb10 bool
 60688  	var yyhl10 bool = l >= 0
 60689  	yyj10++
 60690  	if yyhl10 {
 60691  		yyb10 = yyj10 > l
 60692  	} else {
 60693  		yyb10 = r.CheckBreak()
 60694  	}
 60695  	if yyb10 {
 60696  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60697  		return
 60698  	}
 60699  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60700  	if r.TryDecodeAsNil() {
 60701  		x.LTarget = ""
 60702  	} else {
 60703  		yyv11 := &x.LTarget
 60704  		yym12 := z.DecBinary()
 60705  		_ = yym12
 60706  		if false {
 60707  		} else {
 60708  			*((*string)(yyv11)) = r.DecodeString()
 60709  		}
 60710  	}
 60711  	yyj10++
 60712  	if yyhl10 {
 60713  		yyb10 = yyj10 > l
 60714  	} else {
 60715  		yyb10 = r.CheckBreak()
 60716  	}
 60717  	if yyb10 {
 60718  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60719  		return
 60720  	}
 60721  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60722  	if r.TryDecodeAsNil() {
 60723  		x.RTarget = ""
 60724  	} else {
 60725  		yyv13 := &x.RTarget
 60726  		yym14 := z.DecBinary()
 60727  		_ = yym14
 60728  		if false {
 60729  		} else {
 60730  			*((*string)(yyv13)) = r.DecodeString()
 60731  		}
 60732  	}
 60733  	yyj10++
 60734  	if yyhl10 {
 60735  		yyb10 = yyj10 > l
 60736  	} else {
 60737  		yyb10 = r.CheckBreak()
 60738  	}
 60739  	if yyb10 {
 60740  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60741  		return
 60742  	}
 60743  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60744  	if r.TryDecodeAsNil() {
 60745  		x.Operand = ""
 60746  	} else {
 60747  		yyv15 := &x.Operand
 60748  		yym16 := z.DecBinary()
 60749  		_ = yym16
 60750  		if false {
 60751  		} else {
 60752  			*((*string)(yyv15)) = r.DecodeString()
 60753  		}
 60754  	}
 60755  	for {
 60756  		yyj10++
 60757  		if yyhl10 {
 60758  			yyb10 = yyj10 > l
 60759  		} else {
 60760  			yyb10 = r.CheckBreak()
 60761  		}
 60762  		if yyb10 {
 60763  			break
 60764  		}
 60765  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60766  		z.DecStructFieldNotFound(yyj10-1, "")
 60767  	}
 60768  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60769  }
 60770  
 60771  func (x *EphemeralDisk) CodecEncodeSelf(e *codec1978.Encoder) {
 60772  	var h codecSelfer100
 60773  	z, r := codec1978.GenHelperEncoder(e)
 60774  	_, _, _ = h, z, r
 60775  	if x == nil {
 60776  		r.EncodeNil()
 60777  	} else {
 60778  		yym1 := z.EncBinary()
 60779  		_ = yym1
 60780  		if false {
 60781  		} else if z.HasExtensions() && z.EncExt(x) {
 60782  		} else {
 60783  			yysep2 := !z.EncBinary()
 60784  			yy2arr2 := z.EncBasicHandle().StructToArray
 60785  			var yyq2 [3]bool
 60786  			_, _, _ = yysep2, yyq2, yy2arr2
 60787  			const yyr2 bool = false
 60788  			var yynn2 int
 60789  			if yyr2 || yy2arr2 {
 60790  				r.EncodeArrayStart(3)
 60791  			} else {
 60792  				yynn2 = 3
 60793  				for _, b := range yyq2 {
 60794  					if b {
 60795  						yynn2++
 60796  					}
 60797  				}
 60798  				r.EncodeMapStart(yynn2)
 60799  				yynn2 = 0
 60800  			}
 60801  			if yyr2 || yy2arr2 {
 60802  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 60803  				yym4 := z.EncBinary()
 60804  				_ = yym4
 60805  				if false {
 60806  				} else {
 60807  					r.EncodeBool(bool(x.Sticky))
 60808  				}
 60809  			} else {
 60810  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 60811  				r.EncodeString(codecSelferC_UTF8100, string("Sticky"))
 60812  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 60813  				yym5 := z.EncBinary()
 60814  				_ = yym5
 60815  				if false {
 60816  				} else {
 60817  					r.EncodeBool(bool(x.Sticky))
 60818  				}
 60819  			}
 60820  			if yyr2 || yy2arr2 {
 60821  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 60822  				yym7 := z.EncBinary()
 60823  				_ = yym7
 60824  				if false {
 60825  				} else {
 60826  					r.EncodeInt(int64(x.SizeMB))
 60827  				}
 60828  			} else {
 60829  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 60830  				r.EncodeString(codecSelferC_UTF8100, string("SizeMB"))
 60831  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 60832  				yym8 := z.EncBinary()
 60833  				_ = yym8
 60834  				if false {
 60835  				} else {
 60836  					r.EncodeInt(int64(x.SizeMB))
 60837  				}
 60838  			}
 60839  			if yyr2 || yy2arr2 {
 60840  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 60841  				yym10 := z.EncBinary()
 60842  				_ = yym10
 60843  				if false {
 60844  				} else {
 60845  					r.EncodeBool(bool(x.Migrate))
 60846  				}
 60847  			} else {
 60848  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 60849  				r.EncodeString(codecSelferC_UTF8100, string("Migrate"))
 60850  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 60851  				yym11 := z.EncBinary()
 60852  				_ = yym11
 60853  				if false {
 60854  				} else {
 60855  					r.EncodeBool(bool(x.Migrate))
 60856  				}
 60857  			}
 60858  			if yyr2 || yy2arr2 {
 60859  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 60860  			} else {
 60861  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 60862  			}
 60863  		}
 60864  	}
 60865  }
 60866  
 60867  func (x *EphemeralDisk) CodecDecodeSelf(d *codec1978.Decoder) {
 60868  	var h codecSelfer100
 60869  	z, r := codec1978.GenHelperDecoder(d)
 60870  	_, _, _ = h, z, r
 60871  	yym1 := z.DecBinary()
 60872  	_ = yym1
 60873  	if false {
 60874  	} else if z.HasExtensions() && z.DecExt(x) {
 60875  	} else {
 60876  		yyct2 := r.ContainerType()
 60877  		if yyct2 == codecSelferValueTypeMap100 {
 60878  			yyl2 := r.ReadMapStart()
 60879  			if yyl2 == 0 {
 60880  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 60881  			} else {
 60882  				x.codecDecodeSelfFromMap(yyl2, d)
 60883  			}
 60884  		} else if yyct2 == codecSelferValueTypeArray100 {
 60885  			yyl2 := r.ReadArrayStart()
 60886  			if yyl2 == 0 {
 60887  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60888  			} else {
 60889  				x.codecDecodeSelfFromArray(yyl2, d)
 60890  			}
 60891  		} else {
 60892  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 60893  		}
 60894  	}
 60895  }
 60896  
 60897  func (x *EphemeralDisk) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 60898  	var h codecSelfer100
 60899  	z, r := codec1978.GenHelperDecoder(d)
 60900  	_, _, _ = h, z, r
 60901  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 60902  	_ = yys3Slc
 60903  	var yyhl3 bool = l >= 0
 60904  	for yyj3 := 0; ; yyj3++ {
 60905  		if yyhl3 {
 60906  			if yyj3 >= l {
 60907  				break
 60908  			}
 60909  		} else {
 60910  			if r.CheckBreak() {
 60911  				break
 60912  			}
 60913  		}
 60914  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 60915  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 60916  		yys3 := string(yys3Slc)
 60917  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 60918  		switch yys3 {
 60919  		case "Sticky":
 60920  			if r.TryDecodeAsNil() {
 60921  				x.Sticky = false
 60922  			} else {
 60923  				yyv4 := &x.Sticky
 60924  				yym5 := z.DecBinary()
 60925  				_ = yym5
 60926  				if false {
 60927  				} else {
 60928  					*((*bool)(yyv4)) = r.DecodeBool()
 60929  				}
 60930  			}
 60931  		case "SizeMB":
 60932  			if r.TryDecodeAsNil() {
 60933  				x.SizeMB = 0
 60934  			} else {
 60935  				yyv6 := &x.SizeMB
 60936  				yym7 := z.DecBinary()
 60937  				_ = yym7
 60938  				if false {
 60939  				} else {
 60940  					*((*int)(yyv6)) = int(r.DecodeInt(codecSelferBitsize100))
 60941  				}
 60942  			}
 60943  		case "Migrate":
 60944  			if r.TryDecodeAsNil() {
 60945  				x.Migrate = false
 60946  			} else {
 60947  				yyv8 := &x.Migrate
 60948  				yym9 := z.DecBinary()
 60949  				_ = yym9
 60950  				if false {
 60951  				} else {
 60952  					*((*bool)(yyv8)) = r.DecodeBool()
 60953  				}
 60954  			}
 60955  		default:
 60956  			z.DecStructFieldNotFound(-1, yys3)
 60957  		} // end switch yys3
 60958  	} // end for yyj3
 60959  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 60960  }
 60961  
 60962  func (x *EphemeralDisk) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 60963  	var h codecSelfer100
 60964  	z, r := codec1978.GenHelperDecoder(d)
 60965  	_, _, _ = h, z, r
 60966  	var yyj10 int
 60967  	var yyb10 bool
 60968  	var yyhl10 bool = l >= 0
 60969  	yyj10++
 60970  	if yyhl10 {
 60971  		yyb10 = yyj10 > l
 60972  	} else {
 60973  		yyb10 = r.CheckBreak()
 60974  	}
 60975  	if yyb10 {
 60976  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60977  		return
 60978  	}
 60979  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 60980  	if r.TryDecodeAsNil() {
 60981  		x.Sticky = false
 60982  	} else {
 60983  		yyv11 := &x.Sticky
 60984  		yym12 := z.DecBinary()
 60985  		_ = yym12
 60986  		if false {
 60987  		} else {
 60988  			*((*bool)(yyv11)) = r.DecodeBool()
 60989  		}
 60990  	}
 60991  	yyj10++
 60992  	if yyhl10 {
 60993  		yyb10 = yyj10 > l
 60994  	} else {
 60995  		yyb10 = r.CheckBreak()
 60996  	}
 60997  	if yyb10 {
 60998  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 60999  		return
 61000  	}
 61001  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 61002  	if r.TryDecodeAsNil() {
 61003  		x.SizeMB = 0
 61004  	} else {
 61005  		yyv13 := &x.SizeMB
 61006  		yym14 := z.DecBinary()
 61007  		_ = yym14
 61008  		if false {
 61009  		} else {
 61010  			*((*int)(yyv13)) = int(r.DecodeInt(codecSelferBitsize100))
 61011  		}
 61012  	}
 61013  	yyj10++
 61014  	if yyhl10 {
 61015  		yyb10 = yyj10 > l
 61016  	} else {
 61017  		yyb10 = r.CheckBreak()
 61018  	}
 61019  	if yyb10 {
 61020  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61021  		return
 61022  	}
 61023  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 61024  	if r.TryDecodeAsNil() {
 61025  		x.Migrate = false
 61026  	} else {
 61027  		yyv15 := &x.Migrate
 61028  		yym16 := z.DecBinary()
 61029  		_ = yym16
 61030  		if false {
 61031  		} else {
 61032  			*((*bool)(yyv15)) = r.DecodeBool()
 61033  		}
 61034  	}
 61035  	for {
 61036  		yyj10++
 61037  		if yyhl10 {
 61038  			yyb10 = yyj10 > l
 61039  		} else {
 61040  			yyb10 = r.CheckBreak()
 61041  		}
 61042  		if yyb10 {
 61043  			break
 61044  		}
 61045  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 61046  		z.DecStructFieldNotFound(yyj10-1, "")
 61047  	}
 61048  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61049  }
 61050  
 61051  func (x *Vault) CodecEncodeSelf(e *codec1978.Encoder) {
 61052  	var h codecSelfer100
 61053  	z, r := codec1978.GenHelperEncoder(e)
 61054  	_, _, _ = h, z, r
 61055  	if x == nil {
 61056  		r.EncodeNil()
 61057  	} else {
 61058  		yym1 := z.EncBinary()
 61059  		_ = yym1
 61060  		if false {
 61061  		} else if z.HasExtensions() && z.EncExt(x) {
 61062  		} else {
 61063  			yysep2 := !z.EncBinary()
 61064  			yy2arr2 := z.EncBasicHandle().StructToArray
 61065  			var yyq2 [4]bool
 61066  			_, _, _ = yysep2, yyq2, yy2arr2
 61067  			const yyr2 bool = false
 61068  			var yynn2 int
 61069  			if yyr2 || yy2arr2 {
 61070  				r.EncodeArrayStart(4)
 61071  			} else {
 61072  				yynn2 = 4
 61073  				for _, b := range yyq2 {
 61074  					if b {
 61075  						yynn2++
 61076  					}
 61077  				}
 61078  				r.EncodeMapStart(yynn2)
 61079  				yynn2 = 0
 61080  			}
 61081  			if yyr2 || yy2arr2 {
 61082  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 61083  				if x.Policies == nil {
 61084  					r.EncodeNil()
 61085  				} else {
 61086  					yym4 := z.EncBinary()
 61087  					_ = yym4
 61088  					if false {
 61089  					} else {
 61090  						z.F.EncSliceStringV(x.Policies, false, e)
 61091  					}
 61092  				}
 61093  			} else {
 61094  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 61095  				r.EncodeString(codecSelferC_UTF8100, string("Policies"))
 61096  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 61097  				if x.Policies == nil {
 61098  					r.EncodeNil()
 61099  				} else {
 61100  					yym5 := z.EncBinary()
 61101  					_ = yym5
 61102  					if false {
 61103  					} else {
 61104  						z.F.EncSliceStringV(x.Policies, false, e)
 61105  					}
 61106  				}
 61107  			}
 61108  			if yyr2 || yy2arr2 {
 61109  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 61110  				yym7 := z.EncBinary()
 61111  				_ = yym7
 61112  				if false {
 61113  				} else {
 61114  					r.EncodeBool(bool(x.Env))
 61115  				}
 61116  			} else {
 61117  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 61118  				r.EncodeString(codecSelferC_UTF8100, string("Env"))
 61119  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 61120  				yym8 := z.EncBinary()
 61121  				_ = yym8
 61122  				if false {
 61123  				} else {
 61124  					r.EncodeBool(bool(x.Env))
 61125  				}
 61126  			}
 61127  			if yyr2 || yy2arr2 {
 61128  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 61129  				yym10 := z.EncBinary()
 61130  				_ = yym10
 61131  				if false {
 61132  				} else {
 61133  					r.EncodeString(codecSelferC_UTF8100, string(x.ChangeMode))
 61134  				}
 61135  			} else {
 61136  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 61137  				r.EncodeString(codecSelferC_UTF8100, string("ChangeMode"))
 61138  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 61139  				yym11 := z.EncBinary()
 61140  				_ = yym11
 61141  				if false {
 61142  				} else {
 61143  					r.EncodeString(codecSelferC_UTF8100, string(x.ChangeMode))
 61144  				}
 61145  			}
 61146  			if yyr2 || yy2arr2 {
 61147  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 61148  				yym13 := z.EncBinary()
 61149  				_ = yym13
 61150  				if false {
 61151  				} else {
 61152  					r.EncodeString(codecSelferC_UTF8100, string(x.ChangeSignal))
 61153  				}
 61154  			} else {
 61155  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 61156  				r.EncodeString(codecSelferC_UTF8100, string("ChangeSignal"))
 61157  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 61158  				yym14 := z.EncBinary()
 61159  				_ = yym14
 61160  				if false {
 61161  				} else {
 61162  					r.EncodeString(codecSelferC_UTF8100, string(x.ChangeSignal))
 61163  				}
 61164  			}
 61165  			if yyr2 || yy2arr2 {
 61166  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 61167  			} else {
 61168  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 61169  			}
 61170  		}
 61171  	}
 61172  }
 61173  
 61174  func (x *Vault) CodecDecodeSelf(d *codec1978.Decoder) {
 61175  	var h codecSelfer100
 61176  	z, r := codec1978.GenHelperDecoder(d)
 61177  	_, _, _ = h, z, r
 61178  	yym1 := z.DecBinary()
 61179  	_ = yym1
 61180  	if false {
 61181  	} else if z.HasExtensions() && z.DecExt(x) {
 61182  	} else {
 61183  		yyct2 := r.ContainerType()
 61184  		if yyct2 == codecSelferValueTypeMap100 {
 61185  			yyl2 := r.ReadMapStart()
 61186  			if yyl2 == 0 {
 61187  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 61188  			} else {
 61189  				x.codecDecodeSelfFromMap(yyl2, d)
 61190  			}
 61191  		} else if yyct2 == codecSelferValueTypeArray100 {
 61192  			yyl2 := r.ReadArrayStart()
 61193  			if yyl2 == 0 {
 61194  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61195  			} else {
 61196  				x.codecDecodeSelfFromArray(yyl2, d)
 61197  			}
 61198  		} else {
 61199  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 61200  		}
 61201  	}
 61202  }
 61203  
 61204  func (x *Vault) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 61205  	var h codecSelfer100
 61206  	z, r := codec1978.GenHelperDecoder(d)
 61207  	_, _, _ = h, z, r
 61208  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 61209  	_ = yys3Slc
 61210  	var yyhl3 bool = l >= 0
 61211  	for yyj3 := 0; ; yyj3++ {
 61212  		if yyhl3 {
 61213  			if yyj3 >= l {
 61214  				break
 61215  			}
 61216  		} else {
 61217  			if r.CheckBreak() {
 61218  				break
 61219  			}
 61220  		}
 61221  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 61222  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 61223  		yys3 := string(yys3Slc)
 61224  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 61225  		switch yys3 {
 61226  		case "Policies":
 61227  			if r.TryDecodeAsNil() {
 61228  				x.Policies = nil
 61229  			} else {
 61230  				yyv4 := &x.Policies
 61231  				yym5 := z.DecBinary()
 61232  				_ = yym5
 61233  				if false {
 61234  				} else {
 61235  					z.F.DecSliceStringX(yyv4, false, d)
 61236  				}
 61237  			}
 61238  		case "Env":
 61239  			if r.TryDecodeAsNil() {
 61240  				x.Env = false
 61241  			} else {
 61242  				yyv6 := &x.Env
 61243  				yym7 := z.DecBinary()
 61244  				_ = yym7
 61245  				if false {
 61246  				} else {
 61247  					*((*bool)(yyv6)) = r.DecodeBool()
 61248  				}
 61249  			}
 61250  		case "ChangeMode":
 61251  			if r.TryDecodeAsNil() {
 61252  				x.ChangeMode = ""
 61253  			} else {
 61254  				yyv8 := &x.ChangeMode
 61255  				yym9 := z.DecBinary()
 61256  				_ = yym9
 61257  				if false {
 61258  				} else {
 61259  					*((*string)(yyv8)) = r.DecodeString()
 61260  				}
 61261  			}
 61262  		case "ChangeSignal":
 61263  			if r.TryDecodeAsNil() {
 61264  				x.ChangeSignal = ""
 61265  			} else {
 61266  				yyv10 := &x.ChangeSignal
 61267  				yym11 := z.DecBinary()
 61268  				_ = yym11
 61269  				if false {
 61270  				} else {
 61271  					*((*string)(yyv10)) = r.DecodeString()
 61272  				}
 61273  			}
 61274  		default:
 61275  			z.DecStructFieldNotFound(-1, yys3)
 61276  		} // end switch yys3
 61277  	} // end for yyj3
 61278  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 61279  }
 61280  
 61281  func (x *Vault) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 61282  	var h codecSelfer100
 61283  	z, r := codec1978.GenHelperDecoder(d)
 61284  	_, _, _ = h, z, r
 61285  	var yyj12 int
 61286  	var yyb12 bool
 61287  	var yyhl12 bool = l >= 0
 61288  	yyj12++
 61289  	if yyhl12 {
 61290  		yyb12 = yyj12 > l
 61291  	} else {
 61292  		yyb12 = r.CheckBreak()
 61293  	}
 61294  	if yyb12 {
 61295  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61296  		return
 61297  	}
 61298  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 61299  	if r.TryDecodeAsNil() {
 61300  		x.Policies = nil
 61301  	} else {
 61302  		yyv13 := &x.Policies
 61303  		yym14 := z.DecBinary()
 61304  		_ = yym14
 61305  		if false {
 61306  		} else {
 61307  			z.F.DecSliceStringX(yyv13, false, d)
 61308  		}
 61309  	}
 61310  	yyj12++
 61311  	if yyhl12 {
 61312  		yyb12 = yyj12 > l
 61313  	} else {
 61314  		yyb12 = r.CheckBreak()
 61315  	}
 61316  	if yyb12 {
 61317  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61318  		return
 61319  	}
 61320  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 61321  	if r.TryDecodeAsNil() {
 61322  		x.Env = false
 61323  	} else {
 61324  		yyv15 := &x.Env
 61325  		yym16 := z.DecBinary()
 61326  		_ = yym16
 61327  		if false {
 61328  		} else {
 61329  			*((*bool)(yyv15)) = r.DecodeBool()
 61330  		}
 61331  	}
 61332  	yyj12++
 61333  	if yyhl12 {
 61334  		yyb12 = yyj12 > l
 61335  	} else {
 61336  		yyb12 = r.CheckBreak()
 61337  	}
 61338  	if yyb12 {
 61339  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61340  		return
 61341  	}
 61342  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 61343  	if r.TryDecodeAsNil() {
 61344  		x.ChangeMode = ""
 61345  	} else {
 61346  		yyv17 := &x.ChangeMode
 61347  		yym18 := z.DecBinary()
 61348  		_ = yym18
 61349  		if false {
 61350  		} else {
 61351  			*((*string)(yyv17)) = r.DecodeString()
 61352  		}
 61353  	}
 61354  	yyj12++
 61355  	if yyhl12 {
 61356  		yyb12 = yyj12 > l
 61357  	} else {
 61358  		yyb12 = r.CheckBreak()
 61359  	}
 61360  	if yyb12 {
 61361  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61362  		return
 61363  	}
 61364  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 61365  	if r.TryDecodeAsNil() {
 61366  		x.ChangeSignal = ""
 61367  	} else {
 61368  		yyv19 := &x.ChangeSignal
 61369  		yym20 := z.DecBinary()
 61370  		_ = yym20
 61371  		if false {
 61372  		} else {
 61373  			*((*string)(yyv19)) = r.DecodeString()
 61374  		}
 61375  	}
 61376  	for {
 61377  		yyj12++
 61378  		if yyhl12 {
 61379  			yyb12 = yyj12 > l
 61380  		} else {
 61381  			yyb12 = r.CheckBreak()
 61382  		}
 61383  		if yyb12 {
 61384  			break
 61385  		}
 61386  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 61387  		z.DecStructFieldNotFound(yyj12-1, "")
 61388  	}
 61389  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61390  }
 61391  
 61392  func (x *Deployment) CodecEncodeSelf(e *codec1978.Encoder) {
 61393  	var h codecSelfer100
 61394  	z, r := codec1978.GenHelperEncoder(e)
 61395  	_, _, _ = h, z, r
 61396  	if x == nil {
 61397  		r.EncodeNil()
 61398  	} else {
 61399  		yym1 := z.EncBinary()
 61400  		_ = yym1
 61401  		if false {
 61402  		} else if z.HasExtensions() && z.EncExt(x) {
 61403  		} else {
 61404  			yysep2 := !z.EncBinary()
 61405  			yy2arr2 := z.EncBasicHandle().StructToArray
 61406  			var yyq2 [11]bool
 61407  			_, _, _ = yysep2, yyq2, yy2arr2
 61408  			const yyr2 bool = false
 61409  			var yynn2 int
 61410  			if yyr2 || yy2arr2 {
 61411  				r.EncodeArrayStart(11)
 61412  			} else {
 61413  				yynn2 = 11
 61414  				for _, b := range yyq2 {
 61415  					if b {
 61416  						yynn2++
 61417  					}
 61418  				}
 61419  				r.EncodeMapStart(yynn2)
 61420  				yynn2 = 0
 61421  			}
 61422  			if yyr2 || yy2arr2 {
 61423  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 61424  				yym4 := z.EncBinary()
 61425  				_ = yym4
 61426  				if false {
 61427  				} else {
 61428  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 61429  				}
 61430  			} else {
 61431  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 61432  				r.EncodeString(codecSelferC_UTF8100, string("ID"))
 61433  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 61434  				yym5 := z.EncBinary()
 61435  				_ = yym5
 61436  				if false {
 61437  				} else {
 61438  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 61439  				}
 61440  			}
 61441  			if yyr2 || yy2arr2 {
 61442  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 61443  				yym7 := z.EncBinary()
 61444  				_ = yym7
 61445  				if false {
 61446  				} else {
 61447  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 61448  				}
 61449  			} else {
 61450  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 61451  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 61452  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 61453  				yym8 := z.EncBinary()
 61454  				_ = yym8
 61455  				if false {
 61456  				} else {
 61457  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 61458  				}
 61459  			}
 61460  			if yyr2 || yy2arr2 {
 61461  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 61462  				yym10 := z.EncBinary()
 61463  				_ = yym10
 61464  				if false {
 61465  				} else {
 61466  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 61467  				}
 61468  			} else {
 61469  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 61470  				r.EncodeString(codecSelferC_UTF8100, string("JobID"))
 61471  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 61472  				yym11 := z.EncBinary()
 61473  				_ = yym11
 61474  				if false {
 61475  				} else {
 61476  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 61477  				}
 61478  			}
 61479  			if yyr2 || yy2arr2 {
 61480  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 61481  				yym13 := z.EncBinary()
 61482  				_ = yym13
 61483  				if false {
 61484  				} else {
 61485  					r.EncodeUint(uint64(x.JobVersion))
 61486  				}
 61487  			} else {
 61488  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 61489  				r.EncodeString(codecSelferC_UTF8100, string("JobVersion"))
 61490  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 61491  				yym14 := z.EncBinary()
 61492  				_ = yym14
 61493  				if false {
 61494  				} else {
 61495  					r.EncodeUint(uint64(x.JobVersion))
 61496  				}
 61497  			}
 61498  			if yyr2 || yy2arr2 {
 61499  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 61500  				yym16 := z.EncBinary()
 61501  				_ = yym16
 61502  				if false {
 61503  				} else {
 61504  					r.EncodeUint(uint64(x.JobModifyIndex))
 61505  				}
 61506  			} else {
 61507  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 61508  				r.EncodeString(codecSelferC_UTF8100, string("JobModifyIndex"))
 61509  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 61510  				yym17 := z.EncBinary()
 61511  				_ = yym17
 61512  				if false {
 61513  				} else {
 61514  					r.EncodeUint(uint64(x.JobModifyIndex))
 61515  				}
 61516  			}
 61517  			if yyr2 || yy2arr2 {
 61518  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 61519  				yym19 := z.EncBinary()
 61520  				_ = yym19
 61521  				if false {
 61522  				} else {
 61523  					r.EncodeUint(uint64(x.JobCreateIndex))
 61524  				}
 61525  			} else {
 61526  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 61527  				r.EncodeString(codecSelferC_UTF8100, string("JobCreateIndex"))
 61528  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 61529  				yym20 := z.EncBinary()
 61530  				_ = yym20
 61531  				if false {
 61532  				} else {
 61533  					r.EncodeUint(uint64(x.JobCreateIndex))
 61534  				}
 61535  			}
 61536  			if yyr2 || yy2arr2 {
 61537  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 61538  				if x.TaskGroups == nil {
 61539  					r.EncodeNil()
 61540  				} else {
 61541  					yym22 := z.EncBinary()
 61542  					_ = yym22
 61543  					if false {
 61544  					} else {
 61545  						h.encMapstringPtrtoDeploymentState((map[string]*DeploymentState)(x.TaskGroups), e)
 61546  					}
 61547  				}
 61548  			} else {
 61549  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 61550  				r.EncodeString(codecSelferC_UTF8100, string("TaskGroups"))
 61551  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 61552  				if x.TaskGroups == nil {
 61553  					r.EncodeNil()
 61554  				} else {
 61555  					yym23 := z.EncBinary()
 61556  					_ = yym23
 61557  					if false {
 61558  					} else {
 61559  						h.encMapstringPtrtoDeploymentState((map[string]*DeploymentState)(x.TaskGroups), e)
 61560  					}
 61561  				}
 61562  			}
 61563  			if yyr2 || yy2arr2 {
 61564  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 61565  				yym25 := z.EncBinary()
 61566  				_ = yym25
 61567  				if false {
 61568  				} else {
 61569  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 61570  				}
 61571  			} else {
 61572  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 61573  				r.EncodeString(codecSelferC_UTF8100, string("Status"))
 61574  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 61575  				yym26 := z.EncBinary()
 61576  				_ = yym26
 61577  				if false {
 61578  				} else {
 61579  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 61580  				}
 61581  			}
 61582  			if yyr2 || yy2arr2 {
 61583  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 61584  				yym28 := z.EncBinary()
 61585  				_ = yym28
 61586  				if false {
 61587  				} else {
 61588  					r.EncodeString(codecSelferC_UTF8100, string(x.StatusDescription))
 61589  				}
 61590  			} else {
 61591  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 61592  				r.EncodeString(codecSelferC_UTF8100, string("StatusDescription"))
 61593  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 61594  				yym29 := z.EncBinary()
 61595  				_ = yym29
 61596  				if false {
 61597  				} else {
 61598  					r.EncodeString(codecSelferC_UTF8100, string(x.StatusDescription))
 61599  				}
 61600  			}
 61601  			if yyr2 || yy2arr2 {
 61602  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 61603  				yym31 := z.EncBinary()
 61604  				_ = yym31
 61605  				if false {
 61606  				} else {
 61607  					r.EncodeUint(uint64(x.CreateIndex))
 61608  				}
 61609  			} else {
 61610  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 61611  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 61612  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 61613  				yym32 := z.EncBinary()
 61614  				_ = yym32
 61615  				if false {
 61616  				} else {
 61617  					r.EncodeUint(uint64(x.CreateIndex))
 61618  				}
 61619  			}
 61620  			if yyr2 || yy2arr2 {
 61621  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 61622  				yym34 := z.EncBinary()
 61623  				_ = yym34
 61624  				if false {
 61625  				} else {
 61626  					r.EncodeUint(uint64(x.ModifyIndex))
 61627  				}
 61628  			} else {
 61629  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 61630  				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
 61631  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 61632  				yym35 := z.EncBinary()
 61633  				_ = yym35
 61634  				if false {
 61635  				} else {
 61636  					r.EncodeUint(uint64(x.ModifyIndex))
 61637  				}
 61638  			}
 61639  			if yyr2 || yy2arr2 {
 61640  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 61641  			} else {
 61642  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 61643  			}
 61644  		}
 61645  	}
 61646  }
 61647  
 61648  func (x *Deployment) CodecDecodeSelf(d *codec1978.Decoder) {
 61649  	var h codecSelfer100
 61650  	z, r := codec1978.GenHelperDecoder(d)
 61651  	_, _, _ = h, z, r
 61652  	yym1 := z.DecBinary()
 61653  	_ = yym1
 61654  	if false {
 61655  	} else if z.HasExtensions() && z.DecExt(x) {
 61656  	} else {
 61657  		yyct2 := r.ContainerType()
 61658  		if yyct2 == codecSelferValueTypeMap100 {
 61659  			yyl2 := r.ReadMapStart()
 61660  			if yyl2 == 0 {
 61661  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 61662  			} else {
 61663  				x.codecDecodeSelfFromMap(yyl2, d)
 61664  			}
 61665  		} else if yyct2 == codecSelferValueTypeArray100 {
 61666  			yyl2 := r.ReadArrayStart()
 61667  			if yyl2 == 0 {
 61668  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61669  			} else {
 61670  				x.codecDecodeSelfFromArray(yyl2, d)
 61671  			}
 61672  		} else {
 61673  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 61674  		}
 61675  	}
 61676  }
 61677  
 61678  func (x *Deployment) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 61679  	var h codecSelfer100
 61680  	z, r := codec1978.GenHelperDecoder(d)
 61681  	_, _, _ = h, z, r
 61682  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 61683  	_ = yys3Slc
 61684  	var yyhl3 bool = l >= 0
 61685  	for yyj3 := 0; ; yyj3++ {
 61686  		if yyhl3 {
 61687  			if yyj3 >= l {
 61688  				break
 61689  			}
 61690  		} else {
 61691  			if r.CheckBreak() {
 61692  				break
 61693  			}
 61694  		}
 61695  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 61696  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 61697  		yys3 := string(yys3Slc)
 61698  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 61699  		switch yys3 {
 61700  		case "ID":
 61701  			if r.TryDecodeAsNil() {
 61702  				x.ID = ""
 61703  			} else {
 61704  				yyv4 := &x.ID
 61705  				yym5 := z.DecBinary()
 61706  				_ = yym5
 61707  				if false {
 61708  				} else {
 61709  					*((*string)(yyv4)) = r.DecodeString()
 61710  				}
 61711  			}
 61712  		case "Namespace":
 61713  			if r.TryDecodeAsNil() {
 61714  				x.Namespace = ""
 61715  			} else {
 61716  				yyv6 := &x.Namespace
 61717  				yym7 := z.DecBinary()
 61718  				_ = yym7
 61719  				if false {
 61720  				} else {
 61721  					*((*string)(yyv6)) = r.DecodeString()
 61722  				}
 61723  			}
 61724  		case "JobID":
 61725  			if r.TryDecodeAsNil() {
 61726  				x.JobID = ""
 61727  			} else {
 61728  				yyv8 := &x.JobID
 61729  				yym9 := z.DecBinary()
 61730  				_ = yym9
 61731  				if false {
 61732  				} else {
 61733  					*((*string)(yyv8)) = r.DecodeString()
 61734  				}
 61735  			}
 61736  		case "JobVersion":
 61737  			if r.TryDecodeAsNil() {
 61738  				x.JobVersion = 0
 61739  			} else {
 61740  				yyv10 := &x.JobVersion
 61741  				yym11 := z.DecBinary()
 61742  				_ = yym11
 61743  				if false {
 61744  				} else {
 61745  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 61746  				}
 61747  			}
 61748  		case "JobModifyIndex":
 61749  			if r.TryDecodeAsNil() {
 61750  				x.JobModifyIndex = 0
 61751  			} else {
 61752  				yyv12 := &x.JobModifyIndex
 61753  				yym13 := z.DecBinary()
 61754  				_ = yym13
 61755  				if false {
 61756  				} else {
 61757  					*((*uint64)(yyv12)) = uint64(r.DecodeUint(64))
 61758  				}
 61759  			}
 61760  		case "JobCreateIndex":
 61761  			if r.TryDecodeAsNil() {
 61762  				x.JobCreateIndex = 0
 61763  			} else {
 61764  				yyv14 := &x.JobCreateIndex
 61765  				yym15 := z.DecBinary()
 61766  				_ = yym15
 61767  				if false {
 61768  				} else {
 61769  					*((*uint64)(yyv14)) = uint64(r.DecodeUint(64))
 61770  				}
 61771  			}
 61772  		case "TaskGroups":
 61773  			if r.TryDecodeAsNil() {
 61774  				x.TaskGroups = nil
 61775  			} else {
 61776  				yyv16 := &x.TaskGroups
 61777  				yym17 := z.DecBinary()
 61778  				_ = yym17
 61779  				if false {
 61780  				} else {
 61781  					h.decMapstringPtrtoDeploymentState((*map[string]*DeploymentState)(yyv16), d)
 61782  				}
 61783  			}
 61784  		case "Status":
 61785  			if r.TryDecodeAsNil() {
 61786  				x.Status = ""
 61787  			} else {
 61788  				yyv18 := &x.Status
 61789  				yym19 := z.DecBinary()
 61790  				_ = yym19
 61791  				if false {
 61792  				} else {
 61793  					*((*string)(yyv18)) = r.DecodeString()
 61794  				}
 61795  			}
 61796  		case "StatusDescription":
 61797  			if r.TryDecodeAsNil() {
 61798  				x.StatusDescription = ""
 61799  			} else {
 61800  				yyv20 := &x.StatusDescription
 61801  				yym21 := z.DecBinary()
 61802  				_ = yym21
 61803  				if false {
 61804  				} else {
 61805  					*((*string)(yyv20)) = r.DecodeString()
 61806  				}
 61807  			}
 61808  		case "CreateIndex":
 61809  			if r.TryDecodeAsNil() {
 61810  				x.CreateIndex = 0
 61811  			} else {
 61812  				yyv22 := &x.CreateIndex
 61813  				yym23 := z.DecBinary()
 61814  				_ = yym23
 61815  				if false {
 61816  				} else {
 61817  					*((*uint64)(yyv22)) = uint64(r.DecodeUint(64))
 61818  				}
 61819  			}
 61820  		case "ModifyIndex":
 61821  			if r.TryDecodeAsNil() {
 61822  				x.ModifyIndex = 0
 61823  			} else {
 61824  				yyv24 := &x.ModifyIndex
 61825  				yym25 := z.DecBinary()
 61826  				_ = yym25
 61827  				if false {
 61828  				} else {
 61829  					*((*uint64)(yyv24)) = uint64(r.DecodeUint(64))
 61830  				}
 61831  			}
 61832  		default:
 61833  			z.DecStructFieldNotFound(-1, yys3)
 61834  		} // end switch yys3
 61835  	} // end for yyj3
 61836  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 61837  }
 61838  
 61839  func (x *Deployment) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 61840  	var h codecSelfer100
 61841  	z, r := codec1978.GenHelperDecoder(d)
 61842  	_, _, _ = h, z, r
 61843  	var yyj26 int
 61844  	var yyb26 bool
 61845  	var yyhl26 bool = l >= 0
 61846  	yyj26++
 61847  	if yyhl26 {
 61848  		yyb26 = yyj26 > l
 61849  	} else {
 61850  		yyb26 = r.CheckBreak()
 61851  	}
 61852  	if yyb26 {
 61853  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61854  		return
 61855  	}
 61856  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 61857  	if r.TryDecodeAsNil() {
 61858  		x.ID = ""
 61859  	} else {
 61860  		yyv27 := &x.ID
 61861  		yym28 := z.DecBinary()
 61862  		_ = yym28
 61863  		if false {
 61864  		} else {
 61865  			*((*string)(yyv27)) = r.DecodeString()
 61866  		}
 61867  	}
 61868  	yyj26++
 61869  	if yyhl26 {
 61870  		yyb26 = yyj26 > l
 61871  	} else {
 61872  		yyb26 = r.CheckBreak()
 61873  	}
 61874  	if yyb26 {
 61875  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61876  		return
 61877  	}
 61878  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 61879  	if r.TryDecodeAsNil() {
 61880  		x.Namespace = ""
 61881  	} else {
 61882  		yyv29 := &x.Namespace
 61883  		yym30 := z.DecBinary()
 61884  		_ = yym30
 61885  		if false {
 61886  		} else {
 61887  			*((*string)(yyv29)) = r.DecodeString()
 61888  		}
 61889  	}
 61890  	yyj26++
 61891  	if yyhl26 {
 61892  		yyb26 = yyj26 > l
 61893  	} else {
 61894  		yyb26 = r.CheckBreak()
 61895  	}
 61896  	if yyb26 {
 61897  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61898  		return
 61899  	}
 61900  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 61901  	if r.TryDecodeAsNil() {
 61902  		x.JobID = ""
 61903  	} else {
 61904  		yyv31 := &x.JobID
 61905  		yym32 := z.DecBinary()
 61906  		_ = yym32
 61907  		if false {
 61908  		} else {
 61909  			*((*string)(yyv31)) = r.DecodeString()
 61910  		}
 61911  	}
 61912  	yyj26++
 61913  	if yyhl26 {
 61914  		yyb26 = yyj26 > l
 61915  	} else {
 61916  		yyb26 = r.CheckBreak()
 61917  	}
 61918  	if yyb26 {
 61919  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61920  		return
 61921  	}
 61922  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 61923  	if r.TryDecodeAsNil() {
 61924  		x.JobVersion = 0
 61925  	} else {
 61926  		yyv33 := &x.JobVersion
 61927  		yym34 := z.DecBinary()
 61928  		_ = yym34
 61929  		if false {
 61930  		} else {
 61931  			*((*uint64)(yyv33)) = uint64(r.DecodeUint(64))
 61932  		}
 61933  	}
 61934  	yyj26++
 61935  	if yyhl26 {
 61936  		yyb26 = yyj26 > l
 61937  	} else {
 61938  		yyb26 = r.CheckBreak()
 61939  	}
 61940  	if yyb26 {
 61941  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61942  		return
 61943  	}
 61944  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 61945  	if r.TryDecodeAsNil() {
 61946  		x.JobModifyIndex = 0
 61947  	} else {
 61948  		yyv35 := &x.JobModifyIndex
 61949  		yym36 := z.DecBinary()
 61950  		_ = yym36
 61951  		if false {
 61952  		} else {
 61953  			*((*uint64)(yyv35)) = uint64(r.DecodeUint(64))
 61954  		}
 61955  	}
 61956  	yyj26++
 61957  	if yyhl26 {
 61958  		yyb26 = yyj26 > l
 61959  	} else {
 61960  		yyb26 = r.CheckBreak()
 61961  	}
 61962  	if yyb26 {
 61963  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61964  		return
 61965  	}
 61966  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 61967  	if r.TryDecodeAsNil() {
 61968  		x.JobCreateIndex = 0
 61969  	} else {
 61970  		yyv37 := &x.JobCreateIndex
 61971  		yym38 := z.DecBinary()
 61972  		_ = yym38
 61973  		if false {
 61974  		} else {
 61975  			*((*uint64)(yyv37)) = uint64(r.DecodeUint(64))
 61976  		}
 61977  	}
 61978  	yyj26++
 61979  	if yyhl26 {
 61980  		yyb26 = yyj26 > l
 61981  	} else {
 61982  		yyb26 = r.CheckBreak()
 61983  	}
 61984  	if yyb26 {
 61985  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 61986  		return
 61987  	}
 61988  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 61989  	if r.TryDecodeAsNil() {
 61990  		x.TaskGroups = nil
 61991  	} else {
 61992  		yyv39 := &x.TaskGroups
 61993  		yym40 := z.DecBinary()
 61994  		_ = yym40
 61995  		if false {
 61996  		} else {
 61997  			h.decMapstringPtrtoDeploymentState((*map[string]*DeploymentState)(yyv39), d)
 61998  		}
 61999  	}
 62000  	yyj26++
 62001  	if yyhl26 {
 62002  		yyb26 = yyj26 > l
 62003  	} else {
 62004  		yyb26 = r.CheckBreak()
 62005  	}
 62006  	if yyb26 {
 62007  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62008  		return
 62009  	}
 62010  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62011  	if r.TryDecodeAsNil() {
 62012  		x.Status = ""
 62013  	} else {
 62014  		yyv41 := &x.Status
 62015  		yym42 := z.DecBinary()
 62016  		_ = yym42
 62017  		if false {
 62018  		} else {
 62019  			*((*string)(yyv41)) = r.DecodeString()
 62020  		}
 62021  	}
 62022  	yyj26++
 62023  	if yyhl26 {
 62024  		yyb26 = yyj26 > l
 62025  	} else {
 62026  		yyb26 = r.CheckBreak()
 62027  	}
 62028  	if yyb26 {
 62029  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62030  		return
 62031  	}
 62032  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62033  	if r.TryDecodeAsNil() {
 62034  		x.StatusDescription = ""
 62035  	} else {
 62036  		yyv43 := &x.StatusDescription
 62037  		yym44 := z.DecBinary()
 62038  		_ = yym44
 62039  		if false {
 62040  		} else {
 62041  			*((*string)(yyv43)) = r.DecodeString()
 62042  		}
 62043  	}
 62044  	yyj26++
 62045  	if yyhl26 {
 62046  		yyb26 = yyj26 > l
 62047  	} else {
 62048  		yyb26 = r.CheckBreak()
 62049  	}
 62050  	if yyb26 {
 62051  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62052  		return
 62053  	}
 62054  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62055  	if r.TryDecodeAsNil() {
 62056  		x.CreateIndex = 0
 62057  	} else {
 62058  		yyv45 := &x.CreateIndex
 62059  		yym46 := z.DecBinary()
 62060  		_ = yym46
 62061  		if false {
 62062  		} else {
 62063  			*((*uint64)(yyv45)) = uint64(r.DecodeUint(64))
 62064  		}
 62065  	}
 62066  	yyj26++
 62067  	if yyhl26 {
 62068  		yyb26 = yyj26 > l
 62069  	} else {
 62070  		yyb26 = r.CheckBreak()
 62071  	}
 62072  	if yyb26 {
 62073  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62074  		return
 62075  	}
 62076  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62077  	if r.TryDecodeAsNil() {
 62078  		x.ModifyIndex = 0
 62079  	} else {
 62080  		yyv47 := &x.ModifyIndex
 62081  		yym48 := z.DecBinary()
 62082  		_ = yym48
 62083  		if false {
 62084  		} else {
 62085  			*((*uint64)(yyv47)) = uint64(r.DecodeUint(64))
 62086  		}
 62087  	}
 62088  	for {
 62089  		yyj26++
 62090  		if yyhl26 {
 62091  			yyb26 = yyj26 > l
 62092  		} else {
 62093  			yyb26 = r.CheckBreak()
 62094  		}
 62095  		if yyb26 {
 62096  			break
 62097  		}
 62098  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62099  		z.DecStructFieldNotFound(yyj26-1, "")
 62100  	}
 62101  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62102  }
 62103  
 62104  func (x *DeploymentState) CodecEncodeSelf(e *codec1978.Encoder) {
 62105  	var h codecSelfer100
 62106  	z, r := codec1978.GenHelperEncoder(e)
 62107  	_, _, _ = h, z, r
 62108  	if x == nil {
 62109  		r.EncodeNil()
 62110  	} else {
 62111  		yym1 := z.EncBinary()
 62112  		_ = yym1
 62113  		if false {
 62114  		} else if z.HasExtensions() && z.EncExt(x) {
 62115  		} else {
 62116  			yysep2 := !z.EncBinary()
 62117  			yy2arr2 := z.EncBasicHandle().StructToArray
 62118  			var yyq2 [8]bool
 62119  			_, _, _ = yysep2, yyq2, yy2arr2
 62120  			const yyr2 bool = false
 62121  			var yynn2 int
 62122  			if yyr2 || yy2arr2 {
 62123  				r.EncodeArrayStart(8)
 62124  			} else {
 62125  				yynn2 = 8
 62126  				for _, b := range yyq2 {
 62127  					if b {
 62128  						yynn2++
 62129  					}
 62130  				}
 62131  				r.EncodeMapStart(yynn2)
 62132  				yynn2 = 0
 62133  			}
 62134  			if yyr2 || yy2arr2 {
 62135  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 62136  				yym4 := z.EncBinary()
 62137  				_ = yym4
 62138  				if false {
 62139  				} else {
 62140  					r.EncodeBool(bool(x.AutoRevert))
 62141  				}
 62142  			} else {
 62143  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 62144  				r.EncodeString(codecSelferC_UTF8100, string("AutoRevert"))
 62145  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 62146  				yym5 := z.EncBinary()
 62147  				_ = yym5
 62148  				if false {
 62149  				} else {
 62150  					r.EncodeBool(bool(x.AutoRevert))
 62151  				}
 62152  			}
 62153  			if yyr2 || yy2arr2 {
 62154  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 62155  				yym7 := z.EncBinary()
 62156  				_ = yym7
 62157  				if false {
 62158  				} else {
 62159  					r.EncodeBool(bool(x.Promoted))
 62160  				}
 62161  			} else {
 62162  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 62163  				r.EncodeString(codecSelferC_UTF8100, string("Promoted"))
 62164  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 62165  				yym8 := z.EncBinary()
 62166  				_ = yym8
 62167  				if false {
 62168  				} else {
 62169  					r.EncodeBool(bool(x.Promoted))
 62170  				}
 62171  			}
 62172  			if yyr2 || yy2arr2 {
 62173  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 62174  				if x.PlacedCanaries == nil {
 62175  					r.EncodeNil()
 62176  				} else {
 62177  					yym10 := z.EncBinary()
 62178  					_ = yym10
 62179  					if false {
 62180  					} else {
 62181  						z.F.EncSliceStringV(x.PlacedCanaries, false, e)
 62182  					}
 62183  				}
 62184  			} else {
 62185  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 62186  				r.EncodeString(codecSelferC_UTF8100, string("PlacedCanaries"))
 62187  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 62188  				if x.PlacedCanaries == nil {
 62189  					r.EncodeNil()
 62190  				} else {
 62191  					yym11 := z.EncBinary()
 62192  					_ = yym11
 62193  					if false {
 62194  					} else {
 62195  						z.F.EncSliceStringV(x.PlacedCanaries, false, e)
 62196  					}
 62197  				}
 62198  			}
 62199  			if yyr2 || yy2arr2 {
 62200  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 62201  				yym13 := z.EncBinary()
 62202  				_ = yym13
 62203  				if false {
 62204  				} else {
 62205  					r.EncodeInt(int64(x.DesiredCanaries))
 62206  				}
 62207  			} else {
 62208  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 62209  				r.EncodeString(codecSelferC_UTF8100, string("DesiredCanaries"))
 62210  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 62211  				yym14 := z.EncBinary()
 62212  				_ = yym14
 62213  				if false {
 62214  				} else {
 62215  					r.EncodeInt(int64(x.DesiredCanaries))
 62216  				}
 62217  			}
 62218  			if yyr2 || yy2arr2 {
 62219  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 62220  				yym16 := z.EncBinary()
 62221  				_ = yym16
 62222  				if false {
 62223  				} else {
 62224  					r.EncodeInt(int64(x.DesiredTotal))
 62225  				}
 62226  			} else {
 62227  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 62228  				r.EncodeString(codecSelferC_UTF8100, string("DesiredTotal"))
 62229  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 62230  				yym17 := z.EncBinary()
 62231  				_ = yym17
 62232  				if false {
 62233  				} else {
 62234  					r.EncodeInt(int64(x.DesiredTotal))
 62235  				}
 62236  			}
 62237  			if yyr2 || yy2arr2 {
 62238  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 62239  				yym19 := z.EncBinary()
 62240  				_ = yym19
 62241  				if false {
 62242  				} else {
 62243  					r.EncodeInt(int64(x.PlacedAllocs))
 62244  				}
 62245  			} else {
 62246  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 62247  				r.EncodeString(codecSelferC_UTF8100, string("PlacedAllocs"))
 62248  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 62249  				yym20 := z.EncBinary()
 62250  				_ = yym20
 62251  				if false {
 62252  				} else {
 62253  					r.EncodeInt(int64(x.PlacedAllocs))
 62254  				}
 62255  			}
 62256  			if yyr2 || yy2arr2 {
 62257  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 62258  				yym22 := z.EncBinary()
 62259  				_ = yym22
 62260  				if false {
 62261  				} else {
 62262  					r.EncodeInt(int64(x.HealthyAllocs))
 62263  				}
 62264  			} else {
 62265  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 62266  				r.EncodeString(codecSelferC_UTF8100, string("HealthyAllocs"))
 62267  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 62268  				yym23 := z.EncBinary()
 62269  				_ = yym23
 62270  				if false {
 62271  				} else {
 62272  					r.EncodeInt(int64(x.HealthyAllocs))
 62273  				}
 62274  			}
 62275  			if yyr2 || yy2arr2 {
 62276  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 62277  				yym25 := z.EncBinary()
 62278  				_ = yym25
 62279  				if false {
 62280  				} else {
 62281  					r.EncodeInt(int64(x.UnhealthyAllocs))
 62282  				}
 62283  			} else {
 62284  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 62285  				r.EncodeString(codecSelferC_UTF8100, string("UnhealthyAllocs"))
 62286  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 62287  				yym26 := z.EncBinary()
 62288  				_ = yym26
 62289  				if false {
 62290  				} else {
 62291  					r.EncodeInt(int64(x.UnhealthyAllocs))
 62292  				}
 62293  			}
 62294  			if yyr2 || yy2arr2 {
 62295  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 62296  			} else {
 62297  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 62298  			}
 62299  		}
 62300  	}
 62301  }
 62302  
 62303  func (x *DeploymentState) CodecDecodeSelf(d *codec1978.Decoder) {
 62304  	var h codecSelfer100
 62305  	z, r := codec1978.GenHelperDecoder(d)
 62306  	_, _, _ = h, z, r
 62307  	yym1 := z.DecBinary()
 62308  	_ = yym1
 62309  	if false {
 62310  	} else if z.HasExtensions() && z.DecExt(x) {
 62311  	} else {
 62312  		yyct2 := r.ContainerType()
 62313  		if yyct2 == codecSelferValueTypeMap100 {
 62314  			yyl2 := r.ReadMapStart()
 62315  			if yyl2 == 0 {
 62316  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 62317  			} else {
 62318  				x.codecDecodeSelfFromMap(yyl2, d)
 62319  			}
 62320  		} else if yyct2 == codecSelferValueTypeArray100 {
 62321  			yyl2 := r.ReadArrayStart()
 62322  			if yyl2 == 0 {
 62323  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62324  			} else {
 62325  				x.codecDecodeSelfFromArray(yyl2, d)
 62326  			}
 62327  		} else {
 62328  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 62329  		}
 62330  	}
 62331  }
 62332  
 62333  func (x *DeploymentState) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 62334  	var h codecSelfer100
 62335  	z, r := codec1978.GenHelperDecoder(d)
 62336  	_, _, _ = h, z, r
 62337  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 62338  	_ = yys3Slc
 62339  	var yyhl3 bool = l >= 0
 62340  	for yyj3 := 0; ; yyj3++ {
 62341  		if yyhl3 {
 62342  			if yyj3 >= l {
 62343  				break
 62344  			}
 62345  		} else {
 62346  			if r.CheckBreak() {
 62347  				break
 62348  			}
 62349  		}
 62350  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 62351  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 62352  		yys3 := string(yys3Slc)
 62353  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 62354  		switch yys3 {
 62355  		case "AutoRevert":
 62356  			if r.TryDecodeAsNil() {
 62357  				x.AutoRevert = false
 62358  			} else {
 62359  				yyv4 := &x.AutoRevert
 62360  				yym5 := z.DecBinary()
 62361  				_ = yym5
 62362  				if false {
 62363  				} else {
 62364  					*((*bool)(yyv4)) = r.DecodeBool()
 62365  				}
 62366  			}
 62367  		case "Promoted":
 62368  			if r.TryDecodeAsNil() {
 62369  				x.Promoted = false
 62370  			} else {
 62371  				yyv6 := &x.Promoted
 62372  				yym7 := z.DecBinary()
 62373  				_ = yym7
 62374  				if false {
 62375  				} else {
 62376  					*((*bool)(yyv6)) = r.DecodeBool()
 62377  				}
 62378  			}
 62379  		case "PlacedCanaries":
 62380  			if r.TryDecodeAsNil() {
 62381  				x.PlacedCanaries = nil
 62382  			} else {
 62383  				yyv8 := &x.PlacedCanaries
 62384  				yym9 := z.DecBinary()
 62385  				_ = yym9
 62386  				if false {
 62387  				} else {
 62388  					z.F.DecSliceStringX(yyv8, false, d)
 62389  				}
 62390  			}
 62391  		case "DesiredCanaries":
 62392  			if r.TryDecodeAsNil() {
 62393  				x.DesiredCanaries = 0
 62394  			} else {
 62395  				yyv10 := &x.DesiredCanaries
 62396  				yym11 := z.DecBinary()
 62397  				_ = yym11
 62398  				if false {
 62399  				} else {
 62400  					*((*int)(yyv10)) = int(r.DecodeInt(codecSelferBitsize100))
 62401  				}
 62402  			}
 62403  		case "DesiredTotal":
 62404  			if r.TryDecodeAsNil() {
 62405  				x.DesiredTotal = 0
 62406  			} else {
 62407  				yyv12 := &x.DesiredTotal
 62408  				yym13 := z.DecBinary()
 62409  				_ = yym13
 62410  				if false {
 62411  				} else {
 62412  					*((*int)(yyv12)) = int(r.DecodeInt(codecSelferBitsize100))
 62413  				}
 62414  			}
 62415  		case "PlacedAllocs":
 62416  			if r.TryDecodeAsNil() {
 62417  				x.PlacedAllocs = 0
 62418  			} else {
 62419  				yyv14 := &x.PlacedAllocs
 62420  				yym15 := z.DecBinary()
 62421  				_ = yym15
 62422  				if false {
 62423  				} else {
 62424  					*((*int)(yyv14)) = int(r.DecodeInt(codecSelferBitsize100))
 62425  				}
 62426  			}
 62427  		case "HealthyAllocs":
 62428  			if r.TryDecodeAsNil() {
 62429  				x.HealthyAllocs = 0
 62430  			} else {
 62431  				yyv16 := &x.HealthyAllocs
 62432  				yym17 := z.DecBinary()
 62433  				_ = yym17
 62434  				if false {
 62435  				} else {
 62436  					*((*int)(yyv16)) = int(r.DecodeInt(codecSelferBitsize100))
 62437  				}
 62438  			}
 62439  		case "UnhealthyAllocs":
 62440  			if r.TryDecodeAsNil() {
 62441  				x.UnhealthyAllocs = 0
 62442  			} else {
 62443  				yyv18 := &x.UnhealthyAllocs
 62444  				yym19 := z.DecBinary()
 62445  				_ = yym19
 62446  				if false {
 62447  				} else {
 62448  					*((*int)(yyv18)) = int(r.DecodeInt(codecSelferBitsize100))
 62449  				}
 62450  			}
 62451  		default:
 62452  			z.DecStructFieldNotFound(-1, yys3)
 62453  		} // end switch yys3
 62454  	} // end for yyj3
 62455  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 62456  }
 62457  
 62458  func (x *DeploymentState) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 62459  	var h codecSelfer100
 62460  	z, r := codec1978.GenHelperDecoder(d)
 62461  	_, _, _ = h, z, r
 62462  	var yyj20 int
 62463  	var yyb20 bool
 62464  	var yyhl20 bool = l >= 0
 62465  	yyj20++
 62466  	if yyhl20 {
 62467  		yyb20 = yyj20 > l
 62468  	} else {
 62469  		yyb20 = r.CheckBreak()
 62470  	}
 62471  	if yyb20 {
 62472  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62473  		return
 62474  	}
 62475  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62476  	if r.TryDecodeAsNil() {
 62477  		x.AutoRevert = false
 62478  	} else {
 62479  		yyv21 := &x.AutoRevert
 62480  		yym22 := z.DecBinary()
 62481  		_ = yym22
 62482  		if false {
 62483  		} else {
 62484  			*((*bool)(yyv21)) = r.DecodeBool()
 62485  		}
 62486  	}
 62487  	yyj20++
 62488  	if yyhl20 {
 62489  		yyb20 = yyj20 > l
 62490  	} else {
 62491  		yyb20 = r.CheckBreak()
 62492  	}
 62493  	if yyb20 {
 62494  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62495  		return
 62496  	}
 62497  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62498  	if r.TryDecodeAsNil() {
 62499  		x.Promoted = false
 62500  	} else {
 62501  		yyv23 := &x.Promoted
 62502  		yym24 := z.DecBinary()
 62503  		_ = yym24
 62504  		if false {
 62505  		} else {
 62506  			*((*bool)(yyv23)) = r.DecodeBool()
 62507  		}
 62508  	}
 62509  	yyj20++
 62510  	if yyhl20 {
 62511  		yyb20 = yyj20 > l
 62512  	} else {
 62513  		yyb20 = r.CheckBreak()
 62514  	}
 62515  	if yyb20 {
 62516  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62517  		return
 62518  	}
 62519  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62520  	if r.TryDecodeAsNil() {
 62521  		x.PlacedCanaries = nil
 62522  	} else {
 62523  		yyv25 := &x.PlacedCanaries
 62524  		yym26 := z.DecBinary()
 62525  		_ = yym26
 62526  		if false {
 62527  		} else {
 62528  			z.F.DecSliceStringX(yyv25, false, d)
 62529  		}
 62530  	}
 62531  	yyj20++
 62532  	if yyhl20 {
 62533  		yyb20 = yyj20 > l
 62534  	} else {
 62535  		yyb20 = r.CheckBreak()
 62536  	}
 62537  	if yyb20 {
 62538  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62539  		return
 62540  	}
 62541  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62542  	if r.TryDecodeAsNil() {
 62543  		x.DesiredCanaries = 0
 62544  	} else {
 62545  		yyv27 := &x.DesiredCanaries
 62546  		yym28 := z.DecBinary()
 62547  		_ = yym28
 62548  		if false {
 62549  		} else {
 62550  			*((*int)(yyv27)) = int(r.DecodeInt(codecSelferBitsize100))
 62551  		}
 62552  	}
 62553  	yyj20++
 62554  	if yyhl20 {
 62555  		yyb20 = yyj20 > l
 62556  	} else {
 62557  		yyb20 = r.CheckBreak()
 62558  	}
 62559  	if yyb20 {
 62560  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62561  		return
 62562  	}
 62563  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62564  	if r.TryDecodeAsNil() {
 62565  		x.DesiredTotal = 0
 62566  	} else {
 62567  		yyv29 := &x.DesiredTotal
 62568  		yym30 := z.DecBinary()
 62569  		_ = yym30
 62570  		if false {
 62571  		} else {
 62572  			*((*int)(yyv29)) = int(r.DecodeInt(codecSelferBitsize100))
 62573  		}
 62574  	}
 62575  	yyj20++
 62576  	if yyhl20 {
 62577  		yyb20 = yyj20 > l
 62578  	} else {
 62579  		yyb20 = r.CheckBreak()
 62580  	}
 62581  	if yyb20 {
 62582  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62583  		return
 62584  	}
 62585  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62586  	if r.TryDecodeAsNil() {
 62587  		x.PlacedAllocs = 0
 62588  	} else {
 62589  		yyv31 := &x.PlacedAllocs
 62590  		yym32 := z.DecBinary()
 62591  		_ = yym32
 62592  		if false {
 62593  		} else {
 62594  			*((*int)(yyv31)) = int(r.DecodeInt(codecSelferBitsize100))
 62595  		}
 62596  	}
 62597  	yyj20++
 62598  	if yyhl20 {
 62599  		yyb20 = yyj20 > l
 62600  	} else {
 62601  		yyb20 = r.CheckBreak()
 62602  	}
 62603  	if yyb20 {
 62604  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62605  		return
 62606  	}
 62607  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62608  	if r.TryDecodeAsNil() {
 62609  		x.HealthyAllocs = 0
 62610  	} else {
 62611  		yyv33 := &x.HealthyAllocs
 62612  		yym34 := z.DecBinary()
 62613  		_ = yym34
 62614  		if false {
 62615  		} else {
 62616  			*((*int)(yyv33)) = int(r.DecodeInt(codecSelferBitsize100))
 62617  		}
 62618  	}
 62619  	yyj20++
 62620  	if yyhl20 {
 62621  		yyb20 = yyj20 > l
 62622  	} else {
 62623  		yyb20 = r.CheckBreak()
 62624  	}
 62625  	if yyb20 {
 62626  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62627  		return
 62628  	}
 62629  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62630  	if r.TryDecodeAsNil() {
 62631  		x.UnhealthyAllocs = 0
 62632  	} else {
 62633  		yyv35 := &x.UnhealthyAllocs
 62634  		yym36 := z.DecBinary()
 62635  		_ = yym36
 62636  		if false {
 62637  		} else {
 62638  			*((*int)(yyv35)) = int(r.DecodeInt(codecSelferBitsize100))
 62639  		}
 62640  	}
 62641  	for {
 62642  		yyj20++
 62643  		if yyhl20 {
 62644  			yyb20 = yyj20 > l
 62645  		} else {
 62646  			yyb20 = r.CheckBreak()
 62647  		}
 62648  		if yyb20 {
 62649  			break
 62650  		}
 62651  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62652  		z.DecStructFieldNotFound(yyj20-1, "")
 62653  	}
 62654  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62655  }
 62656  
 62657  func (x *DeploymentStatusUpdate) CodecEncodeSelf(e *codec1978.Encoder) {
 62658  	var h codecSelfer100
 62659  	z, r := codec1978.GenHelperEncoder(e)
 62660  	_, _, _ = h, z, r
 62661  	if x == nil {
 62662  		r.EncodeNil()
 62663  	} else {
 62664  		yym1 := z.EncBinary()
 62665  		_ = yym1
 62666  		if false {
 62667  		} else if z.HasExtensions() && z.EncExt(x) {
 62668  		} else {
 62669  			yysep2 := !z.EncBinary()
 62670  			yy2arr2 := z.EncBasicHandle().StructToArray
 62671  			var yyq2 [3]bool
 62672  			_, _, _ = yysep2, yyq2, yy2arr2
 62673  			const yyr2 bool = false
 62674  			var yynn2 int
 62675  			if yyr2 || yy2arr2 {
 62676  				r.EncodeArrayStart(3)
 62677  			} else {
 62678  				yynn2 = 3
 62679  				for _, b := range yyq2 {
 62680  					if b {
 62681  						yynn2++
 62682  					}
 62683  				}
 62684  				r.EncodeMapStart(yynn2)
 62685  				yynn2 = 0
 62686  			}
 62687  			if yyr2 || yy2arr2 {
 62688  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 62689  				yym4 := z.EncBinary()
 62690  				_ = yym4
 62691  				if false {
 62692  				} else {
 62693  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 62694  				}
 62695  			} else {
 62696  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 62697  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentID"))
 62698  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 62699  				yym5 := z.EncBinary()
 62700  				_ = yym5
 62701  				if false {
 62702  				} else {
 62703  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 62704  				}
 62705  			}
 62706  			if yyr2 || yy2arr2 {
 62707  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 62708  				yym7 := z.EncBinary()
 62709  				_ = yym7
 62710  				if false {
 62711  				} else {
 62712  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 62713  				}
 62714  			} else {
 62715  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 62716  				r.EncodeString(codecSelferC_UTF8100, string("Status"))
 62717  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 62718  				yym8 := z.EncBinary()
 62719  				_ = yym8
 62720  				if false {
 62721  				} else {
 62722  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 62723  				}
 62724  			}
 62725  			if yyr2 || yy2arr2 {
 62726  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 62727  				yym10 := z.EncBinary()
 62728  				_ = yym10
 62729  				if false {
 62730  				} else {
 62731  					r.EncodeString(codecSelferC_UTF8100, string(x.StatusDescription))
 62732  				}
 62733  			} else {
 62734  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 62735  				r.EncodeString(codecSelferC_UTF8100, string("StatusDescription"))
 62736  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 62737  				yym11 := z.EncBinary()
 62738  				_ = yym11
 62739  				if false {
 62740  				} else {
 62741  					r.EncodeString(codecSelferC_UTF8100, string(x.StatusDescription))
 62742  				}
 62743  			}
 62744  			if yyr2 || yy2arr2 {
 62745  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 62746  			} else {
 62747  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 62748  			}
 62749  		}
 62750  	}
 62751  }
 62752  
 62753  func (x *DeploymentStatusUpdate) CodecDecodeSelf(d *codec1978.Decoder) {
 62754  	var h codecSelfer100
 62755  	z, r := codec1978.GenHelperDecoder(d)
 62756  	_, _, _ = h, z, r
 62757  	yym1 := z.DecBinary()
 62758  	_ = yym1
 62759  	if false {
 62760  	} else if z.HasExtensions() && z.DecExt(x) {
 62761  	} else {
 62762  		yyct2 := r.ContainerType()
 62763  		if yyct2 == codecSelferValueTypeMap100 {
 62764  			yyl2 := r.ReadMapStart()
 62765  			if yyl2 == 0 {
 62766  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 62767  			} else {
 62768  				x.codecDecodeSelfFromMap(yyl2, d)
 62769  			}
 62770  		} else if yyct2 == codecSelferValueTypeArray100 {
 62771  			yyl2 := r.ReadArrayStart()
 62772  			if yyl2 == 0 {
 62773  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62774  			} else {
 62775  				x.codecDecodeSelfFromArray(yyl2, d)
 62776  			}
 62777  		} else {
 62778  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 62779  		}
 62780  	}
 62781  }
 62782  
 62783  func (x *DeploymentStatusUpdate) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 62784  	var h codecSelfer100
 62785  	z, r := codec1978.GenHelperDecoder(d)
 62786  	_, _, _ = h, z, r
 62787  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 62788  	_ = yys3Slc
 62789  	var yyhl3 bool = l >= 0
 62790  	for yyj3 := 0; ; yyj3++ {
 62791  		if yyhl3 {
 62792  			if yyj3 >= l {
 62793  				break
 62794  			}
 62795  		} else {
 62796  			if r.CheckBreak() {
 62797  				break
 62798  			}
 62799  		}
 62800  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 62801  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 62802  		yys3 := string(yys3Slc)
 62803  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 62804  		switch yys3 {
 62805  		case "DeploymentID":
 62806  			if r.TryDecodeAsNil() {
 62807  				x.DeploymentID = ""
 62808  			} else {
 62809  				yyv4 := &x.DeploymentID
 62810  				yym5 := z.DecBinary()
 62811  				_ = yym5
 62812  				if false {
 62813  				} else {
 62814  					*((*string)(yyv4)) = r.DecodeString()
 62815  				}
 62816  			}
 62817  		case "Status":
 62818  			if r.TryDecodeAsNil() {
 62819  				x.Status = ""
 62820  			} else {
 62821  				yyv6 := &x.Status
 62822  				yym7 := z.DecBinary()
 62823  				_ = yym7
 62824  				if false {
 62825  				} else {
 62826  					*((*string)(yyv6)) = r.DecodeString()
 62827  				}
 62828  			}
 62829  		case "StatusDescription":
 62830  			if r.TryDecodeAsNil() {
 62831  				x.StatusDescription = ""
 62832  			} else {
 62833  				yyv8 := &x.StatusDescription
 62834  				yym9 := z.DecBinary()
 62835  				_ = yym9
 62836  				if false {
 62837  				} else {
 62838  					*((*string)(yyv8)) = r.DecodeString()
 62839  				}
 62840  			}
 62841  		default:
 62842  			z.DecStructFieldNotFound(-1, yys3)
 62843  		} // end switch yys3
 62844  	} // end for yyj3
 62845  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 62846  }
 62847  
 62848  func (x *DeploymentStatusUpdate) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 62849  	var h codecSelfer100
 62850  	z, r := codec1978.GenHelperDecoder(d)
 62851  	_, _, _ = h, z, r
 62852  	var yyj10 int
 62853  	var yyb10 bool
 62854  	var yyhl10 bool = l >= 0
 62855  	yyj10++
 62856  	if yyhl10 {
 62857  		yyb10 = yyj10 > l
 62858  	} else {
 62859  		yyb10 = r.CheckBreak()
 62860  	}
 62861  	if yyb10 {
 62862  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62863  		return
 62864  	}
 62865  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62866  	if r.TryDecodeAsNil() {
 62867  		x.DeploymentID = ""
 62868  	} else {
 62869  		yyv11 := &x.DeploymentID
 62870  		yym12 := z.DecBinary()
 62871  		_ = yym12
 62872  		if false {
 62873  		} else {
 62874  			*((*string)(yyv11)) = r.DecodeString()
 62875  		}
 62876  	}
 62877  	yyj10++
 62878  	if yyhl10 {
 62879  		yyb10 = yyj10 > l
 62880  	} else {
 62881  		yyb10 = r.CheckBreak()
 62882  	}
 62883  	if yyb10 {
 62884  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62885  		return
 62886  	}
 62887  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62888  	if r.TryDecodeAsNil() {
 62889  		x.Status = ""
 62890  	} else {
 62891  		yyv13 := &x.Status
 62892  		yym14 := z.DecBinary()
 62893  		_ = yym14
 62894  		if false {
 62895  		} else {
 62896  			*((*string)(yyv13)) = r.DecodeString()
 62897  		}
 62898  	}
 62899  	yyj10++
 62900  	if yyhl10 {
 62901  		yyb10 = yyj10 > l
 62902  	} else {
 62903  		yyb10 = r.CheckBreak()
 62904  	}
 62905  	if yyb10 {
 62906  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62907  		return
 62908  	}
 62909  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62910  	if r.TryDecodeAsNil() {
 62911  		x.StatusDescription = ""
 62912  	} else {
 62913  		yyv15 := &x.StatusDescription
 62914  		yym16 := z.DecBinary()
 62915  		_ = yym16
 62916  		if false {
 62917  		} else {
 62918  			*((*string)(yyv15)) = r.DecodeString()
 62919  		}
 62920  	}
 62921  	for {
 62922  		yyj10++
 62923  		if yyhl10 {
 62924  			yyb10 = yyj10 > l
 62925  		} else {
 62926  			yyb10 = r.CheckBreak()
 62927  		}
 62928  		if yyb10 {
 62929  			break
 62930  		}
 62931  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 62932  		z.DecStructFieldNotFound(yyj10-1, "")
 62933  	}
 62934  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 62935  }
 62936  
 62937  func (x *RescheduleTracker) CodecEncodeSelf(e *codec1978.Encoder) {
 62938  	var h codecSelfer100
 62939  	z, r := codec1978.GenHelperEncoder(e)
 62940  	_, _, _ = h, z, r
 62941  	if x == nil {
 62942  		r.EncodeNil()
 62943  	} else {
 62944  		yym1 := z.EncBinary()
 62945  		_ = yym1
 62946  		if false {
 62947  		} else if z.HasExtensions() && z.EncExt(x) {
 62948  		} else {
 62949  			yysep2 := !z.EncBinary()
 62950  			yy2arr2 := z.EncBasicHandle().StructToArray
 62951  			var yyq2 [1]bool
 62952  			_, _, _ = yysep2, yyq2, yy2arr2
 62953  			const yyr2 bool = false
 62954  			var yynn2 int
 62955  			if yyr2 || yy2arr2 {
 62956  				r.EncodeArrayStart(1)
 62957  			} else {
 62958  				yynn2 = 1
 62959  				for _, b := range yyq2 {
 62960  					if b {
 62961  						yynn2++
 62962  					}
 62963  				}
 62964  				r.EncodeMapStart(yynn2)
 62965  				yynn2 = 0
 62966  			}
 62967  			if yyr2 || yy2arr2 {
 62968  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 62969  				if x.Events == nil {
 62970  					r.EncodeNil()
 62971  				} else {
 62972  					yym4 := z.EncBinary()
 62973  					_ = yym4
 62974  					if false {
 62975  					} else {
 62976  						h.encSlicePtrtoRescheduleEvent(([]*RescheduleEvent)(x.Events), e)
 62977  					}
 62978  				}
 62979  			} else {
 62980  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 62981  				r.EncodeString(codecSelferC_UTF8100, string("Events"))
 62982  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 62983  				if x.Events == nil {
 62984  					r.EncodeNil()
 62985  				} else {
 62986  					yym5 := z.EncBinary()
 62987  					_ = yym5
 62988  					if false {
 62989  					} else {
 62990  						h.encSlicePtrtoRescheduleEvent(([]*RescheduleEvent)(x.Events), e)
 62991  					}
 62992  				}
 62993  			}
 62994  			if yyr2 || yy2arr2 {
 62995  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 62996  			} else {
 62997  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 62998  			}
 62999  		}
 63000  	}
 63001  }
 63002  
 63003  func (x *RescheduleTracker) CodecDecodeSelf(d *codec1978.Decoder) {
 63004  	var h codecSelfer100
 63005  	z, r := codec1978.GenHelperDecoder(d)
 63006  	_, _, _ = h, z, r
 63007  	yym1 := z.DecBinary()
 63008  	_ = yym1
 63009  	if false {
 63010  	} else if z.HasExtensions() && z.DecExt(x) {
 63011  	} else {
 63012  		yyct2 := r.ContainerType()
 63013  		if yyct2 == codecSelferValueTypeMap100 {
 63014  			yyl2 := r.ReadMapStart()
 63015  			if yyl2 == 0 {
 63016  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 63017  			} else {
 63018  				x.codecDecodeSelfFromMap(yyl2, d)
 63019  			}
 63020  		} else if yyct2 == codecSelferValueTypeArray100 {
 63021  			yyl2 := r.ReadArrayStart()
 63022  			if yyl2 == 0 {
 63023  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 63024  			} else {
 63025  				x.codecDecodeSelfFromArray(yyl2, d)
 63026  			}
 63027  		} else {
 63028  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 63029  		}
 63030  	}
 63031  }
 63032  
 63033  func (x *RescheduleTracker) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 63034  	var h codecSelfer100
 63035  	z, r := codec1978.GenHelperDecoder(d)
 63036  	_, _, _ = h, z, r
 63037  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 63038  	_ = yys3Slc
 63039  	var yyhl3 bool = l >= 0
 63040  	for yyj3 := 0; ; yyj3++ {
 63041  		if yyhl3 {
 63042  			if yyj3 >= l {
 63043  				break
 63044  			}
 63045  		} else {
 63046  			if r.CheckBreak() {
 63047  				break
 63048  			}
 63049  		}
 63050  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 63051  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 63052  		yys3 := string(yys3Slc)
 63053  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 63054  		switch yys3 {
 63055  		case "Events":
 63056  			if r.TryDecodeAsNil() {
 63057  				x.Events = nil
 63058  			} else {
 63059  				yyv4 := &x.Events
 63060  				yym5 := z.DecBinary()
 63061  				_ = yym5
 63062  				if false {
 63063  				} else {
 63064  					h.decSlicePtrtoRescheduleEvent((*[]*RescheduleEvent)(yyv4), d)
 63065  				}
 63066  			}
 63067  		default:
 63068  			z.DecStructFieldNotFound(-1, yys3)
 63069  		} // end switch yys3
 63070  	} // end for yyj3
 63071  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 63072  }
 63073  
 63074  func (x *RescheduleTracker) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 63075  	var h codecSelfer100
 63076  	z, r := codec1978.GenHelperDecoder(d)
 63077  	_, _, _ = h, z, r
 63078  	var yyj6 int
 63079  	var yyb6 bool
 63080  	var yyhl6 bool = l >= 0
 63081  	yyj6++
 63082  	if yyhl6 {
 63083  		yyb6 = yyj6 > l
 63084  	} else {
 63085  		yyb6 = r.CheckBreak()
 63086  	}
 63087  	if yyb6 {
 63088  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 63089  		return
 63090  	}
 63091  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 63092  	if r.TryDecodeAsNil() {
 63093  		x.Events = nil
 63094  	} else {
 63095  		yyv7 := &x.Events
 63096  		yym8 := z.DecBinary()
 63097  		_ = yym8
 63098  		if false {
 63099  		} else {
 63100  			h.decSlicePtrtoRescheduleEvent((*[]*RescheduleEvent)(yyv7), d)
 63101  		}
 63102  	}
 63103  	for {
 63104  		yyj6++
 63105  		if yyhl6 {
 63106  			yyb6 = yyj6 > l
 63107  		} else {
 63108  			yyb6 = r.CheckBreak()
 63109  		}
 63110  		if yyb6 {
 63111  			break
 63112  		}
 63113  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 63114  		z.DecStructFieldNotFound(yyj6-1, "")
 63115  	}
 63116  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 63117  }
 63118  
 63119  func (x *RescheduleEvent) CodecEncodeSelf(e *codec1978.Encoder) {
 63120  	var h codecSelfer100
 63121  	z, r := codec1978.GenHelperEncoder(e)
 63122  	_, _, _ = h, z, r
 63123  	if x == nil {
 63124  		r.EncodeNil()
 63125  	} else {
 63126  		yym1 := z.EncBinary()
 63127  		_ = yym1
 63128  		if false {
 63129  		} else if z.HasExtensions() && z.EncExt(x) {
 63130  		} else {
 63131  			yysep2 := !z.EncBinary()
 63132  			yy2arr2 := z.EncBasicHandle().StructToArray
 63133  			var yyq2 [4]bool
 63134  			_, _, _ = yysep2, yyq2, yy2arr2
 63135  			const yyr2 bool = false
 63136  			var yynn2 int
 63137  			if yyr2 || yy2arr2 {
 63138  				r.EncodeArrayStart(4)
 63139  			} else {
 63140  				yynn2 = 4
 63141  				for _, b := range yyq2 {
 63142  					if b {
 63143  						yynn2++
 63144  					}
 63145  				}
 63146  				r.EncodeMapStart(yynn2)
 63147  				yynn2 = 0
 63148  			}
 63149  			if yyr2 || yy2arr2 {
 63150  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63151  				yym4 := z.EncBinary()
 63152  				_ = yym4
 63153  				if false {
 63154  				} else {
 63155  					r.EncodeInt(int64(x.RescheduleTime))
 63156  				}
 63157  			} else {
 63158  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63159  				r.EncodeString(codecSelferC_UTF8100, string("RescheduleTime"))
 63160  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63161  				yym5 := z.EncBinary()
 63162  				_ = yym5
 63163  				if false {
 63164  				} else {
 63165  					r.EncodeInt(int64(x.RescheduleTime))
 63166  				}
 63167  			}
 63168  			if yyr2 || yy2arr2 {
 63169  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63170  				yym7 := z.EncBinary()
 63171  				_ = yym7
 63172  				if false {
 63173  				} else {
 63174  					r.EncodeString(codecSelferC_UTF8100, string(x.PrevAllocID))
 63175  				}
 63176  			} else {
 63177  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63178  				r.EncodeString(codecSelferC_UTF8100, string("PrevAllocID"))
 63179  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63180  				yym8 := z.EncBinary()
 63181  				_ = yym8
 63182  				if false {
 63183  				} else {
 63184  					r.EncodeString(codecSelferC_UTF8100, string(x.PrevAllocID))
 63185  				}
 63186  			}
 63187  			if yyr2 || yy2arr2 {
 63188  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63189  				yym10 := z.EncBinary()
 63190  				_ = yym10
 63191  				if false {
 63192  				} else {
 63193  					r.EncodeString(codecSelferC_UTF8100, string(x.PrevNodeID))
 63194  				}
 63195  			} else {
 63196  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63197  				r.EncodeString(codecSelferC_UTF8100, string("PrevNodeID"))
 63198  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63199  				yym11 := z.EncBinary()
 63200  				_ = yym11
 63201  				if false {
 63202  				} else {
 63203  					r.EncodeString(codecSelferC_UTF8100, string(x.PrevNodeID))
 63204  				}
 63205  			}
 63206  			if yyr2 || yy2arr2 {
 63207  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63208  				yym13 := z.EncBinary()
 63209  				_ = yym13
 63210  				if false {
 63211  				} else if z.HasExtensions() && z.EncExt(x.Delay) {
 63212  				} else {
 63213  					r.EncodeInt(int64(x.Delay))
 63214  				}
 63215  			} else {
 63216  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63217  				r.EncodeString(codecSelferC_UTF8100, string("Delay"))
 63218  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63219  				yym14 := z.EncBinary()
 63220  				_ = yym14
 63221  				if false {
 63222  				} else if z.HasExtensions() && z.EncExt(x.Delay) {
 63223  				} else {
 63224  					r.EncodeInt(int64(x.Delay))
 63225  				}
 63226  			}
 63227  			if yyr2 || yy2arr2 {
 63228  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 63229  			} else {
 63230  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 63231  			}
 63232  		}
 63233  	}
 63234  }
 63235  
 63236  func (x *RescheduleEvent) CodecDecodeSelf(d *codec1978.Decoder) {
 63237  	var h codecSelfer100
 63238  	z, r := codec1978.GenHelperDecoder(d)
 63239  	_, _, _ = h, z, r
 63240  	yym1 := z.DecBinary()
 63241  	_ = yym1
 63242  	if false {
 63243  	} else if z.HasExtensions() && z.DecExt(x) {
 63244  	} else {
 63245  		yyct2 := r.ContainerType()
 63246  		if yyct2 == codecSelferValueTypeMap100 {
 63247  			yyl2 := r.ReadMapStart()
 63248  			if yyl2 == 0 {
 63249  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 63250  			} else {
 63251  				x.codecDecodeSelfFromMap(yyl2, d)
 63252  			}
 63253  		} else if yyct2 == codecSelferValueTypeArray100 {
 63254  			yyl2 := r.ReadArrayStart()
 63255  			if yyl2 == 0 {
 63256  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 63257  			} else {
 63258  				x.codecDecodeSelfFromArray(yyl2, d)
 63259  			}
 63260  		} else {
 63261  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 63262  		}
 63263  	}
 63264  }
 63265  
 63266  func (x *RescheduleEvent) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 63267  	var h codecSelfer100
 63268  	z, r := codec1978.GenHelperDecoder(d)
 63269  	_, _, _ = h, z, r
 63270  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 63271  	_ = yys3Slc
 63272  	var yyhl3 bool = l >= 0
 63273  	for yyj3 := 0; ; yyj3++ {
 63274  		if yyhl3 {
 63275  			if yyj3 >= l {
 63276  				break
 63277  			}
 63278  		} else {
 63279  			if r.CheckBreak() {
 63280  				break
 63281  			}
 63282  		}
 63283  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 63284  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 63285  		yys3 := string(yys3Slc)
 63286  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 63287  		switch yys3 {
 63288  		case "RescheduleTime":
 63289  			if r.TryDecodeAsNil() {
 63290  				x.RescheduleTime = 0
 63291  			} else {
 63292  				yyv4 := &x.RescheduleTime
 63293  				yym5 := z.DecBinary()
 63294  				_ = yym5
 63295  				if false {
 63296  				} else {
 63297  					*((*int64)(yyv4)) = int64(r.DecodeInt(64))
 63298  				}
 63299  			}
 63300  		case "PrevAllocID":
 63301  			if r.TryDecodeAsNil() {
 63302  				x.PrevAllocID = ""
 63303  			} else {
 63304  				yyv6 := &x.PrevAllocID
 63305  				yym7 := z.DecBinary()
 63306  				_ = yym7
 63307  				if false {
 63308  				} else {
 63309  					*((*string)(yyv6)) = r.DecodeString()
 63310  				}
 63311  			}
 63312  		case "PrevNodeID":
 63313  			if r.TryDecodeAsNil() {
 63314  				x.PrevNodeID = ""
 63315  			} else {
 63316  				yyv8 := &x.PrevNodeID
 63317  				yym9 := z.DecBinary()
 63318  				_ = yym9
 63319  				if false {
 63320  				} else {
 63321  					*((*string)(yyv8)) = r.DecodeString()
 63322  				}
 63323  			}
 63324  		case "Delay":
 63325  			if r.TryDecodeAsNil() {
 63326  				x.Delay = 0
 63327  			} else {
 63328  				yyv10 := &x.Delay
 63329  				yym11 := z.DecBinary()
 63330  				_ = yym11
 63331  				if false {
 63332  				} else if z.HasExtensions() && z.DecExt(yyv10) {
 63333  				} else {
 63334  					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
 63335  				}
 63336  			}
 63337  		default:
 63338  			z.DecStructFieldNotFound(-1, yys3)
 63339  		} // end switch yys3
 63340  	} // end for yyj3
 63341  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 63342  }
 63343  
 63344  func (x *RescheduleEvent) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 63345  	var h codecSelfer100
 63346  	z, r := codec1978.GenHelperDecoder(d)
 63347  	_, _, _ = h, z, r
 63348  	var yyj12 int
 63349  	var yyb12 bool
 63350  	var yyhl12 bool = l >= 0
 63351  	yyj12++
 63352  	if yyhl12 {
 63353  		yyb12 = yyj12 > l
 63354  	} else {
 63355  		yyb12 = r.CheckBreak()
 63356  	}
 63357  	if yyb12 {
 63358  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 63359  		return
 63360  	}
 63361  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 63362  	if r.TryDecodeAsNil() {
 63363  		x.RescheduleTime = 0
 63364  	} else {
 63365  		yyv13 := &x.RescheduleTime
 63366  		yym14 := z.DecBinary()
 63367  		_ = yym14
 63368  		if false {
 63369  		} else {
 63370  			*((*int64)(yyv13)) = int64(r.DecodeInt(64))
 63371  		}
 63372  	}
 63373  	yyj12++
 63374  	if yyhl12 {
 63375  		yyb12 = yyj12 > l
 63376  	} else {
 63377  		yyb12 = r.CheckBreak()
 63378  	}
 63379  	if yyb12 {
 63380  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 63381  		return
 63382  	}
 63383  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 63384  	if r.TryDecodeAsNil() {
 63385  		x.PrevAllocID = ""
 63386  	} else {
 63387  		yyv15 := &x.PrevAllocID
 63388  		yym16 := z.DecBinary()
 63389  		_ = yym16
 63390  		if false {
 63391  		} else {
 63392  			*((*string)(yyv15)) = r.DecodeString()
 63393  		}
 63394  	}
 63395  	yyj12++
 63396  	if yyhl12 {
 63397  		yyb12 = yyj12 > l
 63398  	} else {
 63399  		yyb12 = r.CheckBreak()
 63400  	}
 63401  	if yyb12 {
 63402  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 63403  		return
 63404  	}
 63405  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 63406  	if r.TryDecodeAsNil() {
 63407  		x.PrevNodeID = ""
 63408  	} else {
 63409  		yyv17 := &x.PrevNodeID
 63410  		yym18 := z.DecBinary()
 63411  		_ = yym18
 63412  		if false {
 63413  		} else {
 63414  			*((*string)(yyv17)) = r.DecodeString()
 63415  		}
 63416  	}
 63417  	yyj12++
 63418  	if yyhl12 {
 63419  		yyb12 = yyj12 > l
 63420  	} else {
 63421  		yyb12 = r.CheckBreak()
 63422  	}
 63423  	if yyb12 {
 63424  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 63425  		return
 63426  	}
 63427  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 63428  	if r.TryDecodeAsNil() {
 63429  		x.Delay = 0
 63430  	} else {
 63431  		yyv19 := &x.Delay
 63432  		yym20 := z.DecBinary()
 63433  		_ = yym20
 63434  		if false {
 63435  		} else if z.HasExtensions() && z.DecExt(yyv19) {
 63436  		} else {
 63437  			*((*int64)(yyv19)) = int64(r.DecodeInt(64))
 63438  		}
 63439  	}
 63440  	for {
 63441  		yyj12++
 63442  		if yyhl12 {
 63443  			yyb12 = yyj12 > l
 63444  		} else {
 63445  			yyb12 = r.CheckBreak()
 63446  		}
 63447  		if yyb12 {
 63448  			break
 63449  		}
 63450  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 63451  		z.DecStructFieldNotFound(yyj12-1, "")
 63452  	}
 63453  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 63454  }
 63455  
 63456  func (x *DesiredTransition) CodecEncodeSelf(e *codec1978.Encoder) {
 63457  	var h codecSelfer100
 63458  	z, r := codec1978.GenHelperEncoder(e)
 63459  	_, _, _ = h, z, r
 63460  	if x == nil {
 63461  		r.EncodeNil()
 63462  	} else {
 63463  		yym1 := z.EncBinary()
 63464  		_ = yym1
 63465  		if false {
 63466  		} else if z.HasExtensions() && z.EncExt(x) {
 63467  		} else {
 63468  			yysep2 := !z.EncBinary()
 63469  			yy2arr2 := z.EncBasicHandle().StructToArray
 63470  			var yyq2 [1]bool
 63471  			_, _, _ = yysep2, yyq2, yy2arr2
 63472  			const yyr2 bool = false
 63473  			var yynn2 int
 63474  			if yyr2 || yy2arr2 {
 63475  				r.EncodeArrayStart(1)
 63476  			} else {
 63477  				yynn2 = 1
 63478  				for _, b := range yyq2 {
 63479  					if b {
 63480  						yynn2++
 63481  					}
 63482  				}
 63483  				r.EncodeMapStart(yynn2)
 63484  				yynn2 = 0
 63485  			}
 63486  			if yyr2 || yy2arr2 {
 63487  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63488  				if x.Migrate == nil {
 63489  					r.EncodeNil()
 63490  				} else {
 63491  					yy4 := *x.Migrate
 63492  					yym5 := z.EncBinary()
 63493  					_ = yym5
 63494  					if false {
 63495  					} else {
 63496  						r.EncodeBool(bool(yy4))
 63497  					}
 63498  				}
 63499  			} else {
 63500  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63501  				r.EncodeString(codecSelferC_UTF8100, string("Migrate"))
 63502  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63503  				if x.Migrate == nil {
 63504  					r.EncodeNil()
 63505  				} else {
 63506  					yy6 := *x.Migrate
 63507  					yym7 := z.EncBinary()
 63508  					_ = yym7
 63509  					if false {
 63510  					} else {
 63511  						r.EncodeBool(bool(yy6))
 63512  					}
 63513  				}
 63514  			}
 63515  			if yyr2 || yy2arr2 {
 63516  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 63517  			} else {
 63518  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 63519  			}
 63520  		}
 63521  	}
 63522  }
 63523  
 63524  func (x *DesiredTransition) CodecDecodeSelf(d *codec1978.Decoder) {
 63525  	var h codecSelfer100
 63526  	z, r := codec1978.GenHelperDecoder(d)
 63527  	_, _, _ = h, z, r
 63528  	yym1 := z.DecBinary()
 63529  	_ = yym1
 63530  	if false {
 63531  	} else if z.HasExtensions() && z.DecExt(x) {
 63532  	} else {
 63533  		yyct2 := r.ContainerType()
 63534  		if yyct2 == codecSelferValueTypeMap100 {
 63535  			yyl2 := r.ReadMapStart()
 63536  			if yyl2 == 0 {
 63537  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 63538  			} else {
 63539  				x.codecDecodeSelfFromMap(yyl2, d)
 63540  			}
 63541  		} else if yyct2 == codecSelferValueTypeArray100 {
 63542  			yyl2 := r.ReadArrayStart()
 63543  			if yyl2 == 0 {
 63544  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 63545  			} else {
 63546  				x.codecDecodeSelfFromArray(yyl2, d)
 63547  			}
 63548  		} else {
 63549  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 63550  		}
 63551  	}
 63552  }
 63553  
 63554  func (x *DesiredTransition) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 63555  	var h codecSelfer100
 63556  	z, r := codec1978.GenHelperDecoder(d)
 63557  	_, _, _ = h, z, r
 63558  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 63559  	_ = yys3Slc
 63560  	var yyhl3 bool = l >= 0
 63561  	for yyj3 := 0; ; yyj3++ {
 63562  		if yyhl3 {
 63563  			if yyj3 >= l {
 63564  				break
 63565  			}
 63566  		} else {
 63567  			if r.CheckBreak() {
 63568  				break
 63569  			}
 63570  		}
 63571  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 63572  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 63573  		yys3 := string(yys3Slc)
 63574  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 63575  		switch yys3 {
 63576  		case "Migrate":
 63577  			if r.TryDecodeAsNil() {
 63578  				if x.Migrate != nil {
 63579  					x.Migrate = nil
 63580  				}
 63581  			} else {
 63582  				if x.Migrate == nil {
 63583  					x.Migrate = new(bool)
 63584  				}
 63585  				yym5 := z.DecBinary()
 63586  				_ = yym5
 63587  				if false {
 63588  				} else {
 63589  					*((*bool)(x.Migrate)) = r.DecodeBool()
 63590  				}
 63591  			}
 63592  		default:
 63593  			z.DecStructFieldNotFound(-1, yys3)
 63594  		} // end switch yys3
 63595  	} // end for yyj3
 63596  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 63597  }
 63598  
 63599  func (x *DesiredTransition) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 63600  	var h codecSelfer100
 63601  	z, r := codec1978.GenHelperDecoder(d)
 63602  	_, _, _ = h, z, r
 63603  	var yyj6 int
 63604  	var yyb6 bool
 63605  	var yyhl6 bool = l >= 0
 63606  	yyj6++
 63607  	if yyhl6 {
 63608  		yyb6 = yyj6 > l
 63609  	} else {
 63610  		yyb6 = r.CheckBreak()
 63611  	}
 63612  	if yyb6 {
 63613  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 63614  		return
 63615  	}
 63616  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 63617  	if r.TryDecodeAsNil() {
 63618  		if x.Migrate != nil {
 63619  			x.Migrate = nil
 63620  		}
 63621  	} else {
 63622  		if x.Migrate == nil {
 63623  			x.Migrate = new(bool)
 63624  		}
 63625  		yym8 := z.DecBinary()
 63626  		_ = yym8
 63627  		if false {
 63628  		} else {
 63629  			*((*bool)(x.Migrate)) = r.DecodeBool()
 63630  		}
 63631  	}
 63632  	for {
 63633  		yyj6++
 63634  		if yyhl6 {
 63635  			yyb6 = yyj6 > l
 63636  		} else {
 63637  			yyb6 = r.CheckBreak()
 63638  		}
 63639  		if yyb6 {
 63640  			break
 63641  		}
 63642  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 63643  		z.DecStructFieldNotFound(yyj6-1, "")
 63644  	}
 63645  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 63646  }
 63647  
 63648  func (x *Allocation) CodecEncodeSelf(e *codec1978.Encoder) {
 63649  	var h codecSelfer100
 63650  	z, r := codec1978.GenHelperEncoder(e)
 63651  	_, _, _ = h, z, r
 63652  	if x == nil {
 63653  		r.EncodeNil()
 63654  	} else {
 63655  		yym1 := z.EncBinary()
 63656  		_ = yym1
 63657  		if false {
 63658  		} else if z.HasExtensions() && z.EncExt(x) {
 63659  		} else {
 63660  			yysep2 := !z.EncBinary()
 63661  			yy2arr2 := z.EncBasicHandle().StructToArray
 63662  			var yyq2 [29]bool
 63663  			_, _, _ = yysep2, yyq2, yy2arr2
 63664  			const yyr2 bool = false
 63665  			var yynn2 int
 63666  			if yyr2 || yy2arr2 {
 63667  				r.EncodeArrayStart(29)
 63668  			} else {
 63669  				yynn2 = 29
 63670  				for _, b := range yyq2 {
 63671  					if b {
 63672  						yynn2++
 63673  					}
 63674  				}
 63675  				r.EncodeMapStart(yynn2)
 63676  				yynn2 = 0
 63677  			}
 63678  			if yyr2 || yy2arr2 {
 63679  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63680  				yym4 := z.EncBinary()
 63681  				_ = yym4
 63682  				if false {
 63683  				} else {
 63684  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 63685  				}
 63686  			} else {
 63687  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63688  				r.EncodeString(codecSelferC_UTF8100, string("ID"))
 63689  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63690  				yym5 := z.EncBinary()
 63691  				_ = yym5
 63692  				if false {
 63693  				} else {
 63694  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 63695  				}
 63696  			}
 63697  			if yyr2 || yy2arr2 {
 63698  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63699  				yym7 := z.EncBinary()
 63700  				_ = yym7
 63701  				if false {
 63702  				} else {
 63703  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 63704  				}
 63705  			} else {
 63706  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63707  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 63708  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63709  				yym8 := z.EncBinary()
 63710  				_ = yym8
 63711  				if false {
 63712  				} else {
 63713  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 63714  				}
 63715  			}
 63716  			if yyr2 || yy2arr2 {
 63717  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63718  				yym10 := z.EncBinary()
 63719  				_ = yym10
 63720  				if false {
 63721  				} else {
 63722  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 63723  				}
 63724  			} else {
 63725  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63726  				r.EncodeString(codecSelferC_UTF8100, string("EvalID"))
 63727  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63728  				yym11 := z.EncBinary()
 63729  				_ = yym11
 63730  				if false {
 63731  				} else {
 63732  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 63733  				}
 63734  			}
 63735  			if yyr2 || yy2arr2 {
 63736  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63737  				yym13 := z.EncBinary()
 63738  				_ = yym13
 63739  				if false {
 63740  				} else {
 63741  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 63742  				}
 63743  			} else {
 63744  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63745  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 63746  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63747  				yym14 := z.EncBinary()
 63748  				_ = yym14
 63749  				if false {
 63750  				} else {
 63751  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 63752  				}
 63753  			}
 63754  			if yyr2 || yy2arr2 {
 63755  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63756  				yym16 := z.EncBinary()
 63757  				_ = yym16
 63758  				if false {
 63759  				} else {
 63760  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
 63761  				}
 63762  			} else {
 63763  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63764  				r.EncodeString(codecSelferC_UTF8100, string("NodeID"))
 63765  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63766  				yym17 := z.EncBinary()
 63767  				_ = yym17
 63768  				if false {
 63769  				} else {
 63770  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
 63771  				}
 63772  			}
 63773  			if yyr2 || yy2arr2 {
 63774  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63775  				yym19 := z.EncBinary()
 63776  				_ = yym19
 63777  				if false {
 63778  				} else {
 63779  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 63780  				}
 63781  			} else {
 63782  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63783  				r.EncodeString(codecSelferC_UTF8100, string("JobID"))
 63784  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63785  				yym20 := z.EncBinary()
 63786  				_ = yym20
 63787  				if false {
 63788  				} else {
 63789  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 63790  				}
 63791  			}
 63792  			if yyr2 || yy2arr2 {
 63793  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63794  				if x.Job == nil {
 63795  					r.EncodeNil()
 63796  				} else {
 63797  					x.Job.CodecEncodeSelf(e)
 63798  				}
 63799  			} else {
 63800  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63801  				r.EncodeString(codecSelferC_UTF8100, string("Job"))
 63802  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63803  				if x.Job == nil {
 63804  					r.EncodeNil()
 63805  				} else {
 63806  					x.Job.CodecEncodeSelf(e)
 63807  				}
 63808  			}
 63809  			if yyr2 || yy2arr2 {
 63810  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63811  				yym25 := z.EncBinary()
 63812  				_ = yym25
 63813  				if false {
 63814  				} else {
 63815  					r.EncodeString(codecSelferC_UTF8100, string(x.TaskGroup))
 63816  				}
 63817  			} else {
 63818  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63819  				r.EncodeString(codecSelferC_UTF8100, string("TaskGroup"))
 63820  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63821  				yym26 := z.EncBinary()
 63822  				_ = yym26
 63823  				if false {
 63824  				} else {
 63825  					r.EncodeString(codecSelferC_UTF8100, string(x.TaskGroup))
 63826  				}
 63827  			}
 63828  			if yyr2 || yy2arr2 {
 63829  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63830  				if x.Resources == nil {
 63831  					r.EncodeNil()
 63832  				} else {
 63833  					x.Resources.CodecEncodeSelf(e)
 63834  				}
 63835  			} else {
 63836  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63837  				r.EncodeString(codecSelferC_UTF8100, string("Resources"))
 63838  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63839  				if x.Resources == nil {
 63840  					r.EncodeNil()
 63841  				} else {
 63842  					x.Resources.CodecEncodeSelf(e)
 63843  				}
 63844  			}
 63845  			if yyr2 || yy2arr2 {
 63846  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63847  				if x.SharedResources == nil {
 63848  					r.EncodeNil()
 63849  				} else {
 63850  					x.SharedResources.CodecEncodeSelf(e)
 63851  				}
 63852  			} else {
 63853  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63854  				r.EncodeString(codecSelferC_UTF8100, string("SharedResources"))
 63855  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63856  				if x.SharedResources == nil {
 63857  					r.EncodeNil()
 63858  				} else {
 63859  					x.SharedResources.CodecEncodeSelf(e)
 63860  				}
 63861  			}
 63862  			if yyr2 || yy2arr2 {
 63863  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63864  				if x.TaskResources == nil {
 63865  					r.EncodeNil()
 63866  				} else {
 63867  					yym34 := z.EncBinary()
 63868  					_ = yym34
 63869  					if false {
 63870  					} else {
 63871  						h.encMapstringPtrtoResources((map[string]*Resources)(x.TaskResources), e)
 63872  					}
 63873  				}
 63874  			} else {
 63875  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63876  				r.EncodeString(codecSelferC_UTF8100, string("TaskResources"))
 63877  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63878  				if x.TaskResources == nil {
 63879  					r.EncodeNil()
 63880  				} else {
 63881  					yym35 := z.EncBinary()
 63882  					_ = yym35
 63883  					if false {
 63884  					} else {
 63885  						h.encMapstringPtrtoResources((map[string]*Resources)(x.TaskResources), e)
 63886  					}
 63887  				}
 63888  			}
 63889  			if yyr2 || yy2arr2 {
 63890  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63891  				if x.Metrics == nil {
 63892  					r.EncodeNil()
 63893  				} else {
 63894  					x.Metrics.CodecEncodeSelf(e)
 63895  				}
 63896  			} else {
 63897  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63898  				r.EncodeString(codecSelferC_UTF8100, string("Metrics"))
 63899  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63900  				if x.Metrics == nil {
 63901  					r.EncodeNil()
 63902  				} else {
 63903  					x.Metrics.CodecEncodeSelf(e)
 63904  				}
 63905  			}
 63906  			if yyr2 || yy2arr2 {
 63907  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63908  				yym40 := z.EncBinary()
 63909  				_ = yym40
 63910  				if false {
 63911  				} else {
 63912  					r.EncodeString(codecSelferC_UTF8100, string(x.DesiredStatus))
 63913  				}
 63914  			} else {
 63915  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63916  				r.EncodeString(codecSelferC_UTF8100, string("DesiredStatus"))
 63917  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63918  				yym41 := z.EncBinary()
 63919  				_ = yym41
 63920  				if false {
 63921  				} else {
 63922  					r.EncodeString(codecSelferC_UTF8100, string(x.DesiredStatus))
 63923  				}
 63924  			}
 63925  			if yyr2 || yy2arr2 {
 63926  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63927  				yym43 := z.EncBinary()
 63928  				_ = yym43
 63929  				if false {
 63930  				} else {
 63931  					r.EncodeString(codecSelferC_UTF8100, string(x.DesiredDescription))
 63932  				}
 63933  			} else {
 63934  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63935  				r.EncodeString(codecSelferC_UTF8100, string("DesiredDescription"))
 63936  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63937  				yym44 := z.EncBinary()
 63938  				_ = yym44
 63939  				if false {
 63940  				} else {
 63941  					r.EncodeString(codecSelferC_UTF8100, string(x.DesiredDescription))
 63942  				}
 63943  			}
 63944  			if yyr2 || yy2arr2 {
 63945  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63946  				yy46 := &x.DesiredTransition
 63947  				yy46.CodecEncodeSelf(e)
 63948  			} else {
 63949  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63950  				r.EncodeString(codecSelferC_UTF8100, string("DesiredTransition"))
 63951  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63952  				yy48 := &x.DesiredTransition
 63953  				yy48.CodecEncodeSelf(e)
 63954  			}
 63955  			if yyr2 || yy2arr2 {
 63956  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63957  				yym51 := z.EncBinary()
 63958  				_ = yym51
 63959  				if false {
 63960  				} else {
 63961  					r.EncodeString(codecSelferC_UTF8100, string(x.ClientStatus))
 63962  				}
 63963  			} else {
 63964  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63965  				r.EncodeString(codecSelferC_UTF8100, string("ClientStatus"))
 63966  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63967  				yym52 := z.EncBinary()
 63968  				_ = yym52
 63969  				if false {
 63970  				} else {
 63971  					r.EncodeString(codecSelferC_UTF8100, string(x.ClientStatus))
 63972  				}
 63973  			}
 63974  			if yyr2 || yy2arr2 {
 63975  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63976  				yym54 := z.EncBinary()
 63977  				_ = yym54
 63978  				if false {
 63979  				} else {
 63980  					r.EncodeString(codecSelferC_UTF8100, string(x.ClientDescription))
 63981  				}
 63982  			} else {
 63983  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 63984  				r.EncodeString(codecSelferC_UTF8100, string("ClientDescription"))
 63985  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 63986  				yym55 := z.EncBinary()
 63987  				_ = yym55
 63988  				if false {
 63989  				} else {
 63990  					r.EncodeString(codecSelferC_UTF8100, string(x.ClientDescription))
 63991  				}
 63992  			}
 63993  			if yyr2 || yy2arr2 {
 63994  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 63995  				if x.TaskStates == nil {
 63996  					r.EncodeNil()
 63997  				} else {
 63998  					yym57 := z.EncBinary()
 63999  					_ = yym57
 64000  					if false {
 64001  					} else {
 64002  						h.encMapstringPtrtoTaskState((map[string]*TaskState)(x.TaskStates), e)
 64003  					}
 64004  				}
 64005  			} else {
 64006  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 64007  				r.EncodeString(codecSelferC_UTF8100, string("TaskStates"))
 64008  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 64009  				if x.TaskStates == nil {
 64010  					r.EncodeNil()
 64011  				} else {
 64012  					yym58 := z.EncBinary()
 64013  					_ = yym58
 64014  					if false {
 64015  					} else {
 64016  						h.encMapstringPtrtoTaskState((map[string]*TaskState)(x.TaskStates), e)
 64017  					}
 64018  				}
 64019  			}
 64020  			if yyr2 || yy2arr2 {
 64021  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 64022  				yym60 := z.EncBinary()
 64023  				_ = yym60
 64024  				if false {
 64025  				} else {
 64026  					r.EncodeString(codecSelferC_UTF8100, string(x.PreviousAllocation))
 64027  				}
 64028  			} else {
 64029  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 64030  				r.EncodeString(codecSelferC_UTF8100, string("PreviousAllocation"))
 64031  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 64032  				yym61 := z.EncBinary()
 64033  				_ = yym61
 64034  				if false {
 64035  				} else {
 64036  					r.EncodeString(codecSelferC_UTF8100, string(x.PreviousAllocation))
 64037  				}
 64038  			}
 64039  			if yyr2 || yy2arr2 {
 64040  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 64041  				yym63 := z.EncBinary()
 64042  				_ = yym63
 64043  				if false {
 64044  				} else {
 64045  					r.EncodeString(codecSelferC_UTF8100, string(x.NextAllocation))
 64046  				}
 64047  			} else {
 64048  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 64049  				r.EncodeString(codecSelferC_UTF8100, string("NextAllocation"))
 64050  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 64051  				yym64 := z.EncBinary()
 64052  				_ = yym64
 64053  				if false {
 64054  				} else {
 64055  					r.EncodeString(codecSelferC_UTF8100, string(x.NextAllocation))
 64056  				}
 64057  			}
 64058  			if yyr2 || yy2arr2 {
 64059  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 64060  				yym66 := z.EncBinary()
 64061  				_ = yym66
 64062  				if false {
 64063  				} else {
 64064  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 64065  				}
 64066  			} else {
 64067  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 64068  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentID"))
 64069  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 64070  				yym67 := z.EncBinary()
 64071  				_ = yym67
 64072  				if false {
 64073  				} else {
 64074  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 64075  				}
 64076  			}
 64077  			if yyr2 || yy2arr2 {
 64078  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 64079  				if x.DeploymentStatus == nil {
 64080  					r.EncodeNil()
 64081  				} else {
 64082  					x.DeploymentStatus.CodecEncodeSelf(e)
 64083  				}
 64084  			} else {
 64085  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 64086  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentStatus"))
 64087  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 64088  				if x.DeploymentStatus == nil {
 64089  					r.EncodeNil()
 64090  				} else {
 64091  					x.DeploymentStatus.CodecEncodeSelf(e)
 64092  				}
 64093  			}
 64094  			if yyr2 || yy2arr2 {
 64095  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 64096  				if x.RescheduleTracker == nil {
 64097  					r.EncodeNil()
 64098  				} else {
 64099  					x.RescheduleTracker.CodecEncodeSelf(e)
 64100  				}
 64101  			} else {
 64102  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 64103  				r.EncodeString(codecSelferC_UTF8100, string("RescheduleTracker"))
 64104  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 64105  				if x.RescheduleTracker == nil {
 64106  					r.EncodeNil()
 64107  				} else {
 64108  					x.RescheduleTracker.CodecEncodeSelf(e)
 64109  				}
 64110  			}
 64111  			if yyr2 || yy2arr2 {
 64112  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 64113  				yym75 := z.EncBinary()
 64114  				_ = yym75
 64115  				if false {
 64116  				} else {
 64117  					r.EncodeString(codecSelferC_UTF8100, string(x.FollowupEvalID))
 64118  				}
 64119  			} else {
 64120  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 64121  				r.EncodeString(codecSelferC_UTF8100, string("FollowupEvalID"))
 64122  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 64123  				yym76 := z.EncBinary()
 64124  				_ = yym76
 64125  				if false {
 64126  				} else {
 64127  					r.EncodeString(codecSelferC_UTF8100, string(x.FollowupEvalID))
 64128  				}
 64129  			}
 64130  			if yyr2 || yy2arr2 {
 64131  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 64132  				yym78 := z.EncBinary()
 64133  				_ = yym78
 64134  				if false {
 64135  				} else {
 64136  					r.EncodeUint(uint64(x.CreateIndex))
 64137  				}
 64138  			} else {
 64139  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 64140  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 64141  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 64142  				yym79 := z.EncBinary()
 64143  				_ = yym79
 64144  				if false {
 64145  				} else {
 64146  					r.EncodeUint(uint64(x.CreateIndex))
 64147  				}
 64148  			}
 64149  			if yyr2 || yy2arr2 {
 64150  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 64151  				yym81 := z.EncBinary()
 64152  				_ = yym81
 64153  				if false {
 64154  				} else {
 64155  					r.EncodeUint(uint64(x.ModifyIndex))
 64156  				}
 64157  			} else {
 64158  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 64159  				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
 64160  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 64161  				yym82 := z.EncBinary()
 64162  				_ = yym82
 64163  				if false {
 64164  				} else {
 64165  					r.EncodeUint(uint64(x.ModifyIndex))
 64166  				}
 64167  			}
 64168  			if yyr2 || yy2arr2 {
 64169  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 64170  				yym84 := z.EncBinary()
 64171  				_ = yym84
 64172  				if false {
 64173  				} else {
 64174  					r.EncodeUint(uint64(x.AllocModifyIndex))
 64175  				}
 64176  			} else {
 64177  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 64178  				r.EncodeString(codecSelferC_UTF8100, string("AllocModifyIndex"))
 64179  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 64180  				yym85 := z.EncBinary()
 64181  				_ = yym85
 64182  				if false {
 64183  				} else {
 64184  					r.EncodeUint(uint64(x.AllocModifyIndex))
 64185  				}
 64186  			}
 64187  			if yyr2 || yy2arr2 {
 64188  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 64189  				yym87 := z.EncBinary()
 64190  				_ = yym87
 64191  				if false {
 64192  				} else {
 64193  					r.EncodeInt(int64(x.CreateTime))
 64194  				}
 64195  			} else {
 64196  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 64197  				r.EncodeString(codecSelferC_UTF8100, string("CreateTime"))
 64198  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 64199  				yym88 := z.EncBinary()
 64200  				_ = yym88
 64201  				if false {
 64202  				} else {
 64203  					r.EncodeInt(int64(x.CreateTime))
 64204  				}
 64205  			}
 64206  			if yyr2 || yy2arr2 {
 64207  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 64208  				yym90 := z.EncBinary()
 64209  				_ = yym90
 64210  				if false {
 64211  				} else {
 64212  					r.EncodeInt(int64(x.ModifyTime))
 64213  				}
 64214  			} else {
 64215  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 64216  				r.EncodeString(codecSelferC_UTF8100, string("ModifyTime"))
 64217  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 64218  				yym91 := z.EncBinary()
 64219  				_ = yym91
 64220  				if false {
 64221  				} else {
 64222  					r.EncodeInt(int64(x.ModifyTime))
 64223  				}
 64224  			}
 64225  			if yyr2 || yy2arr2 {
 64226  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 64227  			} else {
 64228  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 64229  			}
 64230  		}
 64231  	}
 64232  }
 64233  
 64234  func (x *Allocation) CodecDecodeSelf(d *codec1978.Decoder) {
 64235  	var h codecSelfer100
 64236  	z, r := codec1978.GenHelperDecoder(d)
 64237  	_, _, _ = h, z, r
 64238  	yym1 := z.DecBinary()
 64239  	_ = yym1
 64240  	if false {
 64241  	} else if z.HasExtensions() && z.DecExt(x) {
 64242  	} else {
 64243  		yyct2 := r.ContainerType()
 64244  		if yyct2 == codecSelferValueTypeMap100 {
 64245  			yyl2 := r.ReadMapStart()
 64246  			if yyl2 == 0 {
 64247  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 64248  			} else {
 64249  				x.codecDecodeSelfFromMap(yyl2, d)
 64250  			}
 64251  		} else if yyct2 == codecSelferValueTypeArray100 {
 64252  			yyl2 := r.ReadArrayStart()
 64253  			if yyl2 == 0 {
 64254  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64255  			} else {
 64256  				x.codecDecodeSelfFromArray(yyl2, d)
 64257  			}
 64258  		} else {
 64259  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 64260  		}
 64261  	}
 64262  }
 64263  
 64264  func (x *Allocation) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 64265  	var h codecSelfer100
 64266  	z, r := codec1978.GenHelperDecoder(d)
 64267  	_, _, _ = h, z, r
 64268  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 64269  	_ = yys3Slc
 64270  	var yyhl3 bool = l >= 0
 64271  	for yyj3 := 0; ; yyj3++ {
 64272  		if yyhl3 {
 64273  			if yyj3 >= l {
 64274  				break
 64275  			}
 64276  		} else {
 64277  			if r.CheckBreak() {
 64278  				break
 64279  			}
 64280  		}
 64281  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 64282  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 64283  		yys3 := string(yys3Slc)
 64284  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 64285  		switch yys3 {
 64286  		case "ID":
 64287  			if r.TryDecodeAsNil() {
 64288  				x.ID = ""
 64289  			} else {
 64290  				yyv4 := &x.ID
 64291  				yym5 := z.DecBinary()
 64292  				_ = yym5
 64293  				if false {
 64294  				} else {
 64295  					*((*string)(yyv4)) = r.DecodeString()
 64296  				}
 64297  			}
 64298  		case "Namespace":
 64299  			if r.TryDecodeAsNil() {
 64300  				x.Namespace = ""
 64301  			} else {
 64302  				yyv6 := &x.Namespace
 64303  				yym7 := z.DecBinary()
 64304  				_ = yym7
 64305  				if false {
 64306  				} else {
 64307  					*((*string)(yyv6)) = r.DecodeString()
 64308  				}
 64309  			}
 64310  		case "EvalID":
 64311  			if r.TryDecodeAsNil() {
 64312  				x.EvalID = ""
 64313  			} else {
 64314  				yyv8 := &x.EvalID
 64315  				yym9 := z.DecBinary()
 64316  				_ = yym9
 64317  				if false {
 64318  				} else {
 64319  					*((*string)(yyv8)) = r.DecodeString()
 64320  				}
 64321  			}
 64322  		case "Name":
 64323  			if r.TryDecodeAsNil() {
 64324  				x.Name = ""
 64325  			} else {
 64326  				yyv10 := &x.Name
 64327  				yym11 := z.DecBinary()
 64328  				_ = yym11
 64329  				if false {
 64330  				} else {
 64331  					*((*string)(yyv10)) = r.DecodeString()
 64332  				}
 64333  			}
 64334  		case "NodeID":
 64335  			if r.TryDecodeAsNil() {
 64336  				x.NodeID = ""
 64337  			} else {
 64338  				yyv12 := &x.NodeID
 64339  				yym13 := z.DecBinary()
 64340  				_ = yym13
 64341  				if false {
 64342  				} else {
 64343  					*((*string)(yyv12)) = r.DecodeString()
 64344  				}
 64345  			}
 64346  		case "JobID":
 64347  			if r.TryDecodeAsNil() {
 64348  				x.JobID = ""
 64349  			} else {
 64350  				yyv14 := &x.JobID
 64351  				yym15 := z.DecBinary()
 64352  				_ = yym15
 64353  				if false {
 64354  				} else {
 64355  					*((*string)(yyv14)) = r.DecodeString()
 64356  				}
 64357  			}
 64358  		case "Job":
 64359  			if r.TryDecodeAsNil() {
 64360  				if x.Job != nil {
 64361  					x.Job = nil
 64362  				}
 64363  			} else {
 64364  				if x.Job == nil {
 64365  					x.Job = new(Job)
 64366  				}
 64367  				x.Job.CodecDecodeSelf(d)
 64368  			}
 64369  		case "TaskGroup":
 64370  			if r.TryDecodeAsNil() {
 64371  				x.TaskGroup = ""
 64372  			} else {
 64373  				yyv17 := &x.TaskGroup
 64374  				yym18 := z.DecBinary()
 64375  				_ = yym18
 64376  				if false {
 64377  				} else {
 64378  					*((*string)(yyv17)) = r.DecodeString()
 64379  				}
 64380  			}
 64381  		case "Resources":
 64382  			if r.TryDecodeAsNil() {
 64383  				if x.Resources != nil {
 64384  					x.Resources = nil
 64385  				}
 64386  			} else {
 64387  				if x.Resources == nil {
 64388  					x.Resources = new(Resources)
 64389  				}
 64390  				x.Resources.CodecDecodeSelf(d)
 64391  			}
 64392  		case "SharedResources":
 64393  			if r.TryDecodeAsNil() {
 64394  				if x.SharedResources != nil {
 64395  					x.SharedResources = nil
 64396  				}
 64397  			} else {
 64398  				if x.SharedResources == nil {
 64399  					x.SharedResources = new(Resources)
 64400  				}
 64401  				x.SharedResources.CodecDecodeSelf(d)
 64402  			}
 64403  		case "TaskResources":
 64404  			if r.TryDecodeAsNil() {
 64405  				x.TaskResources = nil
 64406  			} else {
 64407  				yyv21 := &x.TaskResources
 64408  				yym22 := z.DecBinary()
 64409  				_ = yym22
 64410  				if false {
 64411  				} else {
 64412  					h.decMapstringPtrtoResources((*map[string]*Resources)(yyv21), d)
 64413  				}
 64414  			}
 64415  		case "Metrics":
 64416  			if r.TryDecodeAsNil() {
 64417  				if x.Metrics != nil {
 64418  					x.Metrics = nil
 64419  				}
 64420  			} else {
 64421  				if x.Metrics == nil {
 64422  					x.Metrics = new(AllocMetric)
 64423  				}
 64424  				x.Metrics.CodecDecodeSelf(d)
 64425  			}
 64426  		case "DesiredStatus":
 64427  			if r.TryDecodeAsNil() {
 64428  				x.DesiredStatus = ""
 64429  			} else {
 64430  				yyv24 := &x.DesiredStatus
 64431  				yym25 := z.DecBinary()
 64432  				_ = yym25
 64433  				if false {
 64434  				} else {
 64435  					*((*string)(yyv24)) = r.DecodeString()
 64436  				}
 64437  			}
 64438  		case "DesiredDescription":
 64439  			if r.TryDecodeAsNil() {
 64440  				x.DesiredDescription = ""
 64441  			} else {
 64442  				yyv26 := &x.DesiredDescription
 64443  				yym27 := z.DecBinary()
 64444  				_ = yym27
 64445  				if false {
 64446  				} else {
 64447  					*((*string)(yyv26)) = r.DecodeString()
 64448  				}
 64449  			}
 64450  		case "DesiredTransition":
 64451  			if r.TryDecodeAsNil() {
 64452  				x.DesiredTransition = DesiredTransition{}
 64453  			} else {
 64454  				yyv28 := &x.DesiredTransition
 64455  				yyv28.CodecDecodeSelf(d)
 64456  			}
 64457  		case "ClientStatus":
 64458  			if r.TryDecodeAsNil() {
 64459  				x.ClientStatus = ""
 64460  			} else {
 64461  				yyv29 := &x.ClientStatus
 64462  				yym30 := z.DecBinary()
 64463  				_ = yym30
 64464  				if false {
 64465  				} else {
 64466  					*((*string)(yyv29)) = r.DecodeString()
 64467  				}
 64468  			}
 64469  		case "ClientDescription":
 64470  			if r.TryDecodeAsNil() {
 64471  				x.ClientDescription = ""
 64472  			} else {
 64473  				yyv31 := &x.ClientDescription
 64474  				yym32 := z.DecBinary()
 64475  				_ = yym32
 64476  				if false {
 64477  				} else {
 64478  					*((*string)(yyv31)) = r.DecodeString()
 64479  				}
 64480  			}
 64481  		case "TaskStates":
 64482  			if r.TryDecodeAsNil() {
 64483  				x.TaskStates = nil
 64484  			} else {
 64485  				yyv33 := &x.TaskStates
 64486  				yym34 := z.DecBinary()
 64487  				_ = yym34
 64488  				if false {
 64489  				} else {
 64490  					h.decMapstringPtrtoTaskState((*map[string]*TaskState)(yyv33), d)
 64491  				}
 64492  			}
 64493  		case "PreviousAllocation":
 64494  			if r.TryDecodeAsNil() {
 64495  				x.PreviousAllocation = ""
 64496  			} else {
 64497  				yyv35 := &x.PreviousAllocation
 64498  				yym36 := z.DecBinary()
 64499  				_ = yym36
 64500  				if false {
 64501  				} else {
 64502  					*((*string)(yyv35)) = r.DecodeString()
 64503  				}
 64504  			}
 64505  		case "NextAllocation":
 64506  			if r.TryDecodeAsNil() {
 64507  				x.NextAllocation = ""
 64508  			} else {
 64509  				yyv37 := &x.NextAllocation
 64510  				yym38 := z.DecBinary()
 64511  				_ = yym38
 64512  				if false {
 64513  				} else {
 64514  					*((*string)(yyv37)) = r.DecodeString()
 64515  				}
 64516  			}
 64517  		case "DeploymentID":
 64518  			if r.TryDecodeAsNil() {
 64519  				x.DeploymentID = ""
 64520  			} else {
 64521  				yyv39 := &x.DeploymentID
 64522  				yym40 := z.DecBinary()
 64523  				_ = yym40
 64524  				if false {
 64525  				} else {
 64526  					*((*string)(yyv39)) = r.DecodeString()
 64527  				}
 64528  			}
 64529  		case "DeploymentStatus":
 64530  			if r.TryDecodeAsNil() {
 64531  				if x.DeploymentStatus != nil {
 64532  					x.DeploymentStatus = nil
 64533  				}
 64534  			} else {
 64535  				if x.DeploymentStatus == nil {
 64536  					x.DeploymentStatus = new(AllocDeploymentStatus)
 64537  				}
 64538  				x.DeploymentStatus.CodecDecodeSelf(d)
 64539  			}
 64540  		case "RescheduleTracker":
 64541  			if r.TryDecodeAsNil() {
 64542  				if x.RescheduleTracker != nil {
 64543  					x.RescheduleTracker = nil
 64544  				}
 64545  			} else {
 64546  				if x.RescheduleTracker == nil {
 64547  					x.RescheduleTracker = new(RescheduleTracker)
 64548  				}
 64549  				x.RescheduleTracker.CodecDecodeSelf(d)
 64550  			}
 64551  		case "FollowupEvalID":
 64552  			if r.TryDecodeAsNil() {
 64553  				x.FollowupEvalID = ""
 64554  			} else {
 64555  				yyv43 := &x.FollowupEvalID
 64556  				yym44 := z.DecBinary()
 64557  				_ = yym44
 64558  				if false {
 64559  				} else {
 64560  					*((*string)(yyv43)) = r.DecodeString()
 64561  				}
 64562  			}
 64563  		case "CreateIndex":
 64564  			if r.TryDecodeAsNil() {
 64565  				x.CreateIndex = 0
 64566  			} else {
 64567  				yyv45 := &x.CreateIndex
 64568  				yym46 := z.DecBinary()
 64569  				_ = yym46
 64570  				if false {
 64571  				} else {
 64572  					*((*uint64)(yyv45)) = uint64(r.DecodeUint(64))
 64573  				}
 64574  			}
 64575  		case "ModifyIndex":
 64576  			if r.TryDecodeAsNil() {
 64577  				x.ModifyIndex = 0
 64578  			} else {
 64579  				yyv47 := &x.ModifyIndex
 64580  				yym48 := z.DecBinary()
 64581  				_ = yym48
 64582  				if false {
 64583  				} else {
 64584  					*((*uint64)(yyv47)) = uint64(r.DecodeUint(64))
 64585  				}
 64586  			}
 64587  		case "AllocModifyIndex":
 64588  			if r.TryDecodeAsNil() {
 64589  				x.AllocModifyIndex = 0
 64590  			} else {
 64591  				yyv49 := &x.AllocModifyIndex
 64592  				yym50 := z.DecBinary()
 64593  				_ = yym50
 64594  				if false {
 64595  				} else {
 64596  					*((*uint64)(yyv49)) = uint64(r.DecodeUint(64))
 64597  				}
 64598  			}
 64599  		case "CreateTime":
 64600  			if r.TryDecodeAsNil() {
 64601  				x.CreateTime = 0
 64602  			} else {
 64603  				yyv51 := &x.CreateTime
 64604  				yym52 := z.DecBinary()
 64605  				_ = yym52
 64606  				if false {
 64607  				} else {
 64608  					*((*int64)(yyv51)) = int64(r.DecodeInt(64))
 64609  				}
 64610  			}
 64611  		case "ModifyTime":
 64612  			if r.TryDecodeAsNil() {
 64613  				x.ModifyTime = 0
 64614  			} else {
 64615  				yyv53 := &x.ModifyTime
 64616  				yym54 := z.DecBinary()
 64617  				_ = yym54
 64618  				if false {
 64619  				} else {
 64620  					*((*int64)(yyv53)) = int64(r.DecodeInt(64))
 64621  				}
 64622  			}
 64623  		default:
 64624  			z.DecStructFieldNotFound(-1, yys3)
 64625  		} // end switch yys3
 64626  	} // end for yyj3
 64627  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 64628  }
 64629  
 64630  func (x *Allocation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 64631  	var h codecSelfer100
 64632  	z, r := codec1978.GenHelperDecoder(d)
 64633  	_, _, _ = h, z, r
 64634  	var yyj55 int
 64635  	var yyb55 bool
 64636  	var yyhl55 bool = l >= 0
 64637  	yyj55++
 64638  	if yyhl55 {
 64639  		yyb55 = yyj55 > l
 64640  	} else {
 64641  		yyb55 = r.CheckBreak()
 64642  	}
 64643  	if yyb55 {
 64644  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64645  		return
 64646  	}
 64647  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64648  	if r.TryDecodeAsNil() {
 64649  		x.ID = ""
 64650  	} else {
 64651  		yyv56 := &x.ID
 64652  		yym57 := z.DecBinary()
 64653  		_ = yym57
 64654  		if false {
 64655  		} else {
 64656  			*((*string)(yyv56)) = r.DecodeString()
 64657  		}
 64658  	}
 64659  	yyj55++
 64660  	if yyhl55 {
 64661  		yyb55 = yyj55 > l
 64662  	} else {
 64663  		yyb55 = r.CheckBreak()
 64664  	}
 64665  	if yyb55 {
 64666  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64667  		return
 64668  	}
 64669  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64670  	if r.TryDecodeAsNil() {
 64671  		x.Namespace = ""
 64672  	} else {
 64673  		yyv58 := &x.Namespace
 64674  		yym59 := z.DecBinary()
 64675  		_ = yym59
 64676  		if false {
 64677  		} else {
 64678  			*((*string)(yyv58)) = r.DecodeString()
 64679  		}
 64680  	}
 64681  	yyj55++
 64682  	if yyhl55 {
 64683  		yyb55 = yyj55 > l
 64684  	} else {
 64685  		yyb55 = r.CheckBreak()
 64686  	}
 64687  	if yyb55 {
 64688  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64689  		return
 64690  	}
 64691  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64692  	if r.TryDecodeAsNil() {
 64693  		x.EvalID = ""
 64694  	} else {
 64695  		yyv60 := &x.EvalID
 64696  		yym61 := z.DecBinary()
 64697  		_ = yym61
 64698  		if false {
 64699  		} else {
 64700  			*((*string)(yyv60)) = r.DecodeString()
 64701  		}
 64702  	}
 64703  	yyj55++
 64704  	if yyhl55 {
 64705  		yyb55 = yyj55 > l
 64706  	} else {
 64707  		yyb55 = r.CheckBreak()
 64708  	}
 64709  	if yyb55 {
 64710  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64711  		return
 64712  	}
 64713  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64714  	if r.TryDecodeAsNil() {
 64715  		x.Name = ""
 64716  	} else {
 64717  		yyv62 := &x.Name
 64718  		yym63 := z.DecBinary()
 64719  		_ = yym63
 64720  		if false {
 64721  		} else {
 64722  			*((*string)(yyv62)) = r.DecodeString()
 64723  		}
 64724  	}
 64725  	yyj55++
 64726  	if yyhl55 {
 64727  		yyb55 = yyj55 > l
 64728  	} else {
 64729  		yyb55 = r.CheckBreak()
 64730  	}
 64731  	if yyb55 {
 64732  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64733  		return
 64734  	}
 64735  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64736  	if r.TryDecodeAsNil() {
 64737  		x.NodeID = ""
 64738  	} else {
 64739  		yyv64 := &x.NodeID
 64740  		yym65 := z.DecBinary()
 64741  		_ = yym65
 64742  		if false {
 64743  		} else {
 64744  			*((*string)(yyv64)) = r.DecodeString()
 64745  		}
 64746  	}
 64747  	yyj55++
 64748  	if yyhl55 {
 64749  		yyb55 = yyj55 > l
 64750  	} else {
 64751  		yyb55 = r.CheckBreak()
 64752  	}
 64753  	if yyb55 {
 64754  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64755  		return
 64756  	}
 64757  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64758  	if r.TryDecodeAsNil() {
 64759  		x.JobID = ""
 64760  	} else {
 64761  		yyv66 := &x.JobID
 64762  		yym67 := z.DecBinary()
 64763  		_ = yym67
 64764  		if false {
 64765  		} else {
 64766  			*((*string)(yyv66)) = r.DecodeString()
 64767  		}
 64768  	}
 64769  	yyj55++
 64770  	if yyhl55 {
 64771  		yyb55 = yyj55 > l
 64772  	} else {
 64773  		yyb55 = r.CheckBreak()
 64774  	}
 64775  	if yyb55 {
 64776  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64777  		return
 64778  	}
 64779  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64780  	if r.TryDecodeAsNil() {
 64781  		if x.Job != nil {
 64782  			x.Job = nil
 64783  		}
 64784  	} else {
 64785  		if x.Job == nil {
 64786  			x.Job = new(Job)
 64787  		}
 64788  		x.Job.CodecDecodeSelf(d)
 64789  	}
 64790  	yyj55++
 64791  	if yyhl55 {
 64792  		yyb55 = yyj55 > l
 64793  	} else {
 64794  		yyb55 = r.CheckBreak()
 64795  	}
 64796  	if yyb55 {
 64797  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64798  		return
 64799  	}
 64800  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64801  	if r.TryDecodeAsNil() {
 64802  		x.TaskGroup = ""
 64803  	} else {
 64804  		yyv69 := &x.TaskGroup
 64805  		yym70 := z.DecBinary()
 64806  		_ = yym70
 64807  		if false {
 64808  		} else {
 64809  			*((*string)(yyv69)) = r.DecodeString()
 64810  		}
 64811  	}
 64812  	yyj55++
 64813  	if yyhl55 {
 64814  		yyb55 = yyj55 > l
 64815  	} else {
 64816  		yyb55 = r.CheckBreak()
 64817  	}
 64818  	if yyb55 {
 64819  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64820  		return
 64821  	}
 64822  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64823  	if r.TryDecodeAsNil() {
 64824  		if x.Resources != nil {
 64825  			x.Resources = nil
 64826  		}
 64827  	} else {
 64828  		if x.Resources == nil {
 64829  			x.Resources = new(Resources)
 64830  		}
 64831  		x.Resources.CodecDecodeSelf(d)
 64832  	}
 64833  	yyj55++
 64834  	if yyhl55 {
 64835  		yyb55 = yyj55 > l
 64836  	} else {
 64837  		yyb55 = r.CheckBreak()
 64838  	}
 64839  	if yyb55 {
 64840  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64841  		return
 64842  	}
 64843  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64844  	if r.TryDecodeAsNil() {
 64845  		if x.SharedResources != nil {
 64846  			x.SharedResources = nil
 64847  		}
 64848  	} else {
 64849  		if x.SharedResources == nil {
 64850  			x.SharedResources = new(Resources)
 64851  		}
 64852  		x.SharedResources.CodecDecodeSelf(d)
 64853  	}
 64854  	yyj55++
 64855  	if yyhl55 {
 64856  		yyb55 = yyj55 > l
 64857  	} else {
 64858  		yyb55 = r.CheckBreak()
 64859  	}
 64860  	if yyb55 {
 64861  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64862  		return
 64863  	}
 64864  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64865  	if r.TryDecodeAsNil() {
 64866  		x.TaskResources = nil
 64867  	} else {
 64868  		yyv73 := &x.TaskResources
 64869  		yym74 := z.DecBinary()
 64870  		_ = yym74
 64871  		if false {
 64872  		} else {
 64873  			h.decMapstringPtrtoResources((*map[string]*Resources)(yyv73), d)
 64874  		}
 64875  	}
 64876  	yyj55++
 64877  	if yyhl55 {
 64878  		yyb55 = yyj55 > l
 64879  	} else {
 64880  		yyb55 = r.CheckBreak()
 64881  	}
 64882  	if yyb55 {
 64883  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64884  		return
 64885  	}
 64886  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64887  	if r.TryDecodeAsNil() {
 64888  		if x.Metrics != nil {
 64889  			x.Metrics = nil
 64890  		}
 64891  	} else {
 64892  		if x.Metrics == nil {
 64893  			x.Metrics = new(AllocMetric)
 64894  		}
 64895  		x.Metrics.CodecDecodeSelf(d)
 64896  	}
 64897  	yyj55++
 64898  	if yyhl55 {
 64899  		yyb55 = yyj55 > l
 64900  	} else {
 64901  		yyb55 = r.CheckBreak()
 64902  	}
 64903  	if yyb55 {
 64904  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64905  		return
 64906  	}
 64907  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64908  	if r.TryDecodeAsNil() {
 64909  		x.DesiredStatus = ""
 64910  	} else {
 64911  		yyv76 := &x.DesiredStatus
 64912  		yym77 := z.DecBinary()
 64913  		_ = yym77
 64914  		if false {
 64915  		} else {
 64916  			*((*string)(yyv76)) = r.DecodeString()
 64917  		}
 64918  	}
 64919  	yyj55++
 64920  	if yyhl55 {
 64921  		yyb55 = yyj55 > l
 64922  	} else {
 64923  		yyb55 = r.CheckBreak()
 64924  	}
 64925  	if yyb55 {
 64926  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64927  		return
 64928  	}
 64929  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64930  	if r.TryDecodeAsNil() {
 64931  		x.DesiredDescription = ""
 64932  	} else {
 64933  		yyv78 := &x.DesiredDescription
 64934  		yym79 := z.DecBinary()
 64935  		_ = yym79
 64936  		if false {
 64937  		} else {
 64938  			*((*string)(yyv78)) = r.DecodeString()
 64939  		}
 64940  	}
 64941  	yyj55++
 64942  	if yyhl55 {
 64943  		yyb55 = yyj55 > l
 64944  	} else {
 64945  		yyb55 = r.CheckBreak()
 64946  	}
 64947  	if yyb55 {
 64948  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64949  		return
 64950  	}
 64951  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64952  	if r.TryDecodeAsNil() {
 64953  		x.DesiredTransition = DesiredTransition{}
 64954  	} else {
 64955  		yyv80 := &x.DesiredTransition
 64956  		yyv80.CodecDecodeSelf(d)
 64957  	}
 64958  	yyj55++
 64959  	if yyhl55 {
 64960  		yyb55 = yyj55 > l
 64961  	} else {
 64962  		yyb55 = r.CheckBreak()
 64963  	}
 64964  	if yyb55 {
 64965  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64966  		return
 64967  	}
 64968  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64969  	if r.TryDecodeAsNil() {
 64970  		x.ClientStatus = ""
 64971  	} else {
 64972  		yyv81 := &x.ClientStatus
 64973  		yym82 := z.DecBinary()
 64974  		_ = yym82
 64975  		if false {
 64976  		} else {
 64977  			*((*string)(yyv81)) = r.DecodeString()
 64978  		}
 64979  	}
 64980  	yyj55++
 64981  	if yyhl55 {
 64982  		yyb55 = yyj55 > l
 64983  	} else {
 64984  		yyb55 = r.CheckBreak()
 64985  	}
 64986  	if yyb55 {
 64987  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 64988  		return
 64989  	}
 64990  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 64991  	if r.TryDecodeAsNil() {
 64992  		x.ClientDescription = ""
 64993  	} else {
 64994  		yyv83 := &x.ClientDescription
 64995  		yym84 := z.DecBinary()
 64996  		_ = yym84
 64997  		if false {
 64998  		} else {
 64999  			*((*string)(yyv83)) = r.DecodeString()
 65000  		}
 65001  	}
 65002  	yyj55++
 65003  	if yyhl55 {
 65004  		yyb55 = yyj55 > l
 65005  	} else {
 65006  		yyb55 = r.CheckBreak()
 65007  	}
 65008  	if yyb55 {
 65009  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65010  		return
 65011  	}
 65012  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 65013  	if r.TryDecodeAsNil() {
 65014  		x.TaskStates = nil
 65015  	} else {
 65016  		yyv85 := &x.TaskStates
 65017  		yym86 := z.DecBinary()
 65018  		_ = yym86
 65019  		if false {
 65020  		} else {
 65021  			h.decMapstringPtrtoTaskState((*map[string]*TaskState)(yyv85), d)
 65022  		}
 65023  	}
 65024  	yyj55++
 65025  	if yyhl55 {
 65026  		yyb55 = yyj55 > l
 65027  	} else {
 65028  		yyb55 = r.CheckBreak()
 65029  	}
 65030  	if yyb55 {
 65031  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65032  		return
 65033  	}
 65034  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 65035  	if r.TryDecodeAsNil() {
 65036  		x.PreviousAllocation = ""
 65037  	} else {
 65038  		yyv87 := &x.PreviousAllocation
 65039  		yym88 := z.DecBinary()
 65040  		_ = yym88
 65041  		if false {
 65042  		} else {
 65043  			*((*string)(yyv87)) = r.DecodeString()
 65044  		}
 65045  	}
 65046  	yyj55++
 65047  	if yyhl55 {
 65048  		yyb55 = yyj55 > l
 65049  	} else {
 65050  		yyb55 = r.CheckBreak()
 65051  	}
 65052  	if yyb55 {
 65053  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65054  		return
 65055  	}
 65056  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 65057  	if r.TryDecodeAsNil() {
 65058  		x.NextAllocation = ""
 65059  	} else {
 65060  		yyv89 := &x.NextAllocation
 65061  		yym90 := z.DecBinary()
 65062  		_ = yym90
 65063  		if false {
 65064  		} else {
 65065  			*((*string)(yyv89)) = r.DecodeString()
 65066  		}
 65067  	}
 65068  	yyj55++
 65069  	if yyhl55 {
 65070  		yyb55 = yyj55 > l
 65071  	} else {
 65072  		yyb55 = r.CheckBreak()
 65073  	}
 65074  	if yyb55 {
 65075  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65076  		return
 65077  	}
 65078  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 65079  	if r.TryDecodeAsNil() {
 65080  		x.DeploymentID = ""
 65081  	} else {
 65082  		yyv91 := &x.DeploymentID
 65083  		yym92 := z.DecBinary()
 65084  		_ = yym92
 65085  		if false {
 65086  		} else {
 65087  			*((*string)(yyv91)) = r.DecodeString()
 65088  		}
 65089  	}
 65090  	yyj55++
 65091  	if yyhl55 {
 65092  		yyb55 = yyj55 > l
 65093  	} else {
 65094  		yyb55 = r.CheckBreak()
 65095  	}
 65096  	if yyb55 {
 65097  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65098  		return
 65099  	}
 65100  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 65101  	if r.TryDecodeAsNil() {
 65102  		if x.DeploymentStatus != nil {
 65103  			x.DeploymentStatus = nil
 65104  		}
 65105  	} else {
 65106  		if x.DeploymentStatus == nil {
 65107  			x.DeploymentStatus = new(AllocDeploymentStatus)
 65108  		}
 65109  		x.DeploymentStatus.CodecDecodeSelf(d)
 65110  	}
 65111  	yyj55++
 65112  	if yyhl55 {
 65113  		yyb55 = yyj55 > l
 65114  	} else {
 65115  		yyb55 = r.CheckBreak()
 65116  	}
 65117  	if yyb55 {
 65118  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65119  		return
 65120  	}
 65121  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 65122  	if r.TryDecodeAsNil() {
 65123  		if x.RescheduleTracker != nil {
 65124  			x.RescheduleTracker = nil
 65125  		}
 65126  	} else {
 65127  		if x.RescheduleTracker == nil {
 65128  			x.RescheduleTracker = new(RescheduleTracker)
 65129  		}
 65130  		x.RescheduleTracker.CodecDecodeSelf(d)
 65131  	}
 65132  	yyj55++
 65133  	if yyhl55 {
 65134  		yyb55 = yyj55 > l
 65135  	} else {
 65136  		yyb55 = r.CheckBreak()
 65137  	}
 65138  	if yyb55 {
 65139  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65140  		return
 65141  	}
 65142  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 65143  	if r.TryDecodeAsNil() {
 65144  		x.FollowupEvalID = ""
 65145  	} else {
 65146  		yyv95 := &x.FollowupEvalID
 65147  		yym96 := z.DecBinary()
 65148  		_ = yym96
 65149  		if false {
 65150  		} else {
 65151  			*((*string)(yyv95)) = r.DecodeString()
 65152  		}
 65153  	}
 65154  	yyj55++
 65155  	if yyhl55 {
 65156  		yyb55 = yyj55 > l
 65157  	} else {
 65158  		yyb55 = r.CheckBreak()
 65159  	}
 65160  	if yyb55 {
 65161  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65162  		return
 65163  	}
 65164  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 65165  	if r.TryDecodeAsNil() {
 65166  		x.CreateIndex = 0
 65167  	} else {
 65168  		yyv97 := &x.CreateIndex
 65169  		yym98 := z.DecBinary()
 65170  		_ = yym98
 65171  		if false {
 65172  		} else {
 65173  			*((*uint64)(yyv97)) = uint64(r.DecodeUint(64))
 65174  		}
 65175  	}
 65176  	yyj55++
 65177  	if yyhl55 {
 65178  		yyb55 = yyj55 > l
 65179  	} else {
 65180  		yyb55 = r.CheckBreak()
 65181  	}
 65182  	if yyb55 {
 65183  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65184  		return
 65185  	}
 65186  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 65187  	if r.TryDecodeAsNil() {
 65188  		x.ModifyIndex = 0
 65189  	} else {
 65190  		yyv99 := &x.ModifyIndex
 65191  		yym100 := z.DecBinary()
 65192  		_ = yym100
 65193  		if false {
 65194  		} else {
 65195  			*((*uint64)(yyv99)) = uint64(r.DecodeUint(64))
 65196  		}
 65197  	}
 65198  	yyj55++
 65199  	if yyhl55 {
 65200  		yyb55 = yyj55 > l
 65201  	} else {
 65202  		yyb55 = r.CheckBreak()
 65203  	}
 65204  	if yyb55 {
 65205  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65206  		return
 65207  	}
 65208  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 65209  	if r.TryDecodeAsNil() {
 65210  		x.AllocModifyIndex = 0
 65211  	} else {
 65212  		yyv101 := &x.AllocModifyIndex
 65213  		yym102 := z.DecBinary()
 65214  		_ = yym102
 65215  		if false {
 65216  		} else {
 65217  			*((*uint64)(yyv101)) = uint64(r.DecodeUint(64))
 65218  		}
 65219  	}
 65220  	yyj55++
 65221  	if yyhl55 {
 65222  		yyb55 = yyj55 > l
 65223  	} else {
 65224  		yyb55 = r.CheckBreak()
 65225  	}
 65226  	if yyb55 {
 65227  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65228  		return
 65229  	}
 65230  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 65231  	if r.TryDecodeAsNil() {
 65232  		x.CreateTime = 0
 65233  	} else {
 65234  		yyv103 := &x.CreateTime
 65235  		yym104 := z.DecBinary()
 65236  		_ = yym104
 65237  		if false {
 65238  		} else {
 65239  			*((*int64)(yyv103)) = int64(r.DecodeInt(64))
 65240  		}
 65241  	}
 65242  	yyj55++
 65243  	if yyhl55 {
 65244  		yyb55 = yyj55 > l
 65245  	} else {
 65246  		yyb55 = r.CheckBreak()
 65247  	}
 65248  	if yyb55 {
 65249  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65250  		return
 65251  	}
 65252  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 65253  	if r.TryDecodeAsNil() {
 65254  		x.ModifyTime = 0
 65255  	} else {
 65256  		yyv105 := &x.ModifyTime
 65257  		yym106 := z.DecBinary()
 65258  		_ = yym106
 65259  		if false {
 65260  		} else {
 65261  			*((*int64)(yyv105)) = int64(r.DecodeInt(64))
 65262  		}
 65263  	}
 65264  	for {
 65265  		yyj55++
 65266  		if yyhl55 {
 65267  			yyb55 = yyj55 > l
 65268  		} else {
 65269  			yyb55 = r.CheckBreak()
 65270  		}
 65271  		if yyb55 {
 65272  			break
 65273  		}
 65274  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 65275  		z.DecStructFieldNotFound(yyj55-1, "")
 65276  	}
 65277  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65278  }
 65279  
 65280  func (x *AllocListStub) CodecEncodeSelf(e *codec1978.Encoder) {
 65281  	var h codecSelfer100
 65282  	z, r := codec1978.GenHelperEncoder(e)
 65283  	_, _, _ = h, z, r
 65284  	if x == nil {
 65285  		r.EncodeNil()
 65286  	} else {
 65287  		yym1 := z.EncBinary()
 65288  		_ = yym1
 65289  		if false {
 65290  		} else if z.HasExtensions() && z.EncExt(x) {
 65291  		} else {
 65292  			yysep2 := !z.EncBinary()
 65293  			yy2arr2 := z.EncBasicHandle().StructToArray
 65294  			var yyq2 [18]bool
 65295  			_, _, _ = yysep2, yyq2, yy2arr2
 65296  			const yyr2 bool = false
 65297  			var yynn2 int
 65298  			if yyr2 || yy2arr2 {
 65299  				r.EncodeArrayStart(18)
 65300  			} else {
 65301  				yynn2 = 18
 65302  				for _, b := range yyq2 {
 65303  					if b {
 65304  						yynn2++
 65305  					}
 65306  				}
 65307  				r.EncodeMapStart(yynn2)
 65308  				yynn2 = 0
 65309  			}
 65310  			if yyr2 || yy2arr2 {
 65311  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65312  				yym4 := z.EncBinary()
 65313  				_ = yym4
 65314  				if false {
 65315  				} else {
 65316  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 65317  				}
 65318  			} else {
 65319  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65320  				r.EncodeString(codecSelferC_UTF8100, string("ID"))
 65321  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65322  				yym5 := z.EncBinary()
 65323  				_ = yym5
 65324  				if false {
 65325  				} else {
 65326  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 65327  				}
 65328  			}
 65329  			if yyr2 || yy2arr2 {
 65330  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65331  				yym7 := z.EncBinary()
 65332  				_ = yym7
 65333  				if false {
 65334  				} else {
 65335  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 65336  				}
 65337  			} else {
 65338  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65339  				r.EncodeString(codecSelferC_UTF8100, string("EvalID"))
 65340  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65341  				yym8 := z.EncBinary()
 65342  				_ = yym8
 65343  				if false {
 65344  				} else {
 65345  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 65346  				}
 65347  			}
 65348  			if yyr2 || yy2arr2 {
 65349  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65350  				yym10 := z.EncBinary()
 65351  				_ = yym10
 65352  				if false {
 65353  				} else {
 65354  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 65355  				}
 65356  			} else {
 65357  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65358  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 65359  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65360  				yym11 := z.EncBinary()
 65361  				_ = yym11
 65362  				if false {
 65363  				} else {
 65364  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 65365  				}
 65366  			}
 65367  			if yyr2 || yy2arr2 {
 65368  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65369  				yym13 := z.EncBinary()
 65370  				_ = yym13
 65371  				if false {
 65372  				} else {
 65373  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
 65374  				}
 65375  			} else {
 65376  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65377  				r.EncodeString(codecSelferC_UTF8100, string("NodeID"))
 65378  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65379  				yym14 := z.EncBinary()
 65380  				_ = yym14
 65381  				if false {
 65382  				} else {
 65383  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
 65384  				}
 65385  			}
 65386  			if yyr2 || yy2arr2 {
 65387  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65388  				yym16 := z.EncBinary()
 65389  				_ = yym16
 65390  				if false {
 65391  				} else {
 65392  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 65393  				}
 65394  			} else {
 65395  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65396  				r.EncodeString(codecSelferC_UTF8100, string("JobID"))
 65397  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65398  				yym17 := z.EncBinary()
 65399  				_ = yym17
 65400  				if false {
 65401  				} else {
 65402  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 65403  				}
 65404  			}
 65405  			if yyr2 || yy2arr2 {
 65406  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65407  				yym19 := z.EncBinary()
 65408  				_ = yym19
 65409  				if false {
 65410  				} else {
 65411  					r.EncodeUint(uint64(x.JobVersion))
 65412  				}
 65413  			} else {
 65414  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65415  				r.EncodeString(codecSelferC_UTF8100, string("JobVersion"))
 65416  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65417  				yym20 := z.EncBinary()
 65418  				_ = yym20
 65419  				if false {
 65420  				} else {
 65421  					r.EncodeUint(uint64(x.JobVersion))
 65422  				}
 65423  			}
 65424  			if yyr2 || yy2arr2 {
 65425  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65426  				yym22 := z.EncBinary()
 65427  				_ = yym22
 65428  				if false {
 65429  				} else {
 65430  					r.EncodeString(codecSelferC_UTF8100, string(x.TaskGroup))
 65431  				}
 65432  			} else {
 65433  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65434  				r.EncodeString(codecSelferC_UTF8100, string("TaskGroup"))
 65435  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65436  				yym23 := z.EncBinary()
 65437  				_ = yym23
 65438  				if false {
 65439  				} else {
 65440  					r.EncodeString(codecSelferC_UTF8100, string(x.TaskGroup))
 65441  				}
 65442  			}
 65443  			if yyr2 || yy2arr2 {
 65444  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65445  				yym25 := z.EncBinary()
 65446  				_ = yym25
 65447  				if false {
 65448  				} else {
 65449  					r.EncodeString(codecSelferC_UTF8100, string(x.DesiredStatus))
 65450  				}
 65451  			} else {
 65452  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65453  				r.EncodeString(codecSelferC_UTF8100, string("DesiredStatus"))
 65454  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65455  				yym26 := z.EncBinary()
 65456  				_ = yym26
 65457  				if false {
 65458  				} else {
 65459  					r.EncodeString(codecSelferC_UTF8100, string(x.DesiredStatus))
 65460  				}
 65461  			}
 65462  			if yyr2 || yy2arr2 {
 65463  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65464  				yym28 := z.EncBinary()
 65465  				_ = yym28
 65466  				if false {
 65467  				} else {
 65468  					r.EncodeString(codecSelferC_UTF8100, string(x.DesiredDescription))
 65469  				}
 65470  			} else {
 65471  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65472  				r.EncodeString(codecSelferC_UTF8100, string("DesiredDescription"))
 65473  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65474  				yym29 := z.EncBinary()
 65475  				_ = yym29
 65476  				if false {
 65477  				} else {
 65478  					r.EncodeString(codecSelferC_UTF8100, string(x.DesiredDescription))
 65479  				}
 65480  			}
 65481  			if yyr2 || yy2arr2 {
 65482  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65483  				yym31 := z.EncBinary()
 65484  				_ = yym31
 65485  				if false {
 65486  				} else {
 65487  					r.EncodeString(codecSelferC_UTF8100, string(x.ClientStatus))
 65488  				}
 65489  			} else {
 65490  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65491  				r.EncodeString(codecSelferC_UTF8100, string("ClientStatus"))
 65492  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65493  				yym32 := z.EncBinary()
 65494  				_ = yym32
 65495  				if false {
 65496  				} else {
 65497  					r.EncodeString(codecSelferC_UTF8100, string(x.ClientStatus))
 65498  				}
 65499  			}
 65500  			if yyr2 || yy2arr2 {
 65501  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65502  				yym34 := z.EncBinary()
 65503  				_ = yym34
 65504  				if false {
 65505  				} else {
 65506  					r.EncodeString(codecSelferC_UTF8100, string(x.ClientDescription))
 65507  				}
 65508  			} else {
 65509  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65510  				r.EncodeString(codecSelferC_UTF8100, string("ClientDescription"))
 65511  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65512  				yym35 := z.EncBinary()
 65513  				_ = yym35
 65514  				if false {
 65515  				} else {
 65516  					r.EncodeString(codecSelferC_UTF8100, string(x.ClientDescription))
 65517  				}
 65518  			}
 65519  			if yyr2 || yy2arr2 {
 65520  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65521  				if x.TaskStates == nil {
 65522  					r.EncodeNil()
 65523  				} else {
 65524  					yym37 := z.EncBinary()
 65525  					_ = yym37
 65526  					if false {
 65527  					} else {
 65528  						h.encMapstringPtrtoTaskState((map[string]*TaskState)(x.TaskStates), e)
 65529  					}
 65530  				}
 65531  			} else {
 65532  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65533  				r.EncodeString(codecSelferC_UTF8100, string("TaskStates"))
 65534  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65535  				if x.TaskStates == nil {
 65536  					r.EncodeNil()
 65537  				} else {
 65538  					yym38 := z.EncBinary()
 65539  					_ = yym38
 65540  					if false {
 65541  					} else {
 65542  						h.encMapstringPtrtoTaskState((map[string]*TaskState)(x.TaskStates), e)
 65543  					}
 65544  				}
 65545  			}
 65546  			if yyr2 || yy2arr2 {
 65547  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65548  				if x.DeploymentStatus == nil {
 65549  					r.EncodeNil()
 65550  				} else {
 65551  					x.DeploymentStatus.CodecEncodeSelf(e)
 65552  				}
 65553  			} else {
 65554  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65555  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentStatus"))
 65556  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65557  				if x.DeploymentStatus == nil {
 65558  					r.EncodeNil()
 65559  				} else {
 65560  					x.DeploymentStatus.CodecEncodeSelf(e)
 65561  				}
 65562  			}
 65563  			if yyr2 || yy2arr2 {
 65564  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65565  				yym43 := z.EncBinary()
 65566  				_ = yym43
 65567  				if false {
 65568  				} else {
 65569  					r.EncodeString(codecSelferC_UTF8100, string(x.FollowupEvalID))
 65570  				}
 65571  			} else {
 65572  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65573  				r.EncodeString(codecSelferC_UTF8100, string("FollowupEvalID"))
 65574  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65575  				yym44 := z.EncBinary()
 65576  				_ = yym44
 65577  				if false {
 65578  				} else {
 65579  					r.EncodeString(codecSelferC_UTF8100, string(x.FollowupEvalID))
 65580  				}
 65581  			}
 65582  			if yyr2 || yy2arr2 {
 65583  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65584  				yym46 := z.EncBinary()
 65585  				_ = yym46
 65586  				if false {
 65587  				} else {
 65588  					r.EncodeUint(uint64(x.CreateIndex))
 65589  				}
 65590  			} else {
 65591  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65592  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 65593  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65594  				yym47 := z.EncBinary()
 65595  				_ = yym47
 65596  				if false {
 65597  				} else {
 65598  					r.EncodeUint(uint64(x.CreateIndex))
 65599  				}
 65600  			}
 65601  			if yyr2 || yy2arr2 {
 65602  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65603  				yym49 := z.EncBinary()
 65604  				_ = yym49
 65605  				if false {
 65606  				} else {
 65607  					r.EncodeUint(uint64(x.ModifyIndex))
 65608  				}
 65609  			} else {
 65610  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65611  				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
 65612  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65613  				yym50 := z.EncBinary()
 65614  				_ = yym50
 65615  				if false {
 65616  				} else {
 65617  					r.EncodeUint(uint64(x.ModifyIndex))
 65618  				}
 65619  			}
 65620  			if yyr2 || yy2arr2 {
 65621  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65622  				yym52 := z.EncBinary()
 65623  				_ = yym52
 65624  				if false {
 65625  				} else {
 65626  					r.EncodeInt(int64(x.CreateTime))
 65627  				}
 65628  			} else {
 65629  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65630  				r.EncodeString(codecSelferC_UTF8100, string("CreateTime"))
 65631  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65632  				yym53 := z.EncBinary()
 65633  				_ = yym53
 65634  				if false {
 65635  				} else {
 65636  					r.EncodeInt(int64(x.CreateTime))
 65637  				}
 65638  			}
 65639  			if yyr2 || yy2arr2 {
 65640  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 65641  				yym55 := z.EncBinary()
 65642  				_ = yym55
 65643  				if false {
 65644  				} else {
 65645  					r.EncodeInt(int64(x.ModifyTime))
 65646  				}
 65647  			} else {
 65648  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 65649  				r.EncodeString(codecSelferC_UTF8100, string("ModifyTime"))
 65650  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 65651  				yym56 := z.EncBinary()
 65652  				_ = yym56
 65653  				if false {
 65654  				} else {
 65655  					r.EncodeInt(int64(x.ModifyTime))
 65656  				}
 65657  			}
 65658  			if yyr2 || yy2arr2 {
 65659  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 65660  			} else {
 65661  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 65662  			}
 65663  		}
 65664  	}
 65665  }
 65666  
 65667  func (x *AllocListStub) CodecDecodeSelf(d *codec1978.Decoder) {
 65668  	var h codecSelfer100
 65669  	z, r := codec1978.GenHelperDecoder(d)
 65670  	_, _, _ = h, z, r
 65671  	yym1 := z.DecBinary()
 65672  	_ = yym1
 65673  	if false {
 65674  	} else if z.HasExtensions() && z.DecExt(x) {
 65675  	} else {
 65676  		yyct2 := r.ContainerType()
 65677  		if yyct2 == codecSelferValueTypeMap100 {
 65678  			yyl2 := r.ReadMapStart()
 65679  			if yyl2 == 0 {
 65680  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 65681  			} else {
 65682  				x.codecDecodeSelfFromMap(yyl2, d)
 65683  			}
 65684  		} else if yyct2 == codecSelferValueTypeArray100 {
 65685  			yyl2 := r.ReadArrayStart()
 65686  			if yyl2 == 0 {
 65687  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65688  			} else {
 65689  				x.codecDecodeSelfFromArray(yyl2, d)
 65690  			}
 65691  		} else {
 65692  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 65693  		}
 65694  	}
 65695  }
 65696  
 65697  func (x *AllocListStub) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 65698  	var h codecSelfer100
 65699  	z, r := codec1978.GenHelperDecoder(d)
 65700  	_, _, _ = h, z, r
 65701  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 65702  	_ = yys3Slc
 65703  	var yyhl3 bool = l >= 0
 65704  	for yyj3 := 0; ; yyj3++ {
 65705  		if yyhl3 {
 65706  			if yyj3 >= l {
 65707  				break
 65708  			}
 65709  		} else {
 65710  			if r.CheckBreak() {
 65711  				break
 65712  			}
 65713  		}
 65714  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 65715  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 65716  		yys3 := string(yys3Slc)
 65717  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 65718  		switch yys3 {
 65719  		case "ID":
 65720  			if r.TryDecodeAsNil() {
 65721  				x.ID = ""
 65722  			} else {
 65723  				yyv4 := &x.ID
 65724  				yym5 := z.DecBinary()
 65725  				_ = yym5
 65726  				if false {
 65727  				} else {
 65728  					*((*string)(yyv4)) = r.DecodeString()
 65729  				}
 65730  			}
 65731  		case "EvalID":
 65732  			if r.TryDecodeAsNil() {
 65733  				x.EvalID = ""
 65734  			} else {
 65735  				yyv6 := &x.EvalID
 65736  				yym7 := z.DecBinary()
 65737  				_ = yym7
 65738  				if false {
 65739  				} else {
 65740  					*((*string)(yyv6)) = r.DecodeString()
 65741  				}
 65742  			}
 65743  		case "Name":
 65744  			if r.TryDecodeAsNil() {
 65745  				x.Name = ""
 65746  			} else {
 65747  				yyv8 := &x.Name
 65748  				yym9 := z.DecBinary()
 65749  				_ = yym9
 65750  				if false {
 65751  				} else {
 65752  					*((*string)(yyv8)) = r.DecodeString()
 65753  				}
 65754  			}
 65755  		case "NodeID":
 65756  			if r.TryDecodeAsNil() {
 65757  				x.NodeID = ""
 65758  			} else {
 65759  				yyv10 := &x.NodeID
 65760  				yym11 := z.DecBinary()
 65761  				_ = yym11
 65762  				if false {
 65763  				} else {
 65764  					*((*string)(yyv10)) = r.DecodeString()
 65765  				}
 65766  			}
 65767  		case "JobID":
 65768  			if r.TryDecodeAsNil() {
 65769  				x.JobID = ""
 65770  			} else {
 65771  				yyv12 := &x.JobID
 65772  				yym13 := z.DecBinary()
 65773  				_ = yym13
 65774  				if false {
 65775  				} else {
 65776  					*((*string)(yyv12)) = r.DecodeString()
 65777  				}
 65778  			}
 65779  		case "JobVersion":
 65780  			if r.TryDecodeAsNil() {
 65781  				x.JobVersion = 0
 65782  			} else {
 65783  				yyv14 := &x.JobVersion
 65784  				yym15 := z.DecBinary()
 65785  				_ = yym15
 65786  				if false {
 65787  				} else {
 65788  					*((*uint64)(yyv14)) = uint64(r.DecodeUint(64))
 65789  				}
 65790  			}
 65791  		case "TaskGroup":
 65792  			if r.TryDecodeAsNil() {
 65793  				x.TaskGroup = ""
 65794  			} else {
 65795  				yyv16 := &x.TaskGroup
 65796  				yym17 := z.DecBinary()
 65797  				_ = yym17
 65798  				if false {
 65799  				} else {
 65800  					*((*string)(yyv16)) = r.DecodeString()
 65801  				}
 65802  			}
 65803  		case "DesiredStatus":
 65804  			if r.TryDecodeAsNil() {
 65805  				x.DesiredStatus = ""
 65806  			} else {
 65807  				yyv18 := &x.DesiredStatus
 65808  				yym19 := z.DecBinary()
 65809  				_ = yym19
 65810  				if false {
 65811  				} else {
 65812  					*((*string)(yyv18)) = r.DecodeString()
 65813  				}
 65814  			}
 65815  		case "DesiredDescription":
 65816  			if r.TryDecodeAsNil() {
 65817  				x.DesiredDescription = ""
 65818  			} else {
 65819  				yyv20 := &x.DesiredDescription
 65820  				yym21 := z.DecBinary()
 65821  				_ = yym21
 65822  				if false {
 65823  				} else {
 65824  					*((*string)(yyv20)) = r.DecodeString()
 65825  				}
 65826  			}
 65827  		case "ClientStatus":
 65828  			if r.TryDecodeAsNil() {
 65829  				x.ClientStatus = ""
 65830  			} else {
 65831  				yyv22 := &x.ClientStatus
 65832  				yym23 := z.DecBinary()
 65833  				_ = yym23
 65834  				if false {
 65835  				} else {
 65836  					*((*string)(yyv22)) = r.DecodeString()
 65837  				}
 65838  			}
 65839  		case "ClientDescription":
 65840  			if r.TryDecodeAsNil() {
 65841  				x.ClientDescription = ""
 65842  			} else {
 65843  				yyv24 := &x.ClientDescription
 65844  				yym25 := z.DecBinary()
 65845  				_ = yym25
 65846  				if false {
 65847  				} else {
 65848  					*((*string)(yyv24)) = r.DecodeString()
 65849  				}
 65850  			}
 65851  		case "TaskStates":
 65852  			if r.TryDecodeAsNil() {
 65853  				x.TaskStates = nil
 65854  			} else {
 65855  				yyv26 := &x.TaskStates
 65856  				yym27 := z.DecBinary()
 65857  				_ = yym27
 65858  				if false {
 65859  				} else {
 65860  					h.decMapstringPtrtoTaskState((*map[string]*TaskState)(yyv26), d)
 65861  				}
 65862  			}
 65863  		case "DeploymentStatus":
 65864  			if r.TryDecodeAsNil() {
 65865  				if x.DeploymentStatus != nil {
 65866  					x.DeploymentStatus = nil
 65867  				}
 65868  			} else {
 65869  				if x.DeploymentStatus == nil {
 65870  					x.DeploymentStatus = new(AllocDeploymentStatus)
 65871  				}
 65872  				x.DeploymentStatus.CodecDecodeSelf(d)
 65873  			}
 65874  		case "FollowupEvalID":
 65875  			if r.TryDecodeAsNil() {
 65876  				x.FollowupEvalID = ""
 65877  			} else {
 65878  				yyv29 := &x.FollowupEvalID
 65879  				yym30 := z.DecBinary()
 65880  				_ = yym30
 65881  				if false {
 65882  				} else {
 65883  					*((*string)(yyv29)) = r.DecodeString()
 65884  				}
 65885  			}
 65886  		case "CreateIndex":
 65887  			if r.TryDecodeAsNil() {
 65888  				x.CreateIndex = 0
 65889  			} else {
 65890  				yyv31 := &x.CreateIndex
 65891  				yym32 := z.DecBinary()
 65892  				_ = yym32
 65893  				if false {
 65894  				} else {
 65895  					*((*uint64)(yyv31)) = uint64(r.DecodeUint(64))
 65896  				}
 65897  			}
 65898  		case "ModifyIndex":
 65899  			if r.TryDecodeAsNil() {
 65900  				x.ModifyIndex = 0
 65901  			} else {
 65902  				yyv33 := &x.ModifyIndex
 65903  				yym34 := z.DecBinary()
 65904  				_ = yym34
 65905  				if false {
 65906  				} else {
 65907  					*((*uint64)(yyv33)) = uint64(r.DecodeUint(64))
 65908  				}
 65909  			}
 65910  		case "CreateTime":
 65911  			if r.TryDecodeAsNil() {
 65912  				x.CreateTime = 0
 65913  			} else {
 65914  				yyv35 := &x.CreateTime
 65915  				yym36 := z.DecBinary()
 65916  				_ = yym36
 65917  				if false {
 65918  				} else {
 65919  					*((*int64)(yyv35)) = int64(r.DecodeInt(64))
 65920  				}
 65921  			}
 65922  		case "ModifyTime":
 65923  			if r.TryDecodeAsNil() {
 65924  				x.ModifyTime = 0
 65925  			} else {
 65926  				yyv37 := &x.ModifyTime
 65927  				yym38 := z.DecBinary()
 65928  				_ = yym38
 65929  				if false {
 65930  				} else {
 65931  					*((*int64)(yyv37)) = int64(r.DecodeInt(64))
 65932  				}
 65933  			}
 65934  		default:
 65935  			z.DecStructFieldNotFound(-1, yys3)
 65936  		} // end switch yys3
 65937  	} // end for yyj3
 65938  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 65939  }
 65940  
 65941  func (x *AllocListStub) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 65942  	var h codecSelfer100
 65943  	z, r := codec1978.GenHelperDecoder(d)
 65944  	_, _, _ = h, z, r
 65945  	var yyj39 int
 65946  	var yyb39 bool
 65947  	var yyhl39 bool = l >= 0
 65948  	yyj39++
 65949  	if yyhl39 {
 65950  		yyb39 = yyj39 > l
 65951  	} else {
 65952  		yyb39 = r.CheckBreak()
 65953  	}
 65954  	if yyb39 {
 65955  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65956  		return
 65957  	}
 65958  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 65959  	if r.TryDecodeAsNil() {
 65960  		x.ID = ""
 65961  	} else {
 65962  		yyv40 := &x.ID
 65963  		yym41 := z.DecBinary()
 65964  		_ = yym41
 65965  		if false {
 65966  		} else {
 65967  			*((*string)(yyv40)) = r.DecodeString()
 65968  		}
 65969  	}
 65970  	yyj39++
 65971  	if yyhl39 {
 65972  		yyb39 = yyj39 > l
 65973  	} else {
 65974  		yyb39 = r.CheckBreak()
 65975  	}
 65976  	if yyb39 {
 65977  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 65978  		return
 65979  	}
 65980  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 65981  	if r.TryDecodeAsNil() {
 65982  		x.EvalID = ""
 65983  	} else {
 65984  		yyv42 := &x.EvalID
 65985  		yym43 := z.DecBinary()
 65986  		_ = yym43
 65987  		if false {
 65988  		} else {
 65989  			*((*string)(yyv42)) = r.DecodeString()
 65990  		}
 65991  	}
 65992  	yyj39++
 65993  	if yyhl39 {
 65994  		yyb39 = yyj39 > l
 65995  	} else {
 65996  		yyb39 = r.CheckBreak()
 65997  	}
 65998  	if yyb39 {
 65999  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66000  		return
 66001  	}
 66002  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66003  	if r.TryDecodeAsNil() {
 66004  		x.Name = ""
 66005  	} else {
 66006  		yyv44 := &x.Name
 66007  		yym45 := z.DecBinary()
 66008  		_ = yym45
 66009  		if false {
 66010  		} else {
 66011  			*((*string)(yyv44)) = r.DecodeString()
 66012  		}
 66013  	}
 66014  	yyj39++
 66015  	if yyhl39 {
 66016  		yyb39 = yyj39 > l
 66017  	} else {
 66018  		yyb39 = r.CheckBreak()
 66019  	}
 66020  	if yyb39 {
 66021  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66022  		return
 66023  	}
 66024  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66025  	if r.TryDecodeAsNil() {
 66026  		x.NodeID = ""
 66027  	} else {
 66028  		yyv46 := &x.NodeID
 66029  		yym47 := z.DecBinary()
 66030  		_ = yym47
 66031  		if false {
 66032  		} else {
 66033  			*((*string)(yyv46)) = r.DecodeString()
 66034  		}
 66035  	}
 66036  	yyj39++
 66037  	if yyhl39 {
 66038  		yyb39 = yyj39 > l
 66039  	} else {
 66040  		yyb39 = r.CheckBreak()
 66041  	}
 66042  	if yyb39 {
 66043  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66044  		return
 66045  	}
 66046  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66047  	if r.TryDecodeAsNil() {
 66048  		x.JobID = ""
 66049  	} else {
 66050  		yyv48 := &x.JobID
 66051  		yym49 := z.DecBinary()
 66052  		_ = yym49
 66053  		if false {
 66054  		} else {
 66055  			*((*string)(yyv48)) = r.DecodeString()
 66056  		}
 66057  	}
 66058  	yyj39++
 66059  	if yyhl39 {
 66060  		yyb39 = yyj39 > l
 66061  	} else {
 66062  		yyb39 = r.CheckBreak()
 66063  	}
 66064  	if yyb39 {
 66065  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66066  		return
 66067  	}
 66068  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66069  	if r.TryDecodeAsNil() {
 66070  		x.JobVersion = 0
 66071  	} else {
 66072  		yyv50 := &x.JobVersion
 66073  		yym51 := z.DecBinary()
 66074  		_ = yym51
 66075  		if false {
 66076  		} else {
 66077  			*((*uint64)(yyv50)) = uint64(r.DecodeUint(64))
 66078  		}
 66079  	}
 66080  	yyj39++
 66081  	if yyhl39 {
 66082  		yyb39 = yyj39 > l
 66083  	} else {
 66084  		yyb39 = r.CheckBreak()
 66085  	}
 66086  	if yyb39 {
 66087  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66088  		return
 66089  	}
 66090  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66091  	if r.TryDecodeAsNil() {
 66092  		x.TaskGroup = ""
 66093  	} else {
 66094  		yyv52 := &x.TaskGroup
 66095  		yym53 := z.DecBinary()
 66096  		_ = yym53
 66097  		if false {
 66098  		} else {
 66099  			*((*string)(yyv52)) = r.DecodeString()
 66100  		}
 66101  	}
 66102  	yyj39++
 66103  	if yyhl39 {
 66104  		yyb39 = yyj39 > l
 66105  	} else {
 66106  		yyb39 = r.CheckBreak()
 66107  	}
 66108  	if yyb39 {
 66109  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66110  		return
 66111  	}
 66112  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66113  	if r.TryDecodeAsNil() {
 66114  		x.DesiredStatus = ""
 66115  	} else {
 66116  		yyv54 := &x.DesiredStatus
 66117  		yym55 := z.DecBinary()
 66118  		_ = yym55
 66119  		if false {
 66120  		} else {
 66121  			*((*string)(yyv54)) = r.DecodeString()
 66122  		}
 66123  	}
 66124  	yyj39++
 66125  	if yyhl39 {
 66126  		yyb39 = yyj39 > l
 66127  	} else {
 66128  		yyb39 = r.CheckBreak()
 66129  	}
 66130  	if yyb39 {
 66131  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66132  		return
 66133  	}
 66134  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66135  	if r.TryDecodeAsNil() {
 66136  		x.DesiredDescription = ""
 66137  	} else {
 66138  		yyv56 := &x.DesiredDescription
 66139  		yym57 := z.DecBinary()
 66140  		_ = yym57
 66141  		if false {
 66142  		} else {
 66143  			*((*string)(yyv56)) = r.DecodeString()
 66144  		}
 66145  	}
 66146  	yyj39++
 66147  	if yyhl39 {
 66148  		yyb39 = yyj39 > l
 66149  	} else {
 66150  		yyb39 = r.CheckBreak()
 66151  	}
 66152  	if yyb39 {
 66153  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66154  		return
 66155  	}
 66156  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66157  	if r.TryDecodeAsNil() {
 66158  		x.ClientStatus = ""
 66159  	} else {
 66160  		yyv58 := &x.ClientStatus
 66161  		yym59 := z.DecBinary()
 66162  		_ = yym59
 66163  		if false {
 66164  		} else {
 66165  			*((*string)(yyv58)) = r.DecodeString()
 66166  		}
 66167  	}
 66168  	yyj39++
 66169  	if yyhl39 {
 66170  		yyb39 = yyj39 > l
 66171  	} else {
 66172  		yyb39 = r.CheckBreak()
 66173  	}
 66174  	if yyb39 {
 66175  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66176  		return
 66177  	}
 66178  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66179  	if r.TryDecodeAsNil() {
 66180  		x.ClientDescription = ""
 66181  	} else {
 66182  		yyv60 := &x.ClientDescription
 66183  		yym61 := z.DecBinary()
 66184  		_ = yym61
 66185  		if false {
 66186  		} else {
 66187  			*((*string)(yyv60)) = r.DecodeString()
 66188  		}
 66189  	}
 66190  	yyj39++
 66191  	if yyhl39 {
 66192  		yyb39 = yyj39 > l
 66193  	} else {
 66194  		yyb39 = r.CheckBreak()
 66195  	}
 66196  	if yyb39 {
 66197  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66198  		return
 66199  	}
 66200  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66201  	if r.TryDecodeAsNil() {
 66202  		x.TaskStates = nil
 66203  	} else {
 66204  		yyv62 := &x.TaskStates
 66205  		yym63 := z.DecBinary()
 66206  		_ = yym63
 66207  		if false {
 66208  		} else {
 66209  			h.decMapstringPtrtoTaskState((*map[string]*TaskState)(yyv62), d)
 66210  		}
 66211  	}
 66212  	yyj39++
 66213  	if yyhl39 {
 66214  		yyb39 = yyj39 > l
 66215  	} else {
 66216  		yyb39 = r.CheckBreak()
 66217  	}
 66218  	if yyb39 {
 66219  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66220  		return
 66221  	}
 66222  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66223  	if r.TryDecodeAsNil() {
 66224  		if x.DeploymentStatus != nil {
 66225  			x.DeploymentStatus = nil
 66226  		}
 66227  	} else {
 66228  		if x.DeploymentStatus == nil {
 66229  			x.DeploymentStatus = new(AllocDeploymentStatus)
 66230  		}
 66231  		x.DeploymentStatus.CodecDecodeSelf(d)
 66232  	}
 66233  	yyj39++
 66234  	if yyhl39 {
 66235  		yyb39 = yyj39 > l
 66236  	} else {
 66237  		yyb39 = r.CheckBreak()
 66238  	}
 66239  	if yyb39 {
 66240  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66241  		return
 66242  	}
 66243  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66244  	if r.TryDecodeAsNil() {
 66245  		x.FollowupEvalID = ""
 66246  	} else {
 66247  		yyv65 := &x.FollowupEvalID
 66248  		yym66 := z.DecBinary()
 66249  		_ = yym66
 66250  		if false {
 66251  		} else {
 66252  			*((*string)(yyv65)) = r.DecodeString()
 66253  		}
 66254  	}
 66255  	yyj39++
 66256  	if yyhl39 {
 66257  		yyb39 = yyj39 > l
 66258  	} else {
 66259  		yyb39 = r.CheckBreak()
 66260  	}
 66261  	if yyb39 {
 66262  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66263  		return
 66264  	}
 66265  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66266  	if r.TryDecodeAsNil() {
 66267  		x.CreateIndex = 0
 66268  	} else {
 66269  		yyv67 := &x.CreateIndex
 66270  		yym68 := z.DecBinary()
 66271  		_ = yym68
 66272  		if false {
 66273  		} else {
 66274  			*((*uint64)(yyv67)) = uint64(r.DecodeUint(64))
 66275  		}
 66276  	}
 66277  	yyj39++
 66278  	if yyhl39 {
 66279  		yyb39 = yyj39 > l
 66280  	} else {
 66281  		yyb39 = r.CheckBreak()
 66282  	}
 66283  	if yyb39 {
 66284  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66285  		return
 66286  	}
 66287  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66288  	if r.TryDecodeAsNil() {
 66289  		x.ModifyIndex = 0
 66290  	} else {
 66291  		yyv69 := &x.ModifyIndex
 66292  		yym70 := z.DecBinary()
 66293  		_ = yym70
 66294  		if false {
 66295  		} else {
 66296  			*((*uint64)(yyv69)) = uint64(r.DecodeUint(64))
 66297  		}
 66298  	}
 66299  	yyj39++
 66300  	if yyhl39 {
 66301  		yyb39 = yyj39 > l
 66302  	} else {
 66303  		yyb39 = r.CheckBreak()
 66304  	}
 66305  	if yyb39 {
 66306  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66307  		return
 66308  	}
 66309  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66310  	if r.TryDecodeAsNil() {
 66311  		x.CreateTime = 0
 66312  	} else {
 66313  		yyv71 := &x.CreateTime
 66314  		yym72 := z.DecBinary()
 66315  		_ = yym72
 66316  		if false {
 66317  		} else {
 66318  			*((*int64)(yyv71)) = int64(r.DecodeInt(64))
 66319  		}
 66320  	}
 66321  	yyj39++
 66322  	if yyhl39 {
 66323  		yyb39 = yyj39 > l
 66324  	} else {
 66325  		yyb39 = r.CheckBreak()
 66326  	}
 66327  	if yyb39 {
 66328  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66329  		return
 66330  	}
 66331  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66332  	if r.TryDecodeAsNil() {
 66333  		x.ModifyTime = 0
 66334  	} else {
 66335  		yyv73 := &x.ModifyTime
 66336  		yym74 := z.DecBinary()
 66337  		_ = yym74
 66338  		if false {
 66339  		} else {
 66340  			*((*int64)(yyv73)) = int64(r.DecodeInt(64))
 66341  		}
 66342  	}
 66343  	for {
 66344  		yyj39++
 66345  		if yyhl39 {
 66346  			yyb39 = yyj39 > l
 66347  		} else {
 66348  			yyb39 = r.CheckBreak()
 66349  		}
 66350  		if yyb39 {
 66351  			break
 66352  		}
 66353  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66354  		z.DecStructFieldNotFound(yyj39-1, "")
 66355  	}
 66356  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66357  }
 66358  
 66359  func (x *AllocMetric) CodecEncodeSelf(e *codec1978.Encoder) {
 66360  	var h codecSelfer100
 66361  	z, r := codec1978.GenHelperEncoder(e)
 66362  	_, _, _ = h, z, r
 66363  	if x == nil {
 66364  		r.EncodeNil()
 66365  	} else {
 66366  		yym1 := z.EncBinary()
 66367  		_ = yym1
 66368  		if false {
 66369  		} else if z.HasExtensions() && z.EncExt(x) {
 66370  		} else {
 66371  			yysep2 := !z.EncBinary()
 66372  			yy2arr2 := z.EncBasicHandle().StructToArray
 66373  			var yyq2 [12]bool
 66374  			_, _, _ = yysep2, yyq2, yy2arr2
 66375  			const yyr2 bool = false
 66376  			var yynn2 int
 66377  			if yyr2 || yy2arr2 {
 66378  				r.EncodeArrayStart(12)
 66379  			} else {
 66380  				yynn2 = 12
 66381  				for _, b := range yyq2 {
 66382  					if b {
 66383  						yynn2++
 66384  					}
 66385  				}
 66386  				r.EncodeMapStart(yynn2)
 66387  				yynn2 = 0
 66388  			}
 66389  			if yyr2 || yy2arr2 {
 66390  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 66391  				yym4 := z.EncBinary()
 66392  				_ = yym4
 66393  				if false {
 66394  				} else {
 66395  					r.EncodeInt(int64(x.NodesEvaluated))
 66396  				}
 66397  			} else {
 66398  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 66399  				r.EncodeString(codecSelferC_UTF8100, string("NodesEvaluated"))
 66400  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 66401  				yym5 := z.EncBinary()
 66402  				_ = yym5
 66403  				if false {
 66404  				} else {
 66405  					r.EncodeInt(int64(x.NodesEvaluated))
 66406  				}
 66407  			}
 66408  			if yyr2 || yy2arr2 {
 66409  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 66410  				yym7 := z.EncBinary()
 66411  				_ = yym7
 66412  				if false {
 66413  				} else {
 66414  					r.EncodeInt(int64(x.NodesFiltered))
 66415  				}
 66416  			} else {
 66417  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 66418  				r.EncodeString(codecSelferC_UTF8100, string("NodesFiltered"))
 66419  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 66420  				yym8 := z.EncBinary()
 66421  				_ = yym8
 66422  				if false {
 66423  				} else {
 66424  					r.EncodeInt(int64(x.NodesFiltered))
 66425  				}
 66426  			}
 66427  			if yyr2 || yy2arr2 {
 66428  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 66429  				if x.NodesAvailable == nil {
 66430  					r.EncodeNil()
 66431  				} else {
 66432  					yym10 := z.EncBinary()
 66433  					_ = yym10
 66434  					if false {
 66435  					} else {
 66436  						z.F.EncMapStringIntV(x.NodesAvailable, false, e)
 66437  					}
 66438  				}
 66439  			} else {
 66440  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 66441  				r.EncodeString(codecSelferC_UTF8100, string("NodesAvailable"))
 66442  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 66443  				if x.NodesAvailable == nil {
 66444  					r.EncodeNil()
 66445  				} else {
 66446  					yym11 := z.EncBinary()
 66447  					_ = yym11
 66448  					if false {
 66449  					} else {
 66450  						z.F.EncMapStringIntV(x.NodesAvailable, false, e)
 66451  					}
 66452  				}
 66453  			}
 66454  			if yyr2 || yy2arr2 {
 66455  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 66456  				if x.ClassFiltered == nil {
 66457  					r.EncodeNil()
 66458  				} else {
 66459  					yym13 := z.EncBinary()
 66460  					_ = yym13
 66461  					if false {
 66462  					} else {
 66463  						z.F.EncMapStringIntV(x.ClassFiltered, false, e)
 66464  					}
 66465  				}
 66466  			} else {
 66467  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 66468  				r.EncodeString(codecSelferC_UTF8100, string("ClassFiltered"))
 66469  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 66470  				if x.ClassFiltered == nil {
 66471  					r.EncodeNil()
 66472  				} else {
 66473  					yym14 := z.EncBinary()
 66474  					_ = yym14
 66475  					if false {
 66476  					} else {
 66477  						z.F.EncMapStringIntV(x.ClassFiltered, false, e)
 66478  					}
 66479  				}
 66480  			}
 66481  			if yyr2 || yy2arr2 {
 66482  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 66483  				if x.ConstraintFiltered == nil {
 66484  					r.EncodeNil()
 66485  				} else {
 66486  					yym16 := z.EncBinary()
 66487  					_ = yym16
 66488  					if false {
 66489  					} else {
 66490  						z.F.EncMapStringIntV(x.ConstraintFiltered, false, e)
 66491  					}
 66492  				}
 66493  			} else {
 66494  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 66495  				r.EncodeString(codecSelferC_UTF8100, string("ConstraintFiltered"))
 66496  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 66497  				if x.ConstraintFiltered == nil {
 66498  					r.EncodeNil()
 66499  				} else {
 66500  					yym17 := z.EncBinary()
 66501  					_ = yym17
 66502  					if false {
 66503  					} else {
 66504  						z.F.EncMapStringIntV(x.ConstraintFiltered, false, e)
 66505  					}
 66506  				}
 66507  			}
 66508  			if yyr2 || yy2arr2 {
 66509  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 66510  				yym19 := z.EncBinary()
 66511  				_ = yym19
 66512  				if false {
 66513  				} else {
 66514  					r.EncodeInt(int64(x.NodesExhausted))
 66515  				}
 66516  			} else {
 66517  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 66518  				r.EncodeString(codecSelferC_UTF8100, string("NodesExhausted"))
 66519  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 66520  				yym20 := z.EncBinary()
 66521  				_ = yym20
 66522  				if false {
 66523  				} else {
 66524  					r.EncodeInt(int64(x.NodesExhausted))
 66525  				}
 66526  			}
 66527  			if yyr2 || yy2arr2 {
 66528  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 66529  				if x.ClassExhausted == nil {
 66530  					r.EncodeNil()
 66531  				} else {
 66532  					yym22 := z.EncBinary()
 66533  					_ = yym22
 66534  					if false {
 66535  					} else {
 66536  						z.F.EncMapStringIntV(x.ClassExhausted, false, e)
 66537  					}
 66538  				}
 66539  			} else {
 66540  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 66541  				r.EncodeString(codecSelferC_UTF8100, string("ClassExhausted"))
 66542  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 66543  				if x.ClassExhausted == nil {
 66544  					r.EncodeNil()
 66545  				} else {
 66546  					yym23 := z.EncBinary()
 66547  					_ = yym23
 66548  					if false {
 66549  					} else {
 66550  						z.F.EncMapStringIntV(x.ClassExhausted, false, e)
 66551  					}
 66552  				}
 66553  			}
 66554  			if yyr2 || yy2arr2 {
 66555  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 66556  				if x.DimensionExhausted == nil {
 66557  					r.EncodeNil()
 66558  				} else {
 66559  					yym25 := z.EncBinary()
 66560  					_ = yym25
 66561  					if false {
 66562  					} else {
 66563  						z.F.EncMapStringIntV(x.DimensionExhausted, false, e)
 66564  					}
 66565  				}
 66566  			} else {
 66567  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 66568  				r.EncodeString(codecSelferC_UTF8100, string("DimensionExhausted"))
 66569  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 66570  				if x.DimensionExhausted == nil {
 66571  					r.EncodeNil()
 66572  				} else {
 66573  					yym26 := z.EncBinary()
 66574  					_ = yym26
 66575  					if false {
 66576  					} else {
 66577  						z.F.EncMapStringIntV(x.DimensionExhausted, false, e)
 66578  					}
 66579  				}
 66580  			}
 66581  			if yyr2 || yy2arr2 {
 66582  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 66583  				if x.QuotaExhausted == nil {
 66584  					r.EncodeNil()
 66585  				} else {
 66586  					yym28 := z.EncBinary()
 66587  					_ = yym28
 66588  					if false {
 66589  					} else {
 66590  						z.F.EncSliceStringV(x.QuotaExhausted, false, e)
 66591  					}
 66592  				}
 66593  			} else {
 66594  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 66595  				r.EncodeString(codecSelferC_UTF8100, string("QuotaExhausted"))
 66596  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 66597  				if x.QuotaExhausted == nil {
 66598  					r.EncodeNil()
 66599  				} else {
 66600  					yym29 := z.EncBinary()
 66601  					_ = yym29
 66602  					if false {
 66603  					} else {
 66604  						z.F.EncSliceStringV(x.QuotaExhausted, false, e)
 66605  					}
 66606  				}
 66607  			}
 66608  			if yyr2 || yy2arr2 {
 66609  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 66610  				if x.Scores == nil {
 66611  					r.EncodeNil()
 66612  				} else {
 66613  					yym31 := z.EncBinary()
 66614  					_ = yym31
 66615  					if false {
 66616  					} else {
 66617  						z.F.EncMapStringFloat64V(x.Scores, false, e)
 66618  					}
 66619  				}
 66620  			} else {
 66621  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 66622  				r.EncodeString(codecSelferC_UTF8100, string("Scores"))
 66623  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 66624  				if x.Scores == nil {
 66625  					r.EncodeNil()
 66626  				} else {
 66627  					yym32 := z.EncBinary()
 66628  					_ = yym32
 66629  					if false {
 66630  					} else {
 66631  						z.F.EncMapStringFloat64V(x.Scores, false, e)
 66632  					}
 66633  				}
 66634  			}
 66635  			if yyr2 || yy2arr2 {
 66636  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 66637  				yym34 := z.EncBinary()
 66638  				_ = yym34
 66639  				if false {
 66640  				} else if z.HasExtensions() && z.EncExt(x.AllocationTime) {
 66641  				} else {
 66642  					r.EncodeInt(int64(x.AllocationTime))
 66643  				}
 66644  			} else {
 66645  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 66646  				r.EncodeString(codecSelferC_UTF8100, string("AllocationTime"))
 66647  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 66648  				yym35 := z.EncBinary()
 66649  				_ = yym35
 66650  				if false {
 66651  				} else if z.HasExtensions() && z.EncExt(x.AllocationTime) {
 66652  				} else {
 66653  					r.EncodeInt(int64(x.AllocationTime))
 66654  				}
 66655  			}
 66656  			if yyr2 || yy2arr2 {
 66657  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 66658  				yym37 := z.EncBinary()
 66659  				_ = yym37
 66660  				if false {
 66661  				} else {
 66662  					r.EncodeInt(int64(x.CoalescedFailures))
 66663  				}
 66664  			} else {
 66665  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 66666  				r.EncodeString(codecSelferC_UTF8100, string("CoalescedFailures"))
 66667  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 66668  				yym38 := z.EncBinary()
 66669  				_ = yym38
 66670  				if false {
 66671  				} else {
 66672  					r.EncodeInt(int64(x.CoalescedFailures))
 66673  				}
 66674  			}
 66675  			if yyr2 || yy2arr2 {
 66676  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 66677  			} else {
 66678  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 66679  			}
 66680  		}
 66681  	}
 66682  }
 66683  
 66684  func (x *AllocMetric) CodecDecodeSelf(d *codec1978.Decoder) {
 66685  	var h codecSelfer100
 66686  	z, r := codec1978.GenHelperDecoder(d)
 66687  	_, _, _ = h, z, r
 66688  	yym1 := z.DecBinary()
 66689  	_ = yym1
 66690  	if false {
 66691  	} else if z.HasExtensions() && z.DecExt(x) {
 66692  	} else {
 66693  		yyct2 := r.ContainerType()
 66694  		if yyct2 == codecSelferValueTypeMap100 {
 66695  			yyl2 := r.ReadMapStart()
 66696  			if yyl2 == 0 {
 66697  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 66698  			} else {
 66699  				x.codecDecodeSelfFromMap(yyl2, d)
 66700  			}
 66701  		} else if yyct2 == codecSelferValueTypeArray100 {
 66702  			yyl2 := r.ReadArrayStart()
 66703  			if yyl2 == 0 {
 66704  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66705  			} else {
 66706  				x.codecDecodeSelfFromArray(yyl2, d)
 66707  			}
 66708  		} else {
 66709  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 66710  		}
 66711  	}
 66712  }
 66713  
 66714  func (x *AllocMetric) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 66715  	var h codecSelfer100
 66716  	z, r := codec1978.GenHelperDecoder(d)
 66717  	_, _, _ = h, z, r
 66718  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 66719  	_ = yys3Slc
 66720  	var yyhl3 bool = l >= 0
 66721  	for yyj3 := 0; ; yyj3++ {
 66722  		if yyhl3 {
 66723  			if yyj3 >= l {
 66724  				break
 66725  			}
 66726  		} else {
 66727  			if r.CheckBreak() {
 66728  				break
 66729  			}
 66730  		}
 66731  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 66732  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 66733  		yys3 := string(yys3Slc)
 66734  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 66735  		switch yys3 {
 66736  		case "NodesEvaluated":
 66737  			if r.TryDecodeAsNil() {
 66738  				x.NodesEvaluated = 0
 66739  			} else {
 66740  				yyv4 := &x.NodesEvaluated
 66741  				yym5 := z.DecBinary()
 66742  				_ = yym5
 66743  				if false {
 66744  				} else {
 66745  					*((*int)(yyv4)) = int(r.DecodeInt(codecSelferBitsize100))
 66746  				}
 66747  			}
 66748  		case "NodesFiltered":
 66749  			if r.TryDecodeAsNil() {
 66750  				x.NodesFiltered = 0
 66751  			} else {
 66752  				yyv6 := &x.NodesFiltered
 66753  				yym7 := z.DecBinary()
 66754  				_ = yym7
 66755  				if false {
 66756  				} else {
 66757  					*((*int)(yyv6)) = int(r.DecodeInt(codecSelferBitsize100))
 66758  				}
 66759  			}
 66760  		case "NodesAvailable":
 66761  			if r.TryDecodeAsNil() {
 66762  				x.NodesAvailable = nil
 66763  			} else {
 66764  				yyv8 := &x.NodesAvailable
 66765  				yym9 := z.DecBinary()
 66766  				_ = yym9
 66767  				if false {
 66768  				} else {
 66769  					z.F.DecMapStringIntX(yyv8, false, d)
 66770  				}
 66771  			}
 66772  		case "ClassFiltered":
 66773  			if r.TryDecodeAsNil() {
 66774  				x.ClassFiltered = nil
 66775  			} else {
 66776  				yyv10 := &x.ClassFiltered
 66777  				yym11 := z.DecBinary()
 66778  				_ = yym11
 66779  				if false {
 66780  				} else {
 66781  					z.F.DecMapStringIntX(yyv10, false, d)
 66782  				}
 66783  			}
 66784  		case "ConstraintFiltered":
 66785  			if r.TryDecodeAsNil() {
 66786  				x.ConstraintFiltered = nil
 66787  			} else {
 66788  				yyv12 := &x.ConstraintFiltered
 66789  				yym13 := z.DecBinary()
 66790  				_ = yym13
 66791  				if false {
 66792  				} else {
 66793  					z.F.DecMapStringIntX(yyv12, false, d)
 66794  				}
 66795  			}
 66796  		case "NodesExhausted":
 66797  			if r.TryDecodeAsNil() {
 66798  				x.NodesExhausted = 0
 66799  			} else {
 66800  				yyv14 := &x.NodesExhausted
 66801  				yym15 := z.DecBinary()
 66802  				_ = yym15
 66803  				if false {
 66804  				} else {
 66805  					*((*int)(yyv14)) = int(r.DecodeInt(codecSelferBitsize100))
 66806  				}
 66807  			}
 66808  		case "ClassExhausted":
 66809  			if r.TryDecodeAsNil() {
 66810  				x.ClassExhausted = nil
 66811  			} else {
 66812  				yyv16 := &x.ClassExhausted
 66813  				yym17 := z.DecBinary()
 66814  				_ = yym17
 66815  				if false {
 66816  				} else {
 66817  					z.F.DecMapStringIntX(yyv16, false, d)
 66818  				}
 66819  			}
 66820  		case "DimensionExhausted":
 66821  			if r.TryDecodeAsNil() {
 66822  				x.DimensionExhausted = nil
 66823  			} else {
 66824  				yyv18 := &x.DimensionExhausted
 66825  				yym19 := z.DecBinary()
 66826  				_ = yym19
 66827  				if false {
 66828  				} else {
 66829  					z.F.DecMapStringIntX(yyv18, false, d)
 66830  				}
 66831  			}
 66832  		case "QuotaExhausted":
 66833  			if r.TryDecodeAsNil() {
 66834  				x.QuotaExhausted = nil
 66835  			} else {
 66836  				yyv20 := &x.QuotaExhausted
 66837  				yym21 := z.DecBinary()
 66838  				_ = yym21
 66839  				if false {
 66840  				} else {
 66841  					z.F.DecSliceStringX(yyv20, false, d)
 66842  				}
 66843  			}
 66844  		case "Scores":
 66845  			if r.TryDecodeAsNil() {
 66846  				x.Scores = nil
 66847  			} else {
 66848  				yyv22 := &x.Scores
 66849  				yym23 := z.DecBinary()
 66850  				_ = yym23
 66851  				if false {
 66852  				} else {
 66853  					z.F.DecMapStringFloat64X(yyv22, false, d)
 66854  				}
 66855  			}
 66856  		case "AllocationTime":
 66857  			if r.TryDecodeAsNil() {
 66858  				x.AllocationTime = 0
 66859  			} else {
 66860  				yyv24 := &x.AllocationTime
 66861  				yym25 := z.DecBinary()
 66862  				_ = yym25
 66863  				if false {
 66864  				} else if z.HasExtensions() && z.DecExt(yyv24) {
 66865  				} else {
 66866  					*((*int64)(yyv24)) = int64(r.DecodeInt(64))
 66867  				}
 66868  			}
 66869  		case "CoalescedFailures":
 66870  			if r.TryDecodeAsNil() {
 66871  				x.CoalescedFailures = 0
 66872  			} else {
 66873  				yyv26 := &x.CoalescedFailures
 66874  				yym27 := z.DecBinary()
 66875  				_ = yym27
 66876  				if false {
 66877  				} else {
 66878  					*((*int)(yyv26)) = int(r.DecodeInt(codecSelferBitsize100))
 66879  				}
 66880  			}
 66881  		default:
 66882  			z.DecStructFieldNotFound(-1, yys3)
 66883  		} // end switch yys3
 66884  	} // end for yyj3
 66885  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 66886  }
 66887  
 66888  func (x *AllocMetric) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 66889  	var h codecSelfer100
 66890  	z, r := codec1978.GenHelperDecoder(d)
 66891  	_, _, _ = h, z, r
 66892  	var yyj28 int
 66893  	var yyb28 bool
 66894  	var yyhl28 bool = l >= 0
 66895  	yyj28++
 66896  	if yyhl28 {
 66897  		yyb28 = yyj28 > l
 66898  	} else {
 66899  		yyb28 = r.CheckBreak()
 66900  	}
 66901  	if yyb28 {
 66902  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66903  		return
 66904  	}
 66905  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66906  	if r.TryDecodeAsNil() {
 66907  		x.NodesEvaluated = 0
 66908  	} else {
 66909  		yyv29 := &x.NodesEvaluated
 66910  		yym30 := z.DecBinary()
 66911  		_ = yym30
 66912  		if false {
 66913  		} else {
 66914  			*((*int)(yyv29)) = int(r.DecodeInt(codecSelferBitsize100))
 66915  		}
 66916  	}
 66917  	yyj28++
 66918  	if yyhl28 {
 66919  		yyb28 = yyj28 > l
 66920  	} else {
 66921  		yyb28 = r.CheckBreak()
 66922  	}
 66923  	if yyb28 {
 66924  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66925  		return
 66926  	}
 66927  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66928  	if r.TryDecodeAsNil() {
 66929  		x.NodesFiltered = 0
 66930  	} else {
 66931  		yyv31 := &x.NodesFiltered
 66932  		yym32 := z.DecBinary()
 66933  		_ = yym32
 66934  		if false {
 66935  		} else {
 66936  			*((*int)(yyv31)) = int(r.DecodeInt(codecSelferBitsize100))
 66937  		}
 66938  	}
 66939  	yyj28++
 66940  	if yyhl28 {
 66941  		yyb28 = yyj28 > l
 66942  	} else {
 66943  		yyb28 = r.CheckBreak()
 66944  	}
 66945  	if yyb28 {
 66946  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66947  		return
 66948  	}
 66949  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66950  	if r.TryDecodeAsNil() {
 66951  		x.NodesAvailable = nil
 66952  	} else {
 66953  		yyv33 := &x.NodesAvailable
 66954  		yym34 := z.DecBinary()
 66955  		_ = yym34
 66956  		if false {
 66957  		} else {
 66958  			z.F.DecMapStringIntX(yyv33, false, d)
 66959  		}
 66960  	}
 66961  	yyj28++
 66962  	if yyhl28 {
 66963  		yyb28 = yyj28 > l
 66964  	} else {
 66965  		yyb28 = r.CheckBreak()
 66966  	}
 66967  	if yyb28 {
 66968  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66969  		return
 66970  	}
 66971  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66972  	if r.TryDecodeAsNil() {
 66973  		x.ClassFiltered = nil
 66974  	} else {
 66975  		yyv35 := &x.ClassFiltered
 66976  		yym36 := z.DecBinary()
 66977  		_ = yym36
 66978  		if false {
 66979  		} else {
 66980  			z.F.DecMapStringIntX(yyv35, false, d)
 66981  		}
 66982  	}
 66983  	yyj28++
 66984  	if yyhl28 {
 66985  		yyb28 = yyj28 > l
 66986  	} else {
 66987  		yyb28 = r.CheckBreak()
 66988  	}
 66989  	if yyb28 {
 66990  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 66991  		return
 66992  	}
 66993  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 66994  	if r.TryDecodeAsNil() {
 66995  		x.ConstraintFiltered = nil
 66996  	} else {
 66997  		yyv37 := &x.ConstraintFiltered
 66998  		yym38 := z.DecBinary()
 66999  		_ = yym38
 67000  		if false {
 67001  		} else {
 67002  			z.F.DecMapStringIntX(yyv37, false, d)
 67003  		}
 67004  	}
 67005  	yyj28++
 67006  	if yyhl28 {
 67007  		yyb28 = yyj28 > l
 67008  	} else {
 67009  		yyb28 = r.CheckBreak()
 67010  	}
 67011  	if yyb28 {
 67012  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 67013  		return
 67014  	}
 67015  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 67016  	if r.TryDecodeAsNil() {
 67017  		x.NodesExhausted = 0
 67018  	} else {
 67019  		yyv39 := &x.NodesExhausted
 67020  		yym40 := z.DecBinary()
 67021  		_ = yym40
 67022  		if false {
 67023  		} else {
 67024  			*((*int)(yyv39)) = int(r.DecodeInt(codecSelferBitsize100))
 67025  		}
 67026  	}
 67027  	yyj28++
 67028  	if yyhl28 {
 67029  		yyb28 = yyj28 > l
 67030  	} else {
 67031  		yyb28 = r.CheckBreak()
 67032  	}
 67033  	if yyb28 {
 67034  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 67035  		return
 67036  	}
 67037  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 67038  	if r.TryDecodeAsNil() {
 67039  		x.ClassExhausted = nil
 67040  	} else {
 67041  		yyv41 := &x.ClassExhausted
 67042  		yym42 := z.DecBinary()
 67043  		_ = yym42
 67044  		if false {
 67045  		} else {
 67046  			z.F.DecMapStringIntX(yyv41, false, d)
 67047  		}
 67048  	}
 67049  	yyj28++
 67050  	if yyhl28 {
 67051  		yyb28 = yyj28 > l
 67052  	} else {
 67053  		yyb28 = r.CheckBreak()
 67054  	}
 67055  	if yyb28 {
 67056  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 67057  		return
 67058  	}
 67059  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 67060  	if r.TryDecodeAsNil() {
 67061  		x.DimensionExhausted = nil
 67062  	} else {
 67063  		yyv43 := &x.DimensionExhausted
 67064  		yym44 := z.DecBinary()
 67065  		_ = yym44
 67066  		if false {
 67067  		} else {
 67068  			z.F.DecMapStringIntX(yyv43, false, d)
 67069  		}
 67070  	}
 67071  	yyj28++
 67072  	if yyhl28 {
 67073  		yyb28 = yyj28 > l
 67074  	} else {
 67075  		yyb28 = r.CheckBreak()
 67076  	}
 67077  	if yyb28 {
 67078  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 67079  		return
 67080  	}
 67081  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 67082  	if r.TryDecodeAsNil() {
 67083  		x.QuotaExhausted = nil
 67084  	} else {
 67085  		yyv45 := &x.QuotaExhausted
 67086  		yym46 := z.DecBinary()
 67087  		_ = yym46
 67088  		if false {
 67089  		} else {
 67090  			z.F.DecSliceStringX(yyv45, false, d)
 67091  		}
 67092  	}
 67093  	yyj28++
 67094  	if yyhl28 {
 67095  		yyb28 = yyj28 > l
 67096  	} else {
 67097  		yyb28 = r.CheckBreak()
 67098  	}
 67099  	if yyb28 {
 67100  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 67101  		return
 67102  	}
 67103  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 67104  	if r.TryDecodeAsNil() {
 67105  		x.Scores = nil
 67106  	} else {
 67107  		yyv47 := &x.Scores
 67108  		yym48 := z.DecBinary()
 67109  		_ = yym48
 67110  		if false {
 67111  		} else {
 67112  			z.F.DecMapStringFloat64X(yyv47, false, d)
 67113  		}
 67114  	}
 67115  	yyj28++
 67116  	if yyhl28 {
 67117  		yyb28 = yyj28 > l
 67118  	} else {
 67119  		yyb28 = r.CheckBreak()
 67120  	}
 67121  	if yyb28 {
 67122  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 67123  		return
 67124  	}
 67125  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 67126  	if r.TryDecodeAsNil() {
 67127  		x.AllocationTime = 0
 67128  	} else {
 67129  		yyv49 := &x.AllocationTime
 67130  		yym50 := z.DecBinary()
 67131  		_ = yym50
 67132  		if false {
 67133  		} else if z.HasExtensions() && z.DecExt(yyv49) {
 67134  		} else {
 67135  			*((*int64)(yyv49)) = int64(r.DecodeInt(64))
 67136  		}
 67137  	}
 67138  	yyj28++
 67139  	if yyhl28 {
 67140  		yyb28 = yyj28 > l
 67141  	} else {
 67142  		yyb28 = r.CheckBreak()
 67143  	}
 67144  	if yyb28 {
 67145  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 67146  		return
 67147  	}
 67148  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 67149  	if r.TryDecodeAsNil() {
 67150  		x.CoalescedFailures = 0
 67151  	} else {
 67152  		yyv51 := &x.CoalescedFailures
 67153  		yym52 := z.DecBinary()
 67154  		_ = yym52
 67155  		if false {
 67156  		} else {
 67157  			*((*int)(yyv51)) = int(r.DecodeInt(codecSelferBitsize100))
 67158  		}
 67159  	}
 67160  	for {
 67161  		yyj28++
 67162  		if yyhl28 {
 67163  			yyb28 = yyj28 > l
 67164  		} else {
 67165  			yyb28 = r.CheckBreak()
 67166  		}
 67167  		if yyb28 {
 67168  			break
 67169  		}
 67170  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 67171  		z.DecStructFieldNotFound(yyj28-1, "")
 67172  	}
 67173  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 67174  }
 67175  
 67176  func (x *AllocDeploymentStatus) CodecEncodeSelf(e *codec1978.Encoder) {
 67177  	var h codecSelfer100
 67178  	z, r := codec1978.GenHelperEncoder(e)
 67179  	_, _, _ = h, z, r
 67180  	if x == nil {
 67181  		r.EncodeNil()
 67182  	} else {
 67183  		yym1 := z.EncBinary()
 67184  		_ = yym1
 67185  		if false {
 67186  		} else if z.HasExtensions() && z.EncExt(x) {
 67187  		} else {
 67188  			yysep2 := !z.EncBinary()
 67189  			yy2arr2 := z.EncBasicHandle().StructToArray
 67190  			var yyq2 [2]bool
 67191  			_, _, _ = yysep2, yyq2, yy2arr2
 67192  			const yyr2 bool = false
 67193  			var yynn2 int
 67194  			if yyr2 || yy2arr2 {
 67195  				r.EncodeArrayStart(2)
 67196  			} else {
 67197  				yynn2 = 2
 67198  				for _, b := range yyq2 {
 67199  					if b {
 67200  						yynn2++
 67201  					}
 67202  				}
 67203  				r.EncodeMapStart(yynn2)
 67204  				yynn2 = 0
 67205  			}
 67206  			if yyr2 || yy2arr2 {
 67207  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67208  				if x.Healthy == nil {
 67209  					r.EncodeNil()
 67210  				} else {
 67211  					yy4 := *x.Healthy
 67212  					yym5 := z.EncBinary()
 67213  					_ = yym5
 67214  					if false {
 67215  					} else {
 67216  						r.EncodeBool(bool(yy4))
 67217  					}
 67218  				}
 67219  			} else {
 67220  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67221  				r.EncodeString(codecSelferC_UTF8100, string("Healthy"))
 67222  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67223  				if x.Healthy == nil {
 67224  					r.EncodeNil()
 67225  				} else {
 67226  					yy6 := *x.Healthy
 67227  					yym7 := z.EncBinary()
 67228  					_ = yym7
 67229  					if false {
 67230  					} else {
 67231  						r.EncodeBool(bool(yy6))
 67232  					}
 67233  				}
 67234  			}
 67235  			if yyr2 || yy2arr2 {
 67236  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67237  				yym9 := z.EncBinary()
 67238  				_ = yym9
 67239  				if false {
 67240  				} else {
 67241  					r.EncodeUint(uint64(x.ModifyIndex))
 67242  				}
 67243  			} else {
 67244  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67245  				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
 67246  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67247  				yym10 := z.EncBinary()
 67248  				_ = yym10
 67249  				if false {
 67250  				} else {
 67251  					r.EncodeUint(uint64(x.ModifyIndex))
 67252  				}
 67253  			}
 67254  			if yyr2 || yy2arr2 {
 67255  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 67256  			} else {
 67257  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 67258  			}
 67259  		}
 67260  	}
 67261  }
 67262  
 67263  func (x *AllocDeploymentStatus) CodecDecodeSelf(d *codec1978.Decoder) {
 67264  	var h codecSelfer100
 67265  	z, r := codec1978.GenHelperDecoder(d)
 67266  	_, _, _ = h, z, r
 67267  	yym1 := z.DecBinary()
 67268  	_ = yym1
 67269  	if false {
 67270  	} else if z.HasExtensions() && z.DecExt(x) {
 67271  	} else {
 67272  		yyct2 := r.ContainerType()
 67273  		if yyct2 == codecSelferValueTypeMap100 {
 67274  			yyl2 := r.ReadMapStart()
 67275  			if yyl2 == 0 {
 67276  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 67277  			} else {
 67278  				x.codecDecodeSelfFromMap(yyl2, d)
 67279  			}
 67280  		} else if yyct2 == codecSelferValueTypeArray100 {
 67281  			yyl2 := r.ReadArrayStart()
 67282  			if yyl2 == 0 {
 67283  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 67284  			} else {
 67285  				x.codecDecodeSelfFromArray(yyl2, d)
 67286  			}
 67287  		} else {
 67288  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 67289  		}
 67290  	}
 67291  }
 67292  
 67293  func (x *AllocDeploymentStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 67294  	var h codecSelfer100
 67295  	z, r := codec1978.GenHelperDecoder(d)
 67296  	_, _, _ = h, z, r
 67297  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 67298  	_ = yys3Slc
 67299  	var yyhl3 bool = l >= 0
 67300  	for yyj3 := 0; ; yyj3++ {
 67301  		if yyhl3 {
 67302  			if yyj3 >= l {
 67303  				break
 67304  			}
 67305  		} else {
 67306  			if r.CheckBreak() {
 67307  				break
 67308  			}
 67309  		}
 67310  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 67311  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 67312  		yys3 := string(yys3Slc)
 67313  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 67314  		switch yys3 {
 67315  		case "Healthy":
 67316  			if r.TryDecodeAsNil() {
 67317  				if x.Healthy != nil {
 67318  					x.Healthy = nil
 67319  				}
 67320  			} else {
 67321  				if x.Healthy == nil {
 67322  					x.Healthy = new(bool)
 67323  				}
 67324  				yym5 := z.DecBinary()
 67325  				_ = yym5
 67326  				if false {
 67327  				} else {
 67328  					*((*bool)(x.Healthy)) = r.DecodeBool()
 67329  				}
 67330  			}
 67331  		case "ModifyIndex":
 67332  			if r.TryDecodeAsNil() {
 67333  				x.ModifyIndex = 0
 67334  			} else {
 67335  				yyv6 := &x.ModifyIndex
 67336  				yym7 := z.DecBinary()
 67337  				_ = yym7
 67338  				if false {
 67339  				} else {
 67340  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 67341  				}
 67342  			}
 67343  		default:
 67344  			z.DecStructFieldNotFound(-1, yys3)
 67345  		} // end switch yys3
 67346  	} // end for yyj3
 67347  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 67348  }
 67349  
 67350  func (x *AllocDeploymentStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 67351  	var h codecSelfer100
 67352  	z, r := codec1978.GenHelperDecoder(d)
 67353  	_, _, _ = h, z, r
 67354  	var yyj8 int
 67355  	var yyb8 bool
 67356  	var yyhl8 bool = l >= 0
 67357  	yyj8++
 67358  	if yyhl8 {
 67359  		yyb8 = yyj8 > l
 67360  	} else {
 67361  		yyb8 = r.CheckBreak()
 67362  	}
 67363  	if yyb8 {
 67364  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 67365  		return
 67366  	}
 67367  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 67368  	if r.TryDecodeAsNil() {
 67369  		if x.Healthy != nil {
 67370  			x.Healthy = nil
 67371  		}
 67372  	} else {
 67373  		if x.Healthy == nil {
 67374  			x.Healthy = new(bool)
 67375  		}
 67376  		yym10 := z.DecBinary()
 67377  		_ = yym10
 67378  		if false {
 67379  		} else {
 67380  			*((*bool)(x.Healthy)) = r.DecodeBool()
 67381  		}
 67382  	}
 67383  	yyj8++
 67384  	if yyhl8 {
 67385  		yyb8 = yyj8 > l
 67386  	} else {
 67387  		yyb8 = r.CheckBreak()
 67388  	}
 67389  	if yyb8 {
 67390  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 67391  		return
 67392  	}
 67393  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 67394  	if r.TryDecodeAsNil() {
 67395  		x.ModifyIndex = 0
 67396  	} else {
 67397  		yyv11 := &x.ModifyIndex
 67398  		yym12 := z.DecBinary()
 67399  		_ = yym12
 67400  		if false {
 67401  		} else {
 67402  			*((*uint64)(yyv11)) = uint64(r.DecodeUint(64))
 67403  		}
 67404  	}
 67405  	for {
 67406  		yyj8++
 67407  		if yyhl8 {
 67408  			yyb8 = yyj8 > l
 67409  		} else {
 67410  			yyb8 = r.CheckBreak()
 67411  		}
 67412  		if yyb8 {
 67413  			break
 67414  		}
 67415  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 67416  		z.DecStructFieldNotFound(yyj8-1, "")
 67417  	}
 67418  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 67419  }
 67420  
 67421  func (x *Evaluation) CodecEncodeSelf(e *codec1978.Encoder) {
 67422  	var h codecSelfer100
 67423  	z, r := codec1978.GenHelperEncoder(e)
 67424  	_, _, _ = h, z, r
 67425  	if x == nil {
 67426  		r.EncodeNil()
 67427  	} else {
 67428  		yym1 := z.EncBinary()
 67429  		_ = yym1
 67430  		if false {
 67431  		} else if z.HasExtensions() && z.EncExt(x) {
 67432  		} else {
 67433  			yysep2 := !z.EncBinary()
 67434  			yy2arr2 := z.EncBasicHandle().StructToArray
 67435  			var yyq2 [27]bool
 67436  			_, _, _ = yysep2, yyq2, yy2arr2
 67437  			const yyr2 bool = false
 67438  			var yynn2 int
 67439  			if yyr2 || yy2arr2 {
 67440  				r.EncodeArrayStart(27)
 67441  			} else {
 67442  				yynn2 = 27
 67443  				for _, b := range yyq2 {
 67444  					if b {
 67445  						yynn2++
 67446  					}
 67447  				}
 67448  				r.EncodeMapStart(yynn2)
 67449  				yynn2 = 0
 67450  			}
 67451  			if yyr2 || yy2arr2 {
 67452  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67453  				yym4 := z.EncBinary()
 67454  				_ = yym4
 67455  				if false {
 67456  				} else {
 67457  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 67458  				}
 67459  			} else {
 67460  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67461  				r.EncodeString(codecSelferC_UTF8100, string("ID"))
 67462  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67463  				yym5 := z.EncBinary()
 67464  				_ = yym5
 67465  				if false {
 67466  				} else {
 67467  					r.EncodeString(codecSelferC_UTF8100, string(x.ID))
 67468  				}
 67469  			}
 67470  			if yyr2 || yy2arr2 {
 67471  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67472  				yym7 := z.EncBinary()
 67473  				_ = yym7
 67474  				if false {
 67475  				} else {
 67476  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 67477  				}
 67478  			} else {
 67479  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67480  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 67481  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67482  				yym8 := z.EncBinary()
 67483  				_ = yym8
 67484  				if false {
 67485  				} else {
 67486  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 67487  				}
 67488  			}
 67489  			if yyr2 || yy2arr2 {
 67490  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67491  				yym10 := z.EncBinary()
 67492  				_ = yym10
 67493  				if false {
 67494  				} else {
 67495  					r.EncodeInt(int64(x.Priority))
 67496  				}
 67497  			} else {
 67498  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67499  				r.EncodeString(codecSelferC_UTF8100, string("Priority"))
 67500  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67501  				yym11 := z.EncBinary()
 67502  				_ = yym11
 67503  				if false {
 67504  				} else {
 67505  					r.EncodeInt(int64(x.Priority))
 67506  				}
 67507  			}
 67508  			if yyr2 || yy2arr2 {
 67509  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67510  				yym13 := z.EncBinary()
 67511  				_ = yym13
 67512  				if false {
 67513  				} else {
 67514  					r.EncodeString(codecSelferC_UTF8100, string(x.Type))
 67515  				}
 67516  			} else {
 67517  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67518  				r.EncodeString(codecSelferC_UTF8100, string("Type"))
 67519  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67520  				yym14 := z.EncBinary()
 67521  				_ = yym14
 67522  				if false {
 67523  				} else {
 67524  					r.EncodeString(codecSelferC_UTF8100, string(x.Type))
 67525  				}
 67526  			}
 67527  			if yyr2 || yy2arr2 {
 67528  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67529  				yym16 := z.EncBinary()
 67530  				_ = yym16
 67531  				if false {
 67532  				} else {
 67533  					r.EncodeString(codecSelferC_UTF8100, string(x.TriggeredBy))
 67534  				}
 67535  			} else {
 67536  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67537  				r.EncodeString(codecSelferC_UTF8100, string("TriggeredBy"))
 67538  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67539  				yym17 := z.EncBinary()
 67540  				_ = yym17
 67541  				if false {
 67542  				} else {
 67543  					r.EncodeString(codecSelferC_UTF8100, string(x.TriggeredBy))
 67544  				}
 67545  			}
 67546  			if yyr2 || yy2arr2 {
 67547  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67548  				yym19 := z.EncBinary()
 67549  				_ = yym19
 67550  				if false {
 67551  				} else {
 67552  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 67553  				}
 67554  			} else {
 67555  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67556  				r.EncodeString(codecSelferC_UTF8100, string("JobID"))
 67557  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67558  				yym20 := z.EncBinary()
 67559  				_ = yym20
 67560  				if false {
 67561  				} else {
 67562  					r.EncodeString(codecSelferC_UTF8100, string(x.JobID))
 67563  				}
 67564  			}
 67565  			if yyr2 || yy2arr2 {
 67566  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67567  				yym22 := z.EncBinary()
 67568  				_ = yym22
 67569  				if false {
 67570  				} else {
 67571  					r.EncodeUint(uint64(x.JobModifyIndex))
 67572  				}
 67573  			} else {
 67574  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67575  				r.EncodeString(codecSelferC_UTF8100, string("JobModifyIndex"))
 67576  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67577  				yym23 := z.EncBinary()
 67578  				_ = yym23
 67579  				if false {
 67580  				} else {
 67581  					r.EncodeUint(uint64(x.JobModifyIndex))
 67582  				}
 67583  			}
 67584  			if yyr2 || yy2arr2 {
 67585  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67586  				yym25 := z.EncBinary()
 67587  				_ = yym25
 67588  				if false {
 67589  				} else {
 67590  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
 67591  				}
 67592  			} else {
 67593  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67594  				r.EncodeString(codecSelferC_UTF8100, string("NodeID"))
 67595  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67596  				yym26 := z.EncBinary()
 67597  				_ = yym26
 67598  				if false {
 67599  				} else {
 67600  					r.EncodeString(codecSelferC_UTF8100, string(x.NodeID))
 67601  				}
 67602  			}
 67603  			if yyr2 || yy2arr2 {
 67604  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67605  				yym28 := z.EncBinary()
 67606  				_ = yym28
 67607  				if false {
 67608  				} else {
 67609  					r.EncodeUint(uint64(x.NodeModifyIndex))
 67610  				}
 67611  			} else {
 67612  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67613  				r.EncodeString(codecSelferC_UTF8100, string("NodeModifyIndex"))
 67614  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67615  				yym29 := z.EncBinary()
 67616  				_ = yym29
 67617  				if false {
 67618  				} else {
 67619  					r.EncodeUint(uint64(x.NodeModifyIndex))
 67620  				}
 67621  			}
 67622  			if yyr2 || yy2arr2 {
 67623  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67624  				yym31 := z.EncBinary()
 67625  				_ = yym31
 67626  				if false {
 67627  				} else {
 67628  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 67629  				}
 67630  			} else {
 67631  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67632  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentID"))
 67633  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67634  				yym32 := z.EncBinary()
 67635  				_ = yym32
 67636  				if false {
 67637  				} else {
 67638  					r.EncodeString(codecSelferC_UTF8100, string(x.DeploymentID))
 67639  				}
 67640  			}
 67641  			if yyr2 || yy2arr2 {
 67642  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67643  				yym34 := z.EncBinary()
 67644  				_ = yym34
 67645  				if false {
 67646  				} else {
 67647  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 67648  				}
 67649  			} else {
 67650  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67651  				r.EncodeString(codecSelferC_UTF8100, string("Status"))
 67652  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67653  				yym35 := z.EncBinary()
 67654  				_ = yym35
 67655  				if false {
 67656  				} else {
 67657  					r.EncodeString(codecSelferC_UTF8100, string(x.Status))
 67658  				}
 67659  			}
 67660  			if yyr2 || yy2arr2 {
 67661  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67662  				yym37 := z.EncBinary()
 67663  				_ = yym37
 67664  				if false {
 67665  				} else {
 67666  					r.EncodeString(codecSelferC_UTF8100, string(x.StatusDescription))
 67667  				}
 67668  			} else {
 67669  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67670  				r.EncodeString(codecSelferC_UTF8100, string("StatusDescription"))
 67671  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67672  				yym38 := z.EncBinary()
 67673  				_ = yym38
 67674  				if false {
 67675  				} else {
 67676  					r.EncodeString(codecSelferC_UTF8100, string(x.StatusDescription))
 67677  				}
 67678  			}
 67679  			if yyr2 || yy2arr2 {
 67680  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67681  				yym40 := z.EncBinary()
 67682  				_ = yym40
 67683  				if false {
 67684  				} else if z.HasExtensions() && z.EncExt(x.Wait) {
 67685  				} else {
 67686  					r.EncodeInt(int64(x.Wait))
 67687  				}
 67688  			} else {
 67689  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67690  				r.EncodeString(codecSelferC_UTF8100, string("Wait"))
 67691  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67692  				yym41 := z.EncBinary()
 67693  				_ = yym41
 67694  				if false {
 67695  				} else if z.HasExtensions() && z.EncExt(x.Wait) {
 67696  				} else {
 67697  					r.EncodeInt(int64(x.Wait))
 67698  				}
 67699  			}
 67700  			if yyr2 || yy2arr2 {
 67701  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67702  				yy43 := &x.WaitUntil
 67703  				yym44 := z.EncBinary()
 67704  				_ = yym44
 67705  				if false {
 67706  				} else if yym45 := z.TimeRtidIfBinc(); yym45 != 0 {
 67707  					r.EncodeBuiltin(yym45, yy43)
 67708  				} else if z.HasExtensions() && z.EncExt(yy43) {
 67709  				} else if yym44 {
 67710  					z.EncBinaryMarshal(yy43)
 67711  				} else if !yym44 && z.IsJSONHandle() {
 67712  					z.EncJSONMarshal(yy43)
 67713  				} else {
 67714  					z.EncFallback(yy43)
 67715  				}
 67716  			} else {
 67717  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67718  				r.EncodeString(codecSelferC_UTF8100, string("WaitUntil"))
 67719  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67720  				yy46 := &x.WaitUntil
 67721  				yym47 := z.EncBinary()
 67722  				_ = yym47
 67723  				if false {
 67724  				} else if yym48 := z.TimeRtidIfBinc(); yym48 != 0 {
 67725  					r.EncodeBuiltin(yym48, yy46)
 67726  				} else if z.HasExtensions() && z.EncExt(yy46) {
 67727  				} else if yym47 {
 67728  					z.EncBinaryMarshal(yy46)
 67729  				} else if !yym47 && z.IsJSONHandle() {
 67730  					z.EncJSONMarshal(yy46)
 67731  				} else {
 67732  					z.EncFallback(yy46)
 67733  				}
 67734  			}
 67735  			if yyr2 || yy2arr2 {
 67736  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67737  				yym50 := z.EncBinary()
 67738  				_ = yym50
 67739  				if false {
 67740  				} else {
 67741  					r.EncodeString(codecSelferC_UTF8100, string(x.NextEval))
 67742  				}
 67743  			} else {
 67744  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67745  				r.EncodeString(codecSelferC_UTF8100, string("NextEval"))
 67746  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67747  				yym51 := z.EncBinary()
 67748  				_ = yym51
 67749  				if false {
 67750  				} else {
 67751  					r.EncodeString(codecSelferC_UTF8100, string(x.NextEval))
 67752  				}
 67753  			}
 67754  			if yyr2 || yy2arr2 {
 67755  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67756  				yym53 := z.EncBinary()
 67757  				_ = yym53
 67758  				if false {
 67759  				} else {
 67760  					r.EncodeString(codecSelferC_UTF8100, string(x.PreviousEval))
 67761  				}
 67762  			} else {
 67763  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67764  				r.EncodeString(codecSelferC_UTF8100, string("PreviousEval"))
 67765  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67766  				yym54 := z.EncBinary()
 67767  				_ = yym54
 67768  				if false {
 67769  				} else {
 67770  					r.EncodeString(codecSelferC_UTF8100, string(x.PreviousEval))
 67771  				}
 67772  			}
 67773  			if yyr2 || yy2arr2 {
 67774  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67775  				yym56 := z.EncBinary()
 67776  				_ = yym56
 67777  				if false {
 67778  				} else {
 67779  					r.EncodeString(codecSelferC_UTF8100, string(x.BlockedEval))
 67780  				}
 67781  			} else {
 67782  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67783  				r.EncodeString(codecSelferC_UTF8100, string("BlockedEval"))
 67784  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67785  				yym57 := z.EncBinary()
 67786  				_ = yym57
 67787  				if false {
 67788  				} else {
 67789  					r.EncodeString(codecSelferC_UTF8100, string(x.BlockedEval))
 67790  				}
 67791  			}
 67792  			if yyr2 || yy2arr2 {
 67793  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67794  				if x.FailedTGAllocs == nil {
 67795  					r.EncodeNil()
 67796  				} else {
 67797  					yym59 := z.EncBinary()
 67798  					_ = yym59
 67799  					if false {
 67800  					} else {
 67801  						h.encMapstringPtrtoAllocMetric((map[string]*AllocMetric)(x.FailedTGAllocs), e)
 67802  					}
 67803  				}
 67804  			} else {
 67805  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67806  				r.EncodeString(codecSelferC_UTF8100, string("FailedTGAllocs"))
 67807  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67808  				if x.FailedTGAllocs == nil {
 67809  					r.EncodeNil()
 67810  				} else {
 67811  					yym60 := z.EncBinary()
 67812  					_ = yym60
 67813  					if false {
 67814  					} else {
 67815  						h.encMapstringPtrtoAllocMetric((map[string]*AllocMetric)(x.FailedTGAllocs), e)
 67816  					}
 67817  				}
 67818  			}
 67819  			if yyr2 || yy2arr2 {
 67820  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67821  				if x.ClassEligibility == nil {
 67822  					r.EncodeNil()
 67823  				} else {
 67824  					yym62 := z.EncBinary()
 67825  					_ = yym62
 67826  					if false {
 67827  					} else {
 67828  						z.F.EncMapStringBoolV(x.ClassEligibility, false, e)
 67829  					}
 67830  				}
 67831  			} else {
 67832  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67833  				r.EncodeString(codecSelferC_UTF8100, string("ClassEligibility"))
 67834  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67835  				if x.ClassEligibility == nil {
 67836  					r.EncodeNil()
 67837  				} else {
 67838  					yym63 := z.EncBinary()
 67839  					_ = yym63
 67840  					if false {
 67841  					} else {
 67842  						z.F.EncMapStringBoolV(x.ClassEligibility, false, e)
 67843  					}
 67844  				}
 67845  			}
 67846  			if yyr2 || yy2arr2 {
 67847  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67848  				yym65 := z.EncBinary()
 67849  				_ = yym65
 67850  				if false {
 67851  				} else {
 67852  					r.EncodeString(codecSelferC_UTF8100, string(x.QuotaLimitReached))
 67853  				}
 67854  			} else {
 67855  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67856  				r.EncodeString(codecSelferC_UTF8100, string("QuotaLimitReached"))
 67857  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67858  				yym66 := z.EncBinary()
 67859  				_ = yym66
 67860  				if false {
 67861  				} else {
 67862  					r.EncodeString(codecSelferC_UTF8100, string(x.QuotaLimitReached))
 67863  				}
 67864  			}
 67865  			if yyr2 || yy2arr2 {
 67866  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67867  				yym68 := z.EncBinary()
 67868  				_ = yym68
 67869  				if false {
 67870  				} else {
 67871  					r.EncodeBool(bool(x.EscapedComputedClass))
 67872  				}
 67873  			} else {
 67874  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67875  				r.EncodeString(codecSelferC_UTF8100, string("EscapedComputedClass"))
 67876  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67877  				yym69 := z.EncBinary()
 67878  				_ = yym69
 67879  				if false {
 67880  				} else {
 67881  					r.EncodeBool(bool(x.EscapedComputedClass))
 67882  				}
 67883  			}
 67884  			if yyr2 || yy2arr2 {
 67885  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67886  				yym71 := z.EncBinary()
 67887  				_ = yym71
 67888  				if false {
 67889  				} else {
 67890  					r.EncodeBool(bool(x.AnnotatePlan))
 67891  				}
 67892  			} else {
 67893  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67894  				r.EncodeString(codecSelferC_UTF8100, string("AnnotatePlan"))
 67895  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67896  				yym72 := z.EncBinary()
 67897  				_ = yym72
 67898  				if false {
 67899  				} else {
 67900  					r.EncodeBool(bool(x.AnnotatePlan))
 67901  				}
 67902  			}
 67903  			if yyr2 || yy2arr2 {
 67904  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67905  				if x.QueuedAllocations == nil {
 67906  					r.EncodeNil()
 67907  				} else {
 67908  					yym74 := z.EncBinary()
 67909  					_ = yym74
 67910  					if false {
 67911  					} else {
 67912  						z.F.EncMapStringIntV(x.QueuedAllocations, false, e)
 67913  					}
 67914  				}
 67915  			} else {
 67916  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67917  				r.EncodeString(codecSelferC_UTF8100, string("QueuedAllocations"))
 67918  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67919  				if x.QueuedAllocations == nil {
 67920  					r.EncodeNil()
 67921  				} else {
 67922  					yym75 := z.EncBinary()
 67923  					_ = yym75
 67924  					if false {
 67925  					} else {
 67926  						z.F.EncMapStringIntV(x.QueuedAllocations, false, e)
 67927  					}
 67928  				}
 67929  			}
 67930  			if yyr2 || yy2arr2 {
 67931  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67932  				yym77 := z.EncBinary()
 67933  				_ = yym77
 67934  				if false {
 67935  				} else {
 67936  					r.EncodeString(codecSelferC_UTF8100, string(x.LeaderACL))
 67937  				}
 67938  			} else {
 67939  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67940  				r.EncodeString(codecSelferC_UTF8100, string("LeaderACL"))
 67941  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67942  				yym78 := z.EncBinary()
 67943  				_ = yym78
 67944  				if false {
 67945  				} else {
 67946  					r.EncodeString(codecSelferC_UTF8100, string(x.LeaderACL))
 67947  				}
 67948  			}
 67949  			if yyr2 || yy2arr2 {
 67950  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67951  				yym80 := z.EncBinary()
 67952  				_ = yym80
 67953  				if false {
 67954  				} else {
 67955  					r.EncodeUint(uint64(x.SnapshotIndex))
 67956  				}
 67957  			} else {
 67958  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67959  				r.EncodeString(codecSelferC_UTF8100, string("SnapshotIndex"))
 67960  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67961  				yym81 := z.EncBinary()
 67962  				_ = yym81
 67963  				if false {
 67964  				} else {
 67965  					r.EncodeUint(uint64(x.SnapshotIndex))
 67966  				}
 67967  			}
 67968  			if yyr2 || yy2arr2 {
 67969  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67970  				yym83 := z.EncBinary()
 67971  				_ = yym83
 67972  				if false {
 67973  				} else {
 67974  					r.EncodeUint(uint64(x.CreateIndex))
 67975  				}
 67976  			} else {
 67977  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67978  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 67979  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67980  				yym84 := z.EncBinary()
 67981  				_ = yym84
 67982  				if false {
 67983  				} else {
 67984  					r.EncodeUint(uint64(x.CreateIndex))
 67985  				}
 67986  			}
 67987  			if yyr2 || yy2arr2 {
 67988  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 67989  				yym86 := z.EncBinary()
 67990  				_ = yym86
 67991  				if false {
 67992  				} else {
 67993  					r.EncodeUint(uint64(x.ModifyIndex))
 67994  				}
 67995  			} else {
 67996  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 67997  				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
 67998  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 67999  				yym87 := z.EncBinary()
 68000  				_ = yym87
 68001  				if false {
 68002  				} else {
 68003  					r.EncodeUint(uint64(x.ModifyIndex))
 68004  				}
 68005  			}
 68006  			if yyr2 || yy2arr2 {
 68007  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 68008  			} else {
 68009  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 68010  			}
 68011  		}
 68012  	}
 68013  }
 68014  
 68015  func (x *Evaluation) CodecDecodeSelf(d *codec1978.Decoder) {
 68016  	var h codecSelfer100
 68017  	z, r := codec1978.GenHelperDecoder(d)
 68018  	_, _, _ = h, z, r
 68019  	yym1 := z.DecBinary()
 68020  	_ = yym1
 68021  	if false {
 68022  	} else if z.HasExtensions() && z.DecExt(x) {
 68023  	} else {
 68024  		yyct2 := r.ContainerType()
 68025  		if yyct2 == codecSelferValueTypeMap100 {
 68026  			yyl2 := r.ReadMapStart()
 68027  			if yyl2 == 0 {
 68028  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 68029  			} else {
 68030  				x.codecDecodeSelfFromMap(yyl2, d)
 68031  			}
 68032  		} else if yyct2 == codecSelferValueTypeArray100 {
 68033  			yyl2 := r.ReadArrayStart()
 68034  			if yyl2 == 0 {
 68035  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68036  			} else {
 68037  				x.codecDecodeSelfFromArray(yyl2, d)
 68038  			}
 68039  		} else {
 68040  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 68041  		}
 68042  	}
 68043  }
 68044  
 68045  func (x *Evaluation) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 68046  	var h codecSelfer100
 68047  	z, r := codec1978.GenHelperDecoder(d)
 68048  	_, _, _ = h, z, r
 68049  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 68050  	_ = yys3Slc
 68051  	var yyhl3 bool = l >= 0
 68052  	for yyj3 := 0; ; yyj3++ {
 68053  		if yyhl3 {
 68054  			if yyj3 >= l {
 68055  				break
 68056  			}
 68057  		} else {
 68058  			if r.CheckBreak() {
 68059  				break
 68060  			}
 68061  		}
 68062  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 68063  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 68064  		yys3 := string(yys3Slc)
 68065  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 68066  		switch yys3 {
 68067  		case "ID":
 68068  			if r.TryDecodeAsNil() {
 68069  				x.ID = ""
 68070  			} else {
 68071  				yyv4 := &x.ID
 68072  				yym5 := z.DecBinary()
 68073  				_ = yym5
 68074  				if false {
 68075  				} else {
 68076  					*((*string)(yyv4)) = r.DecodeString()
 68077  				}
 68078  			}
 68079  		case "Namespace":
 68080  			if r.TryDecodeAsNil() {
 68081  				x.Namespace = ""
 68082  			} else {
 68083  				yyv6 := &x.Namespace
 68084  				yym7 := z.DecBinary()
 68085  				_ = yym7
 68086  				if false {
 68087  				} else {
 68088  					*((*string)(yyv6)) = r.DecodeString()
 68089  				}
 68090  			}
 68091  		case "Priority":
 68092  			if r.TryDecodeAsNil() {
 68093  				x.Priority = 0
 68094  			} else {
 68095  				yyv8 := &x.Priority
 68096  				yym9 := z.DecBinary()
 68097  				_ = yym9
 68098  				if false {
 68099  				} else {
 68100  					*((*int)(yyv8)) = int(r.DecodeInt(codecSelferBitsize100))
 68101  				}
 68102  			}
 68103  		case "Type":
 68104  			if r.TryDecodeAsNil() {
 68105  				x.Type = ""
 68106  			} else {
 68107  				yyv10 := &x.Type
 68108  				yym11 := z.DecBinary()
 68109  				_ = yym11
 68110  				if false {
 68111  				} else {
 68112  					*((*string)(yyv10)) = r.DecodeString()
 68113  				}
 68114  			}
 68115  		case "TriggeredBy":
 68116  			if r.TryDecodeAsNil() {
 68117  				x.TriggeredBy = ""
 68118  			} else {
 68119  				yyv12 := &x.TriggeredBy
 68120  				yym13 := z.DecBinary()
 68121  				_ = yym13
 68122  				if false {
 68123  				} else {
 68124  					*((*string)(yyv12)) = r.DecodeString()
 68125  				}
 68126  			}
 68127  		case "JobID":
 68128  			if r.TryDecodeAsNil() {
 68129  				x.JobID = ""
 68130  			} else {
 68131  				yyv14 := &x.JobID
 68132  				yym15 := z.DecBinary()
 68133  				_ = yym15
 68134  				if false {
 68135  				} else {
 68136  					*((*string)(yyv14)) = r.DecodeString()
 68137  				}
 68138  			}
 68139  		case "JobModifyIndex":
 68140  			if r.TryDecodeAsNil() {
 68141  				x.JobModifyIndex = 0
 68142  			} else {
 68143  				yyv16 := &x.JobModifyIndex
 68144  				yym17 := z.DecBinary()
 68145  				_ = yym17
 68146  				if false {
 68147  				} else {
 68148  					*((*uint64)(yyv16)) = uint64(r.DecodeUint(64))
 68149  				}
 68150  			}
 68151  		case "NodeID":
 68152  			if r.TryDecodeAsNil() {
 68153  				x.NodeID = ""
 68154  			} else {
 68155  				yyv18 := &x.NodeID
 68156  				yym19 := z.DecBinary()
 68157  				_ = yym19
 68158  				if false {
 68159  				} else {
 68160  					*((*string)(yyv18)) = r.DecodeString()
 68161  				}
 68162  			}
 68163  		case "NodeModifyIndex":
 68164  			if r.TryDecodeAsNil() {
 68165  				x.NodeModifyIndex = 0
 68166  			} else {
 68167  				yyv20 := &x.NodeModifyIndex
 68168  				yym21 := z.DecBinary()
 68169  				_ = yym21
 68170  				if false {
 68171  				} else {
 68172  					*((*uint64)(yyv20)) = uint64(r.DecodeUint(64))
 68173  				}
 68174  			}
 68175  		case "DeploymentID":
 68176  			if r.TryDecodeAsNil() {
 68177  				x.DeploymentID = ""
 68178  			} else {
 68179  				yyv22 := &x.DeploymentID
 68180  				yym23 := z.DecBinary()
 68181  				_ = yym23
 68182  				if false {
 68183  				} else {
 68184  					*((*string)(yyv22)) = r.DecodeString()
 68185  				}
 68186  			}
 68187  		case "Status":
 68188  			if r.TryDecodeAsNil() {
 68189  				x.Status = ""
 68190  			} else {
 68191  				yyv24 := &x.Status
 68192  				yym25 := z.DecBinary()
 68193  				_ = yym25
 68194  				if false {
 68195  				} else {
 68196  					*((*string)(yyv24)) = r.DecodeString()
 68197  				}
 68198  			}
 68199  		case "StatusDescription":
 68200  			if r.TryDecodeAsNil() {
 68201  				x.StatusDescription = ""
 68202  			} else {
 68203  				yyv26 := &x.StatusDescription
 68204  				yym27 := z.DecBinary()
 68205  				_ = yym27
 68206  				if false {
 68207  				} else {
 68208  					*((*string)(yyv26)) = r.DecodeString()
 68209  				}
 68210  			}
 68211  		case "Wait":
 68212  			if r.TryDecodeAsNil() {
 68213  				x.Wait = 0
 68214  			} else {
 68215  				yyv28 := &x.Wait
 68216  				yym29 := z.DecBinary()
 68217  				_ = yym29
 68218  				if false {
 68219  				} else if z.HasExtensions() && z.DecExt(yyv28) {
 68220  				} else {
 68221  					*((*int64)(yyv28)) = int64(r.DecodeInt(64))
 68222  				}
 68223  			}
 68224  		case "WaitUntil":
 68225  			if r.TryDecodeAsNil() {
 68226  				x.WaitUntil = time.Time{}
 68227  			} else {
 68228  				yyv30 := &x.WaitUntil
 68229  				yym31 := z.DecBinary()
 68230  				_ = yym31
 68231  				if false {
 68232  				} else if yym32 := z.TimeRtidIfBinc(); yym32 != 0 {
 68233  					r.DecodeBuiltin(yym32, yyv30)
 68234  				} else if z.HasExtensions() && z.DecExt(yyv30) {
 68235  				} else if yym31 {
 68236  					z.DecBinaryUnmarshal(yyv30)
 68237  				} else if !yym31 && z.IsJSONHandle() {
 68238  					z.DecJSONUnmarshal(yyv30)
 68239  				} else {
 68240  					z.DecFallback(yyv30, false)
 68241  				}
 68242  			}
 68243  		case "NextEval":
 68244  			if r.TryDecodeAsNil() {
 68245  				x.NextEval = ""
 68246  			} else {
 68247  				yyv33 := &x.NextEval
 68248  				yym34 := z.DecBinary()
 68249  				_ = yym34
 68250  				if false {
 68251  				} else {
 68252  					*((*string)(yyv33)) = r.DecodeString()
 68253  				}
 68254  			}
 68255  		case "PreviousEval":
 68256  			if r.TryDecodeAsNil() {
 68257  				x.PreviousEval = ""
 68258  			} else {
 68259  				yyv35 := &x.PreviousEval
 68260  				yym36 := z.DecBinary()
 68261  				_ = yym36
 68262  				if false {
 68263  				} else {
 68264  					*((*string)(yyv35)) = r.DecodeString()
 68265  				}
 68266  			}
 68267  		case "BlockedEval":
 68268  			if r.TryDecodeAsNil() {
 68269  				x.BlockedEval = ""
 68270  			} else {
 68271  				yyv37 := &x.BlockedEval
 68272  				yym38 := z.DecBinary()
 68273  				_ = yym38
 68274  				if false {
 68275  				} else {
 68276  					*((*string)(yyv37)) = r.DecodeString()
 68277  				}
 68278  			}
 68279  		case "FailedTGAllocs":
 68280  			if r.TryDecodeAsNil() {
 68281  				x.FailedTGAllocs = nil
 68282  			} else {
 68283  				yyv39 := &x.FailedTGAllocs
 68284  				yym40 := z.DecBinary()
 68285  				_ = yym40
 68286  				if false {
 68287  				} else {
 68288  					h.decMapstringPtrtoAllocMetric((*map[string]*AllocMetric)(yyv39), d)
 68289  				}
 68290  			}
 68291  		case "ClassEligibility":
 68292  			if r.TryDecodeAsNil() {
 68293  				x.ClassEligibility = nil
 68294  			} else {
 68295  				yyv41 := &x.ClassEligibility
 68296  				yym42 := z.DecBinary()
 68297  				_ = yym42
 68298  				if false {
 68299  				} else {
 68300  					z.F.DecMapStringBoolX(yyv41, false, d)
 68301  				}
 68302  			}
 68303  		case "QuotaLimitReached":
 68304  			if r.TryDecodeAsNil() {
 68305  				x.QuotaLimitReached = ""
 68306  			} else {
 68307  				yyv43 := &x.QuotaLimitReached
 68308  				yym44 := z.DecBinary()
 68309  				_ = yym44
 68310  				if false {
 68311  				} else {
 68312  					*((*string)(yyv43)) = r.DecodeString()
 68313  				}
 68314  			}
 68315  		case "EscapedComputedClass":
 68316  			if r.TryDecodeAsNil() {
 68317  				x.EscapedComputedClass = false
 68318  			} else {
 68319  				yyv45 := &x.EscapedComputedClass
 68320  				yym46 := z.DecBinary()
 68321  				_ = yym46
 68322  				if false {
 68323  				} else {
 68324  					*((*bool)(yyv45)) = r.DecodeBool()
 68325  				}
 68326  			}
 68327  		case "AnnotatePlan":
 68328  			if r.TryDecodeAsNil() {
 68329  				x.AnnotatePlan = false
 68330  			} else {
 68331  				yyv47 := &x.AnnotatePlan
 68332  				yym48 := z.DecBinary()
 68333  				_ = yym48
 68334  				if false {
 68335  				} else {
 68336  					*((*bool)(yyv47)) = r.DecodeBool()
 68337  				}
 68338  			}
 68339  		case "QueuedAllocations":
 68340  			if r.TryDecodeAsNil() {
 68341  				x.QueuedAllocations = nil
 68342  			} else {
 68343  				yyv49 := &x.QueuedAllocations
 68344  				yym50 := z.DecBinary()
 68345  				_ = yym50
 68346  				if false {
 68347  				} else {
 68348  					z.F.DecMapStringIntX(yyv49, false, d)
 68349  				}
 68350  			}
 68351  		case "LeaderACL":
 68352  			if r.TryDecodeAsNil() {
 68353  				x.LeaderACL = ""
 68354  			} else {
 68355  				yyv51 := &x.LeaderACL
 68356  				yym52 := z.DecBinary()
 68357  				_ = yym52
 68358  				if false {
 68359  				} else {
 68360  					*((*string)(yyv51)) = r.DecodeString()
 68361  				}
 68362  			}
 68363  		case "SnapshotIndex":
 68364  			if r.TryDecodeAsNil() {
 68365  				x.SnapshotIndex = 0
 68366  			} else {
 68367  				yyv53 := &x.SnapshotIndex
 68368  				yym54 := z.DecBinary()
 68369  				_ = yym54
 68370  				if false {
 68371  				} else {
 68372  					*((*uint64)(yyv53)) = uint64(r.DecodeUint(64))
 68373  				}
 68374  			}
 68375  		case "CreateIndex":
 68376  			if r.TryDecodeAsNil() {
 68377  				x.CreateIndex = 0
 68378  			} else {
 68379  				yyv55 := &x.CreateIndex
 68380  				yym56 := z.DecBinary()
 68381  				_ = yym56
 68382  				if false {
 68383  				} else {
 68384  					*((*uint64)(yyv55)) = uint64(r.DecodeUint(64))
 68385  				}
 68386  			}
 68387  		case "ModifyIndex":
 68388  			if r.TryDecodeAsNil() {
 68389  				x.ModifyIndex = 0
 68390  			} else {
 68391  				yyv57 := &x.ModifyIndex
 68392  				yym58 := z.DecBinary()
 68393  				_ = yym58
 68394  				if false {
 68395  				} else {
 68396  					*((*uint64)(yyv57)) = uint64(r.DecodeUint(64))
 68397  				}
 68398  			}
 68399  		default:
 68400  			z.DecStructFieldNotFound(-1, yys3)
 68401  		} // end switch yys3
 68402  	} // end for yyj3
 68403  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 68404  }
 68405  
 68406  func (x *Evaluation) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 68407  	var h codecSelfer100
 68408  	z, r := codec1978.GenHelperDecoder(d)
 68409  	_, _, _ = h, z, r
 68410  	var yyj59 int
 68411  	var yyb59 bool
 68412  	var yyhl59 bool = l >= 0
 68413  	yyj59++
 68414  	if yyhl59 {
 68415  		yyb59 = yyj59 > l
 68416  	} else {
 68417  		yyb59 = r.CheckBreak()
 68418  	}
 68419  	if yyb59 {
 68420  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68421  		return
 68422  	}
 68423  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68424  	if r.TryDecodeAsNil() {
 68425  		x.ID = ""
 68426  	} else {
 68427  		yyv60 := &x.ID
 68428  		yym61 := z.DecBinary()
 68429  		_ = yym61
 68430  		if false {
 68431  		} else {
 68432  			*((*string)(yyv60)) = r.DecodeString()
 68433  		}
 68434  	}
 68435  	yyj59++
 68436  	if yyhl59 {
 68437  		yyb59 = yyj59 > l
 68438  	} else {
 68439  		yyb59 = r.CheckBreak()
 68440  	}
 68441  	if yyb59 {
 68442  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68443  		return
 68444  	}
 68445  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68446  	if r.TryDecodeAsNil() {
 68447  		x.Namespace = ""
 68448  	} else {
 68449  		yyv62 := &x.Namespace
 68450  		yym63 := z.DecBinary()
 68451  		_ = yym63
 68452  		if false {
 68453  		} else {
 68454  			*((*string)(yyv62)) = r.DecodeString()
 68455  		}
 68456  	}
 68457  	yyj59++
 68458  	if yyhl59 {
 68459  		yyb59 = yyj59 > l
 68460  	} else {
 68461  		yyb59 = r.CheckBreak()
 68462  	}
 68463  	if yyb59 {
 68464  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68465  		return
 68466  	}
 68467  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68468  	if r.TryDecodeAsNil() {
 68469  		x.Priority = 0
 68470  	} else {
 68471  		yyv64 := &x.Priority
 68472  		yym65 := z.DecBinary()
 68473  		_ = yym65
 68474  		if false {
 68475  		} else {
 68476  			*((*int)(yyv64)) = int(r.DecodeInt(codecSelferBitsize100))
 68477  		}
 68478  	}
 68479  	yyj59++
 68480  	if yyhl59 {
 68481  		yyb59 = yyj59 > l
 68482  	} else {
 68483  		yyb59 = r.CheckBreak()
 68484  	}
 68485  	if yyb59 {
 68486  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68487  		return
 68488  	}
 68489  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68490  	if r.TryDecodeAsNil() {
 68491  		x.Type = ""
 68492  	} else {
 68493  		yyv66 := &x.Type
 68494  		yym67 := z.DecBinary()
 68495  		_ = yym67
 68496  		if false {
 68497  		} else {
 68498  			*((*string)(yyv66)) = r.DecodeString()
 68499  		}
 68500  	}
 68501  	yyj59++
 68502  	if yyhl59 {
 68503  		yyb59 = yyj59 > l
 68504  	} else {
 68505  		yyb59 = r.CheckBreak()
 68506  	}
 68507  	if yyb59 {
 68508  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68509  		return
 68510  	}
 68511  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68512  	if r.TryDecodeAsNil() {
 68513  		x.TriggeredBy = ""
 68514  	} else {
 68515  		yyv68 := &x.TriggeredBy
 68516  		yym69 := z.DecBinary()
 68517  		_ = yym69
 68518  		if false {
 68519  		} else {
 68520  			*((*string)(yyv68)) = r.DecodeString()
 68521  		}
 68522  	}
 68523  	yyj59++
 68524  	if yyhl59 {
 68525  		yyb59 = yyj59 > l
 68526  	} else {
 68527  		yyb59 = r.CheckBreak()
 68528  	}
 68529  	if yyb59 {
 68530  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68531  		return
 68532  	}
 68533  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68534  	if r.TryDecodeAsNil() {
 68535  		x.JobID = ""
 68536  	} else {
 68537  		yyv70 := &x.JobID
 68538  		yym71 := z.DecBinary()
 68539  		_ = yym71
 68540  		if false {
 68541  		} else {
 68542  			*((*string)(yyv70)) = r.DecodeString()
 68543  		}
 68544  	}
 68545  	yyj59++
 68546  	if yyhl59 {
 68547  		yyb59 = yyj59 > l
 68548  	} else {
 68549  		yyb59 = r.CheckBreak()
 68550  	}
 68551  	if yyb59 {
 68552  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68553  		return
 68554  	}
 68555  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68556  	if r.TryDecodeAsNil() {
 68557  		x.JobModifyIndex = 0
 68558  	} else {
 68559  		yyv72 := &x.JobModifyIndex
 68560  		yym73 := z.DecBinary()
 68561  		_ = yym73
 68562  		if false {
 68563  		} else {
 68564  			*((*uint64)(yyv72)) = uint64(r.DecodeUint(64))
 68565  		}
 68566  	}
 68567  	yyj59++
 68568  	if yyhl59 {
 68569  		yyb59 = yyj59 > l
 68570  	} else {
 68571  		yyb59 = r.CheckBreak()
 68572  	}
 68573  	if yyb59 {
 68574  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68575  		return
 68576  	}
 68577  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68578  	if r.TryDecodeAsNil() {
 68579  		x.NodeID = ""
 68580  	} else {
 68581  		yyv74 := &x.NodeID
 68582  		yym75 := z.DecBinary()
 68583  		_ = yym75
 68584  		if false {
 68585  		} else {
 68586  			*((*string)(yyv74)) = r.DecodeString()
 68587  		}
 68588  	}
 68589  	yyj59++
 68590  	if yyhl59 {
 68591  		yyb59 = yyj59 > l
 68592  	} else {
 68593  		yyb59 = r.CheckBreak()
 68594  	}
 68595  	if yyb59 {
 68596  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68597  		return
 68598  	}
 68599  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68600  	if r.TryDecodeAsNil() {
 68601  		x.NodeModifyIndex = 0
 68602  	} else {
 68603  		yyv76 := &x.NodeModifyIndex
 68604  		yym77 := z.DecBinary()
 68605  		_ = yym77
 68606  		if false {
 68607  		} else {
 68608  			*((*uint64)(yyv76)) = uint64(r.DecodeUint(64))
 68609  		}
 68610  	}
 68611  	yyj59++
 68612  	if yyhl59 {
 68613  		yyb59 = yyj59 > l
 68614  	} else {
 68615  		yyb59 = r.CheckBreak()
 68616  	}
 68617  	if yyb59 {
 68618  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68619  		return
 68620  	}
 68621  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68622  	if r.TryDecodeAsNil() {
 68623  		x.DeploymentID = ""
 68624  	} else {
 68625  		yyv78 := &x.DeploymentID
 68626  		yym79 := z.DecBinary()
 68627  		_ = yym79
 68628  		if false {
 68629  		} else {
 68630  			*((*string)(yyv78)) = r.DecodeString()
 68631  		}
 68632  	}
 68633  	yyj59++
 68634  	if yyhl59 {
 68635  		yyb59 = yyj59 > l
 68636  	} else {
 68637  		yyb59 = r.CheckBreak()
 68638  	}
 68639  	if yyb59 {
 68640  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68641  		return
 68642  	}
 68643  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68644  	if r.TryDecodeAsNil() {
 68645  		x.Status = ""
 68646  	} else {
 68647  		yyv80 := &x.Status
 68648  		yym81 := z.DecBinary()
 68649  		_ = yym81
 68650  		if false {
 68651  		} else {
 68652  			*((*string)(yyv80)) = r.DecodeString()
 68653  		}
 68654  	}
 68655  	yyj59++
 68656  	if yyhl59 {
 68657  		yyb59 = yyj59 > l
 68658  	} else {
 68659  		yyb59 = r.CheckBreak()
 68660  	}
 68661  	if yyb59 {
 68662  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68663  		return
 68664  	}
 68665  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68666  	if r.TryDecodeAsNil() {
 68667  		x.StatusDescription = ""
 68668  	} else {
 68669  		yyv82 := &x.StatusDescription
 68670  		yym83 := z.DecBinary()
 68671  		_ = yym83
 68672  		if false {
 68673  		} else {
 68674  			*((*string)(yyv82)) = r.DecodeString()
 68675  		}
 68676  	}
 68677  	yyj59++
 68678  	if yyhl59 {
 68679  		yyb59 = yyj59 > l
 68680  	} else {
 68681  		yyb59 = r.CheckBreak()
 68682  	}
 68683  	if yyb59 {
 68684  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68685  		return
 68686  	}
 68687  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68688  	if r.TryDecodeAsNil() {
 68689  		x.Wait = 0
 68690  	} else {
 68691  		yyv84 := &x.Wait
 68692  		yym85 := z.DecBinary()
 68693  		_ = yym85
 68694  		if false {
 68695  		} else if z.HasExtensions() && z.DecExt(yyv84) {
 68696  		} else {
 68697  			*((*int64)(yyv84)) = int64(r.DecodeInt(64))
 68698  		}
 68699  	}
 68700  	yyj59++
 68701  	if yyhl59 {
 68702  		yyb59 = yyj59 > l
 68703  	} else {
 68704  		yyb59 = r.CheckBreak()
 68705  	}
 68706  	if yyb59 {
 68707  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68708  		return
 68709  	}
 68710  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68711  	if r.TryDecodeAsNil() {
 68712  		x.WaitUntil = time.Time{}
 68713  	} else {
 68714  		yyv86 := &x.WaitUntil
 68715  		yym87 := z.DecBinary()
 68716  		_ = yym87
 68717  		if false {
 68718  		} else if yym88 := z.TimeRtidIfBinc(); yym88 != 0 {
 68719  			r.DecodeBuiltin(yym88, yyv86)
 68720  		} else if z.HasExtensions() && z.DecExt(yyv86) {
 68721  		} else if yym87 {
 68722  			z.DecBinaryUnmarshal(yyv86)
 68723  		} else if !yym87 && z.IsJSONHandle() {
 68724  			z.DecJSONUnmarshal(yyv86)
 68725  		} else {
 68726  			z.DecFallback(yyv86, false)
 68727  		}
 68728  	}
 68729  	yyj59++
 68730  	if yyhl59 {
 68731  		yyb59 = yyj59 > l
 68732  	} else {
 68733  		yyb59 = r.CheckBreak()
 68734  	}
 68735  	if yyb59 {
 68736  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68737  		return
 68738  	}
 68739  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68740  	if r.TryDecodeAsNil() {
 68741  		x.NextEval = ""
 68742  	} else {
 68743  		yyv89 := &x.NextEval
 68744  		yym90 := z.DecBinary()
 68745  		_ = yym90
 68746  		if false {
 68747  		} else {
 68748  			*((*string)(yyv89)) = r.DecodeString()
 68749  		}
 68750  	}
 68751  	yyj59++
 68752  	if yyhl59 {
 68753  		yyb59 = yyj59 > l
 68754  	} else {
 68755  		yyb59 = r.CheckBreak()
 68756  	}
 68757  	if yyb59 {
 68758  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68759  		return
 68760  	}
 68761  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68762  	if r.TryDecodeAsNil() {
 68763  		x.PreviousEval = ""
 68764  	} else {
 68765  		yyv91 := &x.PreviousEval
 68766  		yym92 := z.DecBinary()
 68767  		_ = yym92
 68768  		if false {
 68769  		} else {
 68770  			*((*string)(yyv91)) = r.DecodeString()
 68771  		}
 68772  	}
 68773  	yyj59++
 68774  	if yyhl59 {
 68775  		yyb59 = yyj59 > l
 68776  	} else {
 68777  		yyb59 = r.CheckBreak()
 68778  	}
 68779  	if yyb59 {
 68780  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68781  		return
 68782  	}
 68783  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68784  	if r.TryDecodeAsNil() {
 68785  		x.BlockedEval = ""
 68786  	} else {
 68787  		yyv93 := &x.BlockedEval
 68788  		yym94 := z.DecBinary()
 68789  		_ = yym94
 68790  		if false {
 68791  		} else {
 68792  			*((*string)(yyv93)) = r.DecodeString()
 68793  		}
 68794  	}
 68795  	yyj59++
 68796  	if yyhl59 {
 68797  		yyb59 = yyj59 > l
 68798  	} else {
 68799  		yyb59 = r.CheckBreak()
 68800  	}
 68801  	if yyb59 {
 68802  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68803  		return
 68804  	}
 68805  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68806  	if r.TryDecodeAsNil() {
 68807  		x.FailedTGAllocs = nil
 68808  	} else {
 68809  		yyv95 := &x.FailedTGAllocs
 68810  		yym96 := z.DecBinary()
 68811  		_ = yym96
 68812  		if false {
 68813  		} else {
 68814  			h.decMapstringPtrtoAllocMetric((*map[string]*AllocMetric)(yyv95), d)
 68815  		}
 68816  	}
 68817  	yyj59++
 68818  	if yyhl59 {
 68819  		yyb59 = yyj59 > l
 68820  	} else {
 68821  		yyb59 = r.CheckBreak()
 68822  	}
 68823  	if yyb59 {
 68824  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68825  		return
 68826  	}
 68827  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68828  	if r.TryDecodeAsNil() {
 68829  		x.ClassEligibility = nil
 68830  	} else {
 68831  		yyv97 := &x.ClassEligibility
 68832  		yym98 := z.DecBinary()
 68833  		_ = yym98
 68834  		if false {
 68835  		} else {
 68836  			z.F.DecMapStringBoolX(yyv97, false, d)
 68837  		}
 68838  	}
 68839  	yyj59++
 68840  	if yyhl59 {
 68841  		yyb59 = yyj59 > l
 68842  	} else {
 68843  		yyb59 = r.CheckBreak()
 68844  	}
 68845  	if yyb59 {
 68846  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68847  		return
 68848  	}
 68849  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68850  	if r.TryDecodeAsNil() {
 68851  		x.QuotaLimitReached = ""
 68852  	} else {
 68853  		yyv99 := &x.QuotaLimitReached
 68854  		yym100 := z.DecBinary()
 68855  		_ = yym100
 68856  		if false {
 68857  		} else {
 68858  			*((*string)(yyv99)) = r.DecodeString()
 68859  		}
 68860  	}
 68861  	yyj59++
 68862  	if yyhl59 {
 68863  		yyb59 = yyj59 > l
 68864  	} else {
 68865  		yyb59 = r.CheckBreak()
 68866  	}
 68867  	if yyb59 {
 68868  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68869  		return
 68870  	}
 68871  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68872  	if r.TryDecodeAsNil() {
 68873  		x.EscapedComputedClass = false
 68874  	} else {
 68875  		yyv101 := &x.EscapedComputedClass
 68876  		yym102 := z.DecBinary()
 68877  		_ = yym102
 68878  		if false {
 68879  		} else {
 68880  			*((*bool)(yyv101)) = r.DecodeBool()
 68881  		}
 68882  	}
 68883  	yyj59++
 68884  	if yyhl59 {
 68885  		yyb59 = yyj59 > l
 68886  	} else {
 68887  		yyb59 = r.CheckBreak()
 68888  	}
 68889  	if yyb59 {
 68890  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68891  		return
 68892  	}
 68893  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68894  	if r.TryDecodeAsNil() {
 68895  		x.AnnotatePlan = false
 68896  	} else {
 68897  		yyv103 := &x.AnnotatePlan
 68898  		yym104 := z.DecBinary()
 68899  		_ = yym104
 68900  		if false {
 68901  		} else {
 68902  			*((*bool)(yyv103)) = r.DecodeBool()
 68903  		}
 68904  	}
 68905  	yyj59++
 68906  	if yyhl59 {
 68907  		yyb59 = yyj59 > l
 68908  	} else {
 68909  		yyb59 = r.CheckBreak()
 68910  	}
 68911  	if yyb59 {
 68912  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68913  		return
 68914  	}
 68915  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68916  	if r.TryDecodeAsNil() {
 68917  		x.QueuedAllocations = nil
 68918  	} else {
 68919  		yyv105 := &x.QueuedAllocations
 68920  		yym106 := z.DecBinary()
 68921  		_ = yym106
 68922  		if false {
 68923  		} else {
 68924  			z.F.DecMapStringIntX(yyv105, false, d)
 68925  		}
 68926  	}
 68927  	yyj59++
 68928  	if yyhl59 {
 68929  		yyb59 = yyj59 > l
 68930  	} else {
 68931  		yyb59 = r.CheckBreak()
 68932  	}
 68933  	if yyb59 {
 68934  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68935  		return
 68936  	}
 68937  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68938  	if r.TryDecodeAsNil() {
 68939  		x.LeaderACL = ""
 68940  	} else {
 68941  		yyv107 := &x.LeaderACL
 68942  		yym108 := z.DecBinary()
 68943  		_ = yym108
 68944  		if false {
 68945  		} else {
 68946  			*((*string)(yyv107)) = r.DecodeString()
 68947  		}
 68948  	}
 68949  	yyj59++
 68950  	if yyhl59 {
 68951  		yyb59 = yyj59 > l
 68952  	} else {
 68953  		yyb59 = r.CheckBreak()
 68954  	}
 68955  	if yyb59 {
 68956  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68957  		return
 68958  	}
 68959  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68960  	if r.TryDecodeAsNil() {
 68961  		x.SnapshotIndex = 0
 68962  	} else {
 68963  		yyv109 := &x.SnapshotIndex
 68964  		yym110 := z.DecBinary()
 68965  		_ = yym110
 68966  		if false {
 68967  		} else {
 68968  			*((*uint64)(yyv109)) = uint64(r.DecodeUint(64))
 68969  		}
 68970  	}
 68971  	yyj59++
 68972  	if yyhl59 {
 68973  		yyb59 = yyj59 > l
 68974  	} else {
 68975  		yyb59 = r.CheckBreak()
 68976  	}
 68977  	if yyb59 {
 68978  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 68979  		return
 68980  	}
 68981  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 68982  	if r.TryDecodeAsNil() {
 68983  		x.CreateIndex = 0
 68984  	} else {
 68985  		yyv111 := &x.CreateIndex
 68986  		yym112 := z.DecBinary()
 68987  		_ = yym112
 68988  		if false {
 68989  		} else {
 68990  			*((*uint64)(yyv111)) = uint64(r.DecodeUint(64))
 68991  		}
 68992  	}
 68993  	yyj59++
 68994  	if yyhl59 {
 68995  		yyb59 = yyj59 > l
 68996  	} else {
 68997  		yyb59 = r.CheckBreak()
 68998  	}
 68999  	if yyb59 {
 69000  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 69001  		return
 69002  	}
 69003  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 69004  	if r.TryDecodeAsNil() {
 69005  		x.ModifyIndex = 0
 69006  	} else {
 69007  		yyv113 := &x.ModifyIndex
 69008  		yym114 := z.DecBinary()
 69009  		_ = yym114
 69010  		if false {
 69011  		} else {
 69012  			*((*uint64)(yyv113)) = uint64(r.DecodeUint(64))
 69013  		}
 69014  	}
 69015  	for {
 69016  		yyj59++
 69017  		if yyhl59 {
 69018  			yyb59 = yyj59 > l
 69019  		} else {
 69020  			yyb59 = r.CheckBreak()
 69021  		}
 69022  		if yyb59 {
 69023  			break
 69024  		}
 69025  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 69026  		z.DecStructFieldNotFound(yyj59-1, "")
 69027  	}
 69028  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 69029  }
 69030  
 69031  func (x *Plan) CodecEncodeSelf(e *codec1978.Encoder) {
 69032  	var h codecSelfer100
 69033  	z, r := codec1978.GenHelperEncoder(e)
 69034  	_, _, _ = h, z, r
 69035  	if x == nil {
 69036  		r.EncodeNil()
 69037  	} else {
 69038  		yym1 := z.EncBinary()
 69039  		_ = yym1
 69040  		if false {
 69041  		} else if z.HasExtensions() && z.EncExt(x) {
 69042  		} else {
 69043  			yysep2 := !z.EncBinary()
 69044  			yy2arr2 := z.EncBasicHandle().StructToArray
 69045  			var yyq2 [10]bool
 69046  			_, _, _ = yysep2, yyq2, yy2arr2
 69047  			const yyr2 bool = false
 69048  			var yynn2 int
 69049  			if yyr2 || yy2arr2 {
 69050  				r.EncodeArrayStart(10)
 69051  			} else {
 69052  				yynn2 = 10
 69053  				for _, b := range yyq2 {
 69054  					if b {
 69055  						yynn2++
 69056  					}
 69057  				}
 69058  				r.EncodeMapStart(yynn2)
 69059  				yynn2 = 0
 69060  			}
 69061  			if yyr2 || yy2arr2 {
 69062  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69063  				yym4 := z.EncBinary()
 69064  				_ = yym4
 69065  				if false {
 69066  				} else {
 69067  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 69068  				}
 69069  			} else {
 69070  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69071  				r.EncodeString(codecSelferC_UTF8100, string("EvalID"))
 69072  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69073  				yym5 := z.EncBinary()
 69074  				_ = yym5
 69075  				if false {
 69076  				} else {
 69077  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalID))
 69078  				}
 69079  			}
 69080  			if yyr2 || yy2arr2 {
 69081  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69082  				yym7 := z.EncBinary()
 69083  				_ = yym7
 69084  				if false {
 69085  				} else {
 69086  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalToken))
 69087  				}
 69088  			} else {
 69089  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69090  				r.EncodeString(codecSelferC_UTF8100, string("EvalToken"))
 69091  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69092  				yym8 := z.EncBinary()
 69093  				_ = yym8
 69094  				if false {
 69095  				} else {
 69096  					r.EncodeString(codecSelferC_UTF8100, string(x.EvalToken))
 69097  				}
 69098  			}
 69099  			if yyr2 || yy2arr2 {
 69100  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69101  				yym10 := z.EncBinary()
 69102  				_ = yym10
 69103  				if false {
 69104  				} else {
 69105  					r.EncodeInt(int64(x.Priority))
 69106  				}
 69107  			} else {
 69108  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69109  				r.EncodeString(codecSelferC_UTF8100, string("Priority"))
 69110  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69111  				yym11 := z.EncBinary()
 69112  				_ = yym11
 69113  				if false {
 69114  				} else {
 69115  					r.EncodeInt(int64(x.Priority))
 69116  				}
 69117  			}
 69118  			if yyr2 || yy2arr2 {
 69119  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69120  				yym13 := z.EncBinary()
 69121  				_ = yym13
 69122  				if false {
 69123  				} else {
 69124  					r.EncodeBool(bool(x.AllAtOnce))
 69125  				}
 69126  			} else {
 69127  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69128  				r.EncodeString(codecSelferC_UTF8100, string("AllAtOnce"))
 69129  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69130  				yym14 := z.EncBinary()
 69131  				_ = yym14
 69132  				if false {
 69133  				} else {
 69134  					r.EncodeBool(bool(x.AllAtOnce))
 69135  				}
 69136  			}
 69137  			if yyr2 || yy2arr2 {
 69138  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69139  				if x.Job == nil {
 69140  					r.EncodeNil()
 69141  				} else {
 69142  					x.Job.CodecEncodeSelf(e)
 69143  				}
 69144  			} else {
 69145  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69146  				r.EncodeString(codecSelferC_UTF8100, string("Job"))
 69147  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69148  				if x.Job == nil {
 69149  					r.EncodeNil()
 69150  				} else {
 69151  					x.Job.CodecEncodeSelf(e)
 69152  				}
 69153  			}
 69154  			if yyr2 || yy2arr2 {
 69155  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69156  				if x.NodeUpdate == nil {
 69157  					r.EncodeNil()
 69158  				} else {
 69159  					yym19 := z.EncBinary()
 69160  					_ = yym19
 69161  					if false {
 69162  					} else {
 69163  						h.encMapstringSlicePtrtoAllocation((map[string][]*Allocation)(x.NodeUpdate), e)
 69164  					}
 69165  				}
 69166  			} else {
 69167  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69168  				r.EncodeString(codecSelferC_UTF8100, string("NodeUpdate"))
 69169  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69170  				if x.NodeUpdate == nil {
 69171  					r.EncodeNil()
 69172  				} else {
 69173  					yym20 := z.EncBinary()
 69174  					_ = yym20
 69175  					if false {
 69176  					} else {
 69177  						h.encMapstringSlicePtrtoAllocation((map[string][]*Allocation)(x.NodeUpdate), e)
 69178  					}
 69179  				}
 69180  			}
 69181  			if yyr2 || yy2arr2 {
 69182  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69183  				if x.NodeAllocation == nil {
 69184  					r.EncodeNil()
 69185  				} else {
 69186  					yym22 := z.EncBinary()
 69187  					_ = yym22
 69188  					if false {
 69189  					} else {
 69190  						h.encMapstringSlicePtrtoAllocation((map[string][]*Allocation)(x.NodeAllocation), e)
 69191  					}
 69192  				}
 69193  			} else {
 69194  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69195  				r.EncodeString(codecSelferC_UTF8100, string("NodeAllocation"))
 69196  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69197  				if x.NodeAllocation == nil {
 69198  					r.EncodeNil()
 69199  				} else {
 69200  					yym23 := z.EncBinary()
 69201  					_ = yym23
 69202  					if false {
 69203  					} else {
 69204  						h.encMapstringSlicePtrtoAllocation((map[string][]*Allocation)(x.NodeAllocation), e)
 69205  					}
 69206  				}
 69207  			}
 69208  			if yyr2 || yy2arr2 {
 69209  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69210  				if x.Annotations == nil {
 69211  					r.EncodeNil()
 69212  				} else {
 69213  					x.Annotations.CodecEncodeSelf(e)
 69214  				}
 69215  			} else {
 69216  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69217  				r.EncodeString(codecSelferC_UTF8100, string("Annotations"))
 69218  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69219  				if x.Annotations == nil {
 69220  					r.EncodeNil()
 69221  				} else {
 69222  					x.Annotations.CodecEncodeSelf(e)
 69223  				}
 69224  			}
 69225  			if yyr2 || yy2arr2 {
 69226  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69227  				if x.Deployment == nil {
 69228  					r.EncodeNil()
 69229  				} else {
 69230  					x.Deployment.CodecEncodeSelf(e)
 69231  				}
 69232  			} else {
 69233  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69234  				r.EncodeString(codecSelferC_UTF8100, string("Deployment"))
 69235  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69236  				if x.Deployment == nil {
 69237  					r.EncodeNil()
 69238  				} else {
 69239  					x.Deployment.CodecEncodeSelf(e)
 69240  				}
 69241  			}
 69242  			if yyr2 || yy2arr2 {
 69243  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69244  				if x.DeploymentUpdates == nil {
 69245  					r.EncodeNil()
 69246  				} else {
 69247  					yym31 := z.EncBinary()
 69248  					_ = yym31
 69249  					if false {
 69250  					} else {
 69251  						h.encSlicePtrtoDeploymentStatusUpdate(([]*DeploymentStatusUpdate)(x.DeploymentUpdates), e)
 69252  					}
 69253  				}
 69254  			} else {
 69255  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69256  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentUpdates"))
 69257  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69258  				if x.DeploymentUpdates == nil {
 69259  					r.EncodeNil()
 69260  				} else {
 69261  					yym32 := z.EncBinary()
 69262  					_ = yym32
 69263  					if false {
 69264  					} else {
 69265  						h.encSlicePtrtoDeploymentStatusUpdate(([]*DeploymentStatusUpdate)(x.DeploymentUpdates), e)
 69266  					}
 69267  				}
 69268  			}
 69269  			if yyr2 || yy2arr2 {
 69270  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 69271  			} else {
 69272  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 69273  			}
 69274  		}
 69275  	}
 69276  }
 69277  
 69278  func (x *Plan) CodecDecodeSelf(d *codec1978.Decoder) {
 69279  	var h codecSelfer100
 69280  	z, r := codec1978.GenHelperDecoder(d)
 69281  	_, _, _ = h, z, r
 69282  	yym1 := z.DecBinary()
 69283  	_ = yym1
 69284  	if false {
 69285  	} else if z.HasExtensions() && z.DecExt(x) {
 69286  	} else {
 69287  		yyct2 := r.ContainerType()
 69288  		if yyct2 == codecSelferValueTypeMap100 {
 69289  			yyl2 := r.ReadMapStart()
 69290  			if yyl2 == 0 {
 69291  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 69292  			} else {
 69293  				x.codecDecodeSelfFromMap(yyl2, d)
 69294  			}
 69295  		} else if yyct2 == codecSelferValueTypeArray100 {
 69296  			yyl2 := r.ReadArrayStart()
 69297  			if yyl2 == 0 {
 69298  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 69299  			} else {
 69300  				x.codecDecodeSelfFromArray(yyl2, d)
 69301  			}
 69302  		} else {
 69303  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 69304  		}
 69305  	}
 69306  }
 69307  
 69308  func (x *Plan) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 69309  	var h codecSelfer100
 69310  	z, r := codec1978.GenHelperDecoder(d)
 69311  	_, _, _ = h, z, r
 69312  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 69313  	_ = yys3Slc
 69314  	var yyhl3 bool = l >= 0
 69315  	for yyj3 := 0; ; yyj3++ {
 69316  		if yyhl3 {
 69317  			if yyj3 >= l {
 69318  				break
 69319  			}
 69320  		} else {
 69321  			if r.CheckBreak() {
 69322  				break
 69323  			}
 69324  		}
 69325  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 69326  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 69327  		yys3 := string(yys3Slc)
 69328  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 69329  		switch yys3 {
 69330  		case "EvalID":
 69331  			if r.TryDecodeAsNil() {
 69332  				x.EvalID = ""
 69333  			} else {
 69334  				yyv4 := &x.EvalID
 69335  				yym5 := z.DecBinary()
 69336  				_ = yym5
 69337  				if false {
 69338  				} else {
 69339  					*((*string)(yyv4)) = r.DecodeString()
 69340  				}
 69341  			}
 69342  		case "EvalToken":
 69343  			if r.TryDecodeAsNil() {
 69344  				x.EvalToken = ""
 69345  			} else {
 69346  				yyv6 := &x.EvalToken
 69347  				yym7 := z.DecBinary()
 69348  				_ = yym7
 69349  				if false {
 69350  				} else {
 69351  					*((*string)(yyv6)) = r.DecodeString()
 69352  				}
 69353  			}
 69354  		case "Priority":
 69355  			if r.TryDecodeAsNil() {
 69356  				x.Priority = 0
 69357  			} else {
 69358  				yyv8 := &x.Priority
 69359  				yym9 := z.DecBinary()
 69360  				_ = yym9
 69361  				if false {
 69362  				} else {
 69363  					*((*int)(yyv8)) = int(r.DecodeInt(codecSelferBitsize100))
 69364  				}
 69365  			}
 69366  		case "AllAtOnce":
 69367  			if r.TryDecodeAsNil() {
 69368  				x.AllAtOnce = false
 69369  			} else {
 69370  				yyv10 := &x.AllAtOnce
 69371  				yym11 := z.DecBinary()
 69372  				_ = yym11
 69373  				if false {
 69374  				} else {
 69375  					*((*bool)(yyv10)) = r.DecodeBool()
 69376  				}
 69377  			}
 69378  		case "Job":
 69379  			if r.TryDecodeAsNil() {
 69380  				if x.Job != nil {
 69381  					x.Job = nil
 69382  				}
 69383  			} else {
 69384  				if x.Job == nil {
 69385  					x.Job = new(Job)
 69386  				}
 69387  				x.Job.CodecDecodeSelf(d)
 69388  			}
 69389  		case "NodeUpdate":
 69390  			if r.TryDecodeAsNil() {
 69391  				x.NodeUpdate = nil
 69392  			} else {
 69393  				yyv13 := &x.NodeUpdate
 69394  				yym14 := z.DecBinary()
 69395  				_ = yym14
 69396  				if false {
 69397  				} else {
 69398  					h.decMapstringSlicePtrtoAllocation((*map[string][]*Allocation)(yyv13), d)
 69399  				}
 69400  			}
 69401  		case "NodeAllocation":
 69402  			if r.TryDecodeAsNil() {
 69403  				x.NodeAllocation = nil
 69404  			} else {
 69405  				yyv15 := &x.NodeAllocation
 69406  				yym16 := z.DecBinary()
 69407  				_ = yym16
 69408  				if false {
 69409  				} else {
 69410  					h.decMapstringSlicePtrtoAllocation((*map[string][]*Allocation)(yyv15), d)
 69411  				}
 69412  			}
 69413  		case "Annotations":
 69414  			if r.TryDecodeAsNil() {
 69415  				if x.Annotations != nil {
 69416  					x.Annotations = nil
 69417  				}
 69418  			} else {
 69419  				if x.Annotations == nil {
 69420  					x.Annotations = new(PlanAnnotations)
 69421  				}
 69422  				x.Annotations.CodecDecodeSelf(d)
 69423  			}
 69424  		case "Deployment":
 69425  			if r.TryDecodeAsNil() {
 69426  				if x.Deployment != nil {
 69427  					x.Deployment = nil
 69428  				}
 69429  			} else {
 69430  				if x.Deployment == nil {
 69431  					x.Deployment = new(Deployment)
 69432  				}
 69433  				x.Deployment.CodecDecodeSelf(d)
 69434  			}
 69435  		case "DeploymentUpdates":
 69436  			if r.TryDecodeAsNil() {
 69437  				x.DeploymentUpdates = nil
 69438  			} else {
 69439  				yyv19 := &x.DeploymentUpdates
 69440  				yym20 := z.DecBinary()
 69441  				_ = yym20
 69442  				if false {
 69443  				} else {
 69444  					h.decSlicePtrtoDeploymentStatusUpdate((*[]*DeploymentStatusUpdate)(yyv19), d)
 69445  				}
 69446  			}
 69447  		default:
 69448  			z.DecStructFieldNotFound(-1, yys3)
 69449  		} // end switch yys3
 69450  	} // end for yyj3
 69451  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 69452  }
 69453  
 69454  func (x *Plan) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 69455  	var h codecSelfer100
 69456  	z, r := codec1978.GenHelperDecoder(d)
 69457  	_, _, _ = h, z, r
 69458  	var yyj21 int
 69459  	var yyb21 bool
 69460  	var yyhl21 bool = l >= 0
 69461  	yyj21++
 69462  	if yyhl21 {
 69463  		yyb21 = yyj21 > l
 69464  	} else {
 69465  		yyb21 = r.CheckBreak()
 69466  	}
 69467  	if yyb21 {
 69468  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 69469  		return
 69470  	}
 69471  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 69472  	if r.TryDecodeAsNil() {
 69473  		x.EvalID = ""
 69474  	} else {
 69475  		yyv22 := &x.EvalID
 69476  		yym23 := z.DecBinary()
 69477  		_ = yym23
 69478  		if false {
 69479  		} else {
 69480  			*((*string)(yyv22)) = r.DecodeString()
 69481  		}
 69482  	}
 69483  	yyj21++
 69484  	if yyhl21 {
 69485  		yyb21 = yyj21 > l
 69486  	} else {
 69487  		yyb21 = r.CheckBreak()
 69488  	}
 69489  	if yyb21 {
 69490  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 69491  		return
 69492  	}
 69493  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 69494  	if r.TryDecodeAsNil() {
 69495  		x.EvalToken = ""
 69496  	} else {
 69497  		yyv24 := &x.EvalToken
 69498  		yym25 := z.DecBinary()
 69499  		_ = yym25
 69500  		if false {
 69501  		} else {
 69502  			*((*string)(yyv24)) = r.DecodeString()
 69503  		}
 69504  	}
 69505  	yyj21++
 69506  	if yyhl21 {
 69507  		yyb21 = yyj21 > l
 69508  	} else {
 69509  		yyb21 = r.CheckBreak()
 69510  	}
 69511  	if yyb21 {
 69512  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 69513  		return
 69514  	}
 69515  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 69516  	if r.TryDecodeAsNil() {
 69517  		x.Priority = 0
 69518  	} else {
 69519  		yyv26 := &x.Priority
 69520  		yym27 := z.DecBinary()
 69521  		_ = yym27
 69522  		if false {
 69523  		} else {
 69524  			*((*int)(yyv26)) = int(r.DecodeInt(codecSelferBitsize100))
 69525  		}
 69526  	}
 69527  	yyj21++
 69528  	if yyhl21 {
 69529  		yyb21 = yyj21 > l
 69530  	} else {
 69531  		yyb21 = r.CheckBreak()
 69532  	}
 69533  	if yyb21 {
 69534  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 69535  		return
 69536  	}
 69537  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 69538  	if r.TryDecodeAsNil() {
 69539  		x.AllAtOnce = false
 69540  	} else {
 69541  		yyv28 := &x.AllAtOnce
 69542  		yym29 := z.DecBinary()
 69543  		_ = yym29
 69544  		if false {
 69545  		} else {
 69546  			*((*bool)(yyv28)) = r.DecodeBool()
 69547  		}
 69548  	}
 69549  	yyj21++
 69550  	if yyhl21 {
 69551  		yyb21 = yyj21 > l
 69552  	} else {
 69553  		yyb21 = r.CheckBreak()
 69554  	}
 69555  	if yyb21 {
 69556  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 69557  		return
 69558  	}
 69559  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 69560  	if r.TryDecodeAsNil() {
 69561  		if x.Job != nil {
 69562  			x.Job = nil
 69563  		}
 69564  	} else {
 69565  		if x.Job == nil {
 69566  			x.Job = new(Job)
 69567  		}
 69568  		x.Job.CodecDecodeSelf(d)
 69569  	}
 69570  	yyj21++
 69571  	if yyhl21 {
 69572  		yyb21 = yyj21 > l
 69573  	} else {
 69574  		yyb21 = r.CheckBreak()
 69575  	}
 69576  	if yyb21 {
 69577  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 69578  		return
 69579  	}
 69580  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 69581  	if r.TryDecodeAsNil() {
 69582  		x.NodeUpdate = nil
 69583  	} else {
 69584  		yyv31 := &x.NodeUpdate
 69585  		yym32 := z.DecBinary()
 69586  		_ = yym32
 69587  		if false {
 69588  		} else {
 69589  			h.decMapstringSlicePtrtoAllocation((*map[string][]*Allocation)(yyv31), d)
 69590  		}
 69591  	}
 69592  	yyj21++
 69593  	if yyhl21 {
 69594  		yyb21 = yyj21 > l
 69595  	} else {
 69596  		yyb21 = r.CheckBreak()
 69597  	}
 69598  	if yyb21 {
 69599  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 69600  		return
 69601  	}
 69602  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 69603  	if r.TryDecodeAsNil() {
 69604  		x.NodeAllocation = nil
 69605  	} else {
 69606  		yyv33 := &x.NodeAllocation
 69607  		yym34 := z.DecBinary()
 69608  		_ = yym34
 69609  		if false {
 69610  		} else {
 69611  			h.decMapstringSlicePtrtoAllocation((*map[string][]*Allocation)(yyv33), d)
 69612  		}
 69613  	}
 69614  	yyj21++
 69615  	if yyhl21 {
 69616  		yyb21 = yyj21 > l
 69617  	} else {
 69618  		yyb21 = r.CheckBreak()
 69619  	}
 69620  	if yyb21 {
 69621  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 69622  		return
 69623  	}
 69624  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 69625  	if r.TryDecodeAsNil() {
 69626  		if x.Annotations != nil {
 69627  			x.Annotations = nil
 69628  		}
 69629  	} else {
 69630  		if x.Annotations == nil {
 69631  			x.Annotations = new(PlanAnnotations)
 69632  		}
 69633  		x.Annotations.CodecDecodeSelf(d)
 69634  	}
 69635  	yyj21++
 69636  	if yyhl21 {
 69637  		yyb21 = yyj21 > l
 69638  	} else {
 69639  		yyb21 = r.CheckBreak()
 69640  	}
 69641  	if yyb21 {
 69642  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 69643  		return
 69644  	}
 69645  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 69646  	if r.TryDecodeAsNil() {
 69647  		if x.Deployment != nil {
 69648  			x.Deployment = nil
 69649  		}
 69650  	} else {
 69651  		if x.Deployment == nil {
 69652  			x.Deployment = new(Deployment)
 69653  		}
 69654  		x.Deployment.CodecDecodeSelf(d)
 69655  	}
 69656  	yyj21++
 69657  	if yyhl21 {
 69658  		yyb21 = yyj21 > l
 69659  	} else {
 69660  		yyb21 = r.CheckBreak()
 69661  	}
 69662  	if yyb21 {
 69663  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 69664  		return
 69665  	}
 69666  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 69667  	if r.TryDecodeAsNil() {
 69668  		x.DeploymentUpdates = nil
 69669  	} else {
 69670  		yyv37 := &x.DeploymentUpdates
 69671  		yym38 := z.DecBinary()
 69672  		_ = yym38
 69673  		if false {
 69674  		} else {
 69675  			h.decSlicePtrtoDeploymentStatusUpdate((*[]*DeploymentStatusUpdate)(yyv37), d)
 69676  		}
 69677  	}
 69678  	for {
 69679  		yyj21++
 69680  		if yyhl21 {
 69681  			yyb21 = yyj21 > l
 69682  		} else {
 69683  			yyb21 = r.CheckBreak()
 69684  		}
 69685  		if yyb21 {
 69686  			break
 69687  		}
 69688  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 69689  		z.DecStructFieldNotFound(yyj21-1, "")
 69690  	}
 69691  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 69692  }
 69693  
 69694  func (x *PlanResult) CodecEncodeSelf(e *codec1978.Encoder) {
 69695  	var h codecSelfer100
 69696  	z, r := codec1978.GenHelperEncoder(e)
 69697  	_, _, _ = h, z, r
 69698  	if x == nil {
 69699  		r.EncodeNil()
 69700  	} else {
 69701  		yym1 := z.EncBinary()
 69702  		_ = yym1
 69703  		if false {
 69704  		} else if z.HasExtensions() && z.EncExt(x) {
 69705  		} else {
 69706  			yysep2 := !z.EncBinary()
 69707  			yy2arr2 := z.EncBasicHandle().StructToArray
 69708  			var yyq2 [6]bool
 69709  			_, _, _ = yysep2, yyq2, yy2arr2
 69710  			const yyr2 bool = false
 69711  			var yynn2 int
 69712  			if yyr2 || yy2arr2 {
 69713  				r.EncodeArrayStart(6)
 69714  			} else {
 69715  				yynn2 = 6
 69716  				for _, b := range yyq2 {
 69717  					if b {
 69718  						yynn2++
 69719  					}
 69720  				}
 69721  				r.EncodeMapStart(yynn2)
 69722  				yynn2 = 0
 69723  			}
 69724  			if yyr2 || yy2arr2 {
 69725  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69726  				if x.NodeUpdate == nil {
 69727  					r.EncodeNil()
 69728  				} else {
 69729  					yym4 := z.EncBinary()
 69730  					_ = yym4
 69731  					if false {
 69732  					} else {
 69733  						h.encMapstringSlicePtrtoAllocation((map[string][]*Allocation)(x.NodeUpdate), e)
 69734  					}
 69735  				}
 69736  			} else {
 69737  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69738  				r.EncodeString(codecSelferC_UTF8100, string("NodeUpdate"))
 69739  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69740  				if x.NodeUpdate == nil {
 69741  					r.EncodeNil()
 69742  				} else {
 69743  					yym5 := z.EncBinary()
 69744  					_ = yym5
 69745  					if false {
 69746  					} else {
 69747  						h.encMapstringSlicePtrtoAllocation((map[string][]*Allocation)(x.NodeUpdate), e)
 69748  					}
 69749  				}
 69750  			}
 69751  			if yyr2 || yy2arr2 {
 69752  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69753  				if x.NodeAllocation == nil {
 69754  					r.EncodeNil()
 69755  				} else {
 69756  					yym7 := z.EncBinary()
 69757  					_ = yym7
 69758  					if false {
 69759  					} else {
 69760  						h.encMapstringSlicePtrtoAllocation((map[string][]*Allocation)(x.NodeAllocation), e)
 69761  					}
 69762  				}
 69763  			} else {
 69764  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69765  				r.EncodeString(codecSelferC_UTF8100, string("NodeAllocation"))
 69766  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69767  				if x.NodeAllocation == nil {
 69768  					r.EncodeNil()
 69769  				} else {
 69770  					yym8 := z.EncBinary()
 69771  					_ = yym8
 69772  					if false {
 69773  					} else {
 69774  						h.encMapstringSlicePtrtoAllocation((map[string][]*Allocation)(x.NodeAllocation), e)
 69775  					}
 69776  				}
 69777  			}
 69778  			if yyr2 || yy2arr2 {
 69779  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69780  				if x.Deployment == nil {
 69781  					r.EncodeNil()
 69782  				} else {
 69783  					x.Deployment.CodecEncodeSelf(e)
 69784  				}
 69785  			} else {
 69786  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69787  				r.EncodeString(codecSelferC_UTF8100, string("Deployment"))
 69788  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69789  				if x.Deployment == nil {
 69790  					r.EncodeNil()
 69791  				} else {
 69792  					x.Deployment.CodecEncodeSelf(e)
 69793  				}
 69794  			}
 69795  			if yyr2 || yy2arr2 {
 69796  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69797  				if x.DeploymentUpdates == nil {
 69798  					r.EncodeNil()
 69799  				} else {
 69800  					yym13 := z.EncBinary()
 69801  					_ = yym13
 69802  					if false {
 69803  					} else {
 69804  						h.encSlicePtrtoDeploymentStatusUpdate(([]*DeploymentStatusUpdate)(x.DeploymentUpdates), e)
 69805  					}
 69806  				}
 69807  			} else {
 69808  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69809  				r.EncodeString(codecSelferC_UTF8100, string("DeploymentUpdates"))
 69810  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69811  				if x.DeploymentUpdates == nil {
 69812  					r.EncodeNil()
 69813  				} else {
 69814  					yym14 := z.EncBinary()
 69815  					_ = yym14
 69816  					if false {
 69817  					} else {
 69818  						h.encSlicePtrtoDeploymentStatusUpdate(([]*DeploymentStatusUpdate)(x.DeploymentUpdates), e)
 69819  					}
 69820  				}
 69821  			}
 69822  			if yyr2 || yy2arr2 {
 69823  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69824  				yym16 := z.EncBinary()
 69825  				_ = yym16
 69826  				if false {
 69827  				} else {
 69828  					r.EncodeUint(uint64(x.RefreshIndex))
 69829  				}
 69830  			} else {
 69831  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69832  				r.EncodeString(codecSelferC_UTF8100, string("RefreshIndex"))
 69833  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69834  				yym17 := z.EncBinary()
 69835  				_ = yym17
 69836  				if false {
 69837  				} else {
 69838  					r.EncodeUint(uint64(x.RefreshIndex))
 69839  				}
 69840  			}
 69841  			if yyr2 || yy2arr2 {
 69842  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 69843  				yym19 := z.EncBinary()
 69844  				_ = yym19
 69845  				if false {
 69846  				} else {
 69847  					r.EncodeUint(uint64(x.AllocIndex))
 69848  				}
 69849  			} else {
 69850  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 69851  				r.EncodeString(codecSelferC_UTF8100, string("AllocIndex"))
 69852  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 69853  				yym20 := z.EncBinary()
 69854  				_ = yym20
 69855  				if false {
 69856  				} else {
 69857  					r.EncodeUint(uint64(x.AllocIndex))
 69858  				}
 69859  			}
 69860  			if yyr2 || yy2arr2 {
 69861  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 69862  			} else {
 69863  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 69864  			}
 69865  		}
 69866  	}
 69867  }
 69868  
 69869  func (x *PlanResult) CodecDecodeSelf(d *codec1978.Decoder) {
 69870  	var h codecSelfer100
 69871  	z, r := codec1978.GenHelperDecoder(d)
 69872  	_, _, _ = h, z, r
 69873  	yym1 := z.DecBinary()
 69874  	_ = yym1
 69875  	if false {
 69876  	} else if z.HasExtensions() && z.DecExt(x) {
 69877  	} else {
 69878  		yyct2 := r.ContainerType()
 69879  		if yyct2 == codecSelferValueTypeMap100 {
 69880  			yyl2 := r.ReadMapStart()
 69881  			if yyl2 == 0 {
 69882  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 69883  			} else {
 69884  				x.codecDecodeSelfFromMap(yyl2, d)
 69885  			}
 69886  		} else if yyct2 == codecSelferValueTypeArray100 {
 69887  			yyl2 := r.ReadArrayStart()
 69888  			if yyl2 == 0 {
 69889  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 69890  			} else {
 69891  				x.codecDecodeSelfFromArray(yyl2, d)
 69892  			}
 69893  		} else {
 69894  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 69895  		}
 69896  	}
 69897  }
 69898  
 69899  func (x *PlanResult) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 69900  	var h codecSelfer100
 69901  	z, r := codec1978.GenHelperDecoder(d)
 69902  	_, _, _ = h, z, r
 69903  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 69904  	_ = yys3Slc
 69905  	var yyhl3 bool = l >= 0
 69906  	for yyj3 := 0; ; yyj3++ {
 69907  		if yyhl3 {
 69908  			if yyj3 >= l {
 69909  				break
 69910  			}
 69911  		} else {
 69912  			if r.CheckBreak() {
 69913  				break
 69914  			}
 69915  		}
 69916  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 69917  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 69918  		yys3 := string(yys3Slc)
 69919  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 69920  		switch yys3 {
 69921  		case "NodeUpdate":
 69922  			if r.TryDecodeAsNil() {
 69923  				x.NodeUpdate = nil
 69924  			} else {
 69925  				yyv4 := &x.NodeUpdate
 69926  				yym5 := z.DecBinary()
 69927  				_ = yym5
 69928  				if false {
 69929  				} else {
 69930  					h.decMapstringSlicePtrtoAllocation((*map[string][]*Allocation)(yyv4), d)
 69931  				}
 69932  			}
 69933  		case "NodeAllocation":
 69934  			if r.TryDecodeAsNil() {
 69935  				x.NodeAllocation = nil
 69936  			} else {
 69937  				yyv6 := &x.NodeAllocation
 69938  				yym7 := z.DecBinary()
 69939  				_ = yym7
 69940  				if false {
 69941  				} else {
 69942  					h.decMapstringSlicePtrtoAllocation((*map[string][]*Allocation)(yyv6), d)
 69943  				}
 69944  			}
 69945  		case "Deployment":
 69946  			if r.TryDecodeAsNil() {
 69947  				if x.Deployment != nil {
 69948  					x.Deployment = nil
 69949  				}
 69950  			} else {
 69951  				if x.Deployment == nil {
 69952  					x.Deployment = new(Deployment)
 69953  				}
 69954  				x.Deployment.CodecDecodeSelf(d)
 69955  			}
 69956  		case "DeploymentUpdates":
 69957  			if r.TryDecodeAsNil() {
 69958  				x.DeploymentUpdates = nil
 69959  			} else {
 69960  				yyv9 := &x.DeploymentUpdates
 69961  				yym10 := z.DecBinary()
 69962  				_ = yym10
 69963  				if false {
 69964  				} else {
 69965  					h.decSlicePtrtoDeploymentStatusUpdate((*[]*DeploymentStatusUpdate)(yyv9), d)
 69966  				}
 69967  			}
 69968  		case "RefreshIndex":
 69969  			if r.TryDecodeAsNil() {
 69970  				x.RefreshIndex = 0
 69971  			} else {
 69972  				yyv11 := &x.RefreshIndex
 69973  				yym12 := z.DecBinary()
 69974  				_ = yym12
 69975  				if false {
 69976  				} else {
 69977  					*((*uint64)(yyv11)) = uint64(r.DecodeUint(64))
 69978  				}
 69979  			}
 69980  		case "AllocIndex":
 69981  			if r.TryDecodeAsNil() {
 69982  				x.AllocIndex = 0
 69983  			} else {
 69984  				yyv13 := &x.AllocIndex
 69985  				yym14 := z.DecBinary()
 69986  				_ = yym14
 69987  				if false {
 69988  				} else {
 69989  					*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 69990  				}
 69991  			}
 69992  		default:
 69993  			z.DecStructFieldNotFound(-1, yys3)
 69994  		} // end switch yys3
 69995  	} // end for yyj3
 69996  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 69997  }
 69998  
 69999  func (x *PlanResult) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 70000  	var h codecSelfer100
 70001  	z, r := codec1978.GenHelperDecoder(d)
 70002  	_, _, _ = h, z, r
 70003  	var yyj15 int
 70004  	var yyb15 bool
 70005  	var yyhl15 bool = l >= 0
 70006  	yyj15++
 70007  	if yyhl15 {
 70008  		yyb15 = yyj15 > l
 70009  	} else {
 70010  		yyb15 = r.CheckBreak()
 70011  	}
 70012  	if yyb15 {
 70013  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70014  		return
 70015  	}
 70016  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70017  	if r.TryDecodeAsNil() {
 70018  		x.NodeUpdate = nil
 70019  	} else {
 70020  		yyv16 := &x.NodeUpdate
 70021  		yym17 := z.DecBinary()
 70022  		_ = yym17
 70023  		if false {
 70024  		} else {
 70025  			h.decMapstringSlicePtrtoAllocation((*map[string][]*Allocation)(yyv16), d)
 70026  		}
 70027  	}
 70028  	yyj15++
 70029  	if yyhl15 {
 70030  		yyb15 = yyj15 > l
 70031  	} else {
 70032  		yyb15 = r.CheckBreak()
 70033  	}
 70034  	if yyb15 {
 70035  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70036  		return
 70037  	}
 70038  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70039  	if r.TryDecodeAsNil() {
 70040  		x.NodeAllocation = nil
 70041  	} else {
 70042  		yyv18 := &x.NodeAllocation
 70043  		yym19 := z.DecBinary()
 70044  		_ = yym19
 70045  		if false {
 70046  		} else {
 70047  			h.decMapstringSlicePtrtoAllocation((*map[string][]*Allocation)(yyv18), d)
 70048  		}
 70049  	}
 70050  	yyj15++
 70051  	if yyhl15 {
 70052  		yyb15 = yyj15 > l
 70053  	} else {
 70054  		yyb15 = r.CheckBreak()
 70055  	}
 70056  	if yyb15 {
 70057  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70058  		return
 70059  	}
 70060  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70061  	if r.TryDecodeAsNil() {
 70062  		if x.Deployment != nil {
 70063  			x.Deployment = nil
 70064  		}
 70065  	} else {
 70066  		if x.Deployment == nil {
 70067  			x.Deployment = new(Deployment)
 70068  		}
 70069  		x.Deployment.CodecDecodeSelf(d)
 70070  	}
 70071  	yyj15++
 70072  	if yyhl15 {
 70073  		yyb15 = yyj15 > l
 70074  	} else {
 70075  		yyb15 = r.CheckBreak()
 70076  	}
 70077  	if yyb15 {
 70078  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70079  		return
 70080  	}
 70081  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70082  	if r.TryDecodeAsNil() {
 70083  		x.DeploymentUpdates = nil
 70084  	} else {
 70085  		yyv21 := &x.DeploymentUpdates
 70086  		yym22 := z.DecBinary()
 70087  		_ = yym22
 70088  		if false {
 70089  		} else {
 70090  			h.decSlicePtrtoDeploymentStatusUpdate((*[]*DeploymentStatusUpdate)(yyv21), d)
 70091  		}
 70092  	}
 70093  	yyj15++
 70094  	if yyhl15 {
 70095  		yyb15 = yyj15 > l
 70096  	} else {
 70097  		yyb15 = r.CheckBreak()
 70098  	}
 70099  	if yyb15 {
 70100  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70101  		return
 70102  	}
 70103  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70104  	if r.TryDecodeAsNil() {
 70105  		x.RefreshIndex = 0
 70106  	} else {
 70107  		yyv23 := &x.RefreshIndex
 70108  		yym24 := z.DecBinary()
 70109  		_ = yym24
 70110  		if false {
 70111  		} else {
 70112  			*((*uint64)(yyv23)) = uint64(r.DecodeUint(64))
 70113  		}
 70114  	}
 70115  	yyj15++
 70116  	if yyhl15 {
 70117  		yyb15 = yyj15 > l
 70118  	} else {
 70119  		yyb15 = r.CheckBreak()
 70120  	}
 70121  	if yyb15 {
 70122  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70123  		return
 70124  	}
 70125  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70126  	if r.TryDecodeAsNil() {
 70127  		x.AllocIndex = 0
 70128  	} else {
 70129  		yyv25 := &x.AllocIndex
 70130  		yym26 := z.DecBinary()
 70131  		_ = yym26
 70132  		if false {
 70133  		} else {
 70134  			*((*uint64)(yyv25)) = uint64(r.DecodeUint(64))
 70135  		}
 70136  	}
 70137  	for {
 70138  		yyj15++
 70139  		if yyhl15 {
 70140  			yyb15 = yyj15 > l
 70141  		} else {
 70142  			yyb15 = r.CheckBreak()
 70143  		}
 70144  		if yyb15 {
 70145  			break
 70146  		}
 70147  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70148  		z.DecStructFieldNotFound(yyj15-1, "")
 70149  	}
 70150  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70151  }
 70152  
 70153  func (x *PlanAnnotations) CodecEncodeSelf(e *codec1978.Encoder) {
 70154  	var h codecSelfer100
 70155  	z, r := codec1978.GenHelperEncoder(e)
 70156  	_, _, _ = h, z, r
 70157  	if x == nil {
 70158  		r.EncodeNil()
 70159  	} else {
 70160  		yym1 := z.EncBinary()
 70161  		_ = yym1
 70162  		if false {
 70163  		} else if z.HasExtensions() && z.EncExt(x) {
 70164  		} else {
 70165  			yysep2 := !z.EncBinary()
 70166  			yy2arr2 := z.EncBasicHandle().StructToArray
 70167  			var yyq2 [1]bool
 70168  			_, _, _ = yysep2, yyq2, yy2arr2
 70169  			const yyr2 bool = false
 70170  			var yynn2 int
 70171  			if yyr2 || yy2arr2 {
 70172  				r.EncodeArrayStart(1)
 70173  			} else {
 70174  				yynn2 = 1
 70175  				for _, b := range yyq2 {
 70176  					if b {
 70177  						yynn2++
 70178  					}
 70179  				}
 70180  				r.EncodeMapStart(yynn2)
 70181  				yynn2 = 0
 70182  			}
 70183  			if yyr2 || yy2arr2 {
 70184  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 70185  				if x.DesiredTGUpdates == nil {
 70186  					r.EncodeNil()
 70187  				} else {
 70188  					yym4 := z.EncBinary()
 70189  					_ = yym4
 70190  					if false {
 70191  					} else {
 70192  						h.encMapstringPtrtoDesiredUpdates((map[string]*DesiredUpdates)(x.DesiredTGUpdates), e)
 70193  					}
 70194  				}
 70195  			} else {
 70196  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 70197  				r.EncodeString(codecSelferC_UTF8100, string("DesiredTGUpdates"))
 70198  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 70199  				if x.DesiredTGUpdates == nil {
 70200  					r.EncodeNil()
 70201  				} else {
 70202  					yym5 := z.EncBinary()
 70203  					_ = yym5
 70204  					if false {
 70205  					} else {
 70206  						h.encMapstringPtrtoDesiredUpdates((map[string]*DesiredUpdates)(x.DesiredTGUpdates), e)
 70207  					}
 70208  				}
 70209  			}
 70210  			if yyr2 || yy2arr2 {
 70211  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 70212  			} else {
 70213  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 70214  			}
 70215  		}
 70216  	}
 70217  }
 70218  
 70219  func (x *PlanAnnotations) CodecDecodeSelf(d *codec1978.Decoder) {
 70220  	var h codecSelfer100
 70221  	z, r := codec1978.GenHelperDecoder(d)
 70222  	_, _, _ = h, z, r
 70223  	yym1 := z.DecBinary()
 70224  	_ = yym1
 70225  	if false {
 70226  	} else if z.HasExtensions() && z.DecExt(x) {
 70227  	} else {
 70228  		yyct2 := r.ContainerType()
 70229  		if yyct2 == codecSelferValueTypeMap100 {
 70230  			yyl2 := r.ReadMapStart()
 70231  			if yyl2 == 0 {
 70232  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 70233  			} else {
 70234  				x.codecDecodeSelfFromMap(yyl2, d)
 70235  			}
 70236  		} else if yyct2 == codecSelferValueTypeArray100 {
 70237  			yyl2 := r.ReadArrayStart()
 70238  			if yyl2 == 0 {
 70239  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70240  			} else {
 70241  				x.codecDecodeSelfFromArray(yyl2, d)
 70242  			}
 70243  		} else {
 70244  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 70245  		}
 70246  	}
 70247  }
 70248  
 70249  func (x *PlanAnnotations) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 70250  	var h codecSelfer100
 70251  	z, r := codec1978.GenHelperDecoder(d)
 70252  	_, _, _ = h, z, r
 70253  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 70254  	_ = yys3Slc
 70255  	var yyhl3 bool = l >= 0
 70256  	for yyj3 := 0; ; yyj3++ {
 70257  		if yyhl3 {
 70258  			if yyj3 >= l {
 70259  				break
 70260  			}
 70261  		} else {
 70262  			if r.CheckBreak() {
 70263  				break
 70264  			}
 70265  		}
 70266  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 70267  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 70268  		yys3 := string(yys3Slc)
 70269  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 70270  		switch yys3 {
 70271  		case "DesiredTGUpdates":
 70272  			if r.TryDecodeAsNil() {
 70273  				x.DesiredTGUpdates = nil
 70274  			} else {
 70275  				yyv4 := &x.DesiredTGUpdates
 70276  				yym5 := z.DecBinary()
 70277  				_ = yym5
 70278  				if false {
 70279  				} else {
 70280  					h.decMapstringPtrtoDesiredUpdates((*map[string]*DesiredUpdates)(yyv4), d)
 70281  				}
 70282  			}
 70283  		default:
 70284  			z.DecStructFieldNotFound(-1, yys3)
 70285  		} // end switch yys3
 70286  	} // end for yyj3
 70287  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 70288  }
 70289  
 70290  func (x *PlanAnnotations) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 70291  	var h codecSelfer100
 70292  	z, r := codec1978.GenHelperDecoder(d)
 70293  	_, _, _ = h, z, r
 70294  	var yyj6 int
 70295  	var yyb6 bool
 70296  	var yyhl6 bool = l >= 0
 70297  	yyj6++
 70298  	if yyhl6 {
 70299  		yyb6 = yyj6 > l
 70300  	} else {
 70301  		yyb6 = r.CheckBreak()
 70302  	}
 70303  	if yyb6 {
 70304  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70305  		return
 70306  	}
 70307  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70308  	if r.TryDecodeAsNil() {
 70309  		x.DesiredTGUpdates = nil
 70310  	} else {
 70311  		yyv7 := &x.DesiredTGUpdates
 70312  		yym8 := z.DecBinary()
 70313  		_ = yym8
 70314  		if false {
 70315  		} else {
 70316  			h.decMapstringPtrtoDesiredUpdates((*map[string]*DesiredUpdates)(yyv7), d)
 70317  		}
 70318  	}
 70319  	for {
 70320  		yyj6++
 70321  		if yyhl6 {
 70322  			yyb6 = yyj6 > l
 70323  		} else {
 70324  			yyb6 = r.CheckBreak()
 70325  		}
 70326  		if yyb6 {
 70327  			break
 70328  		}
 70329  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70330  		z.DecStructFieldNotFound(yyj6-1, "")
 70331  	}
 70332  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70333  }
 70334  
 70335  func (x *DesiredUpdates) CodecEncodeSelf(e *codec1978.Encoder) {
 70336  	var h codecSelfer100
 70337  	z, r := codec1978.GenHelperEncoder(e)
 70338  	_, _, _ = h, z, r
 70339  	if x == nil {
 70340  		r.EncodeNil()
 70341  	} else {
 70342  		yym1 := z.EncBinary()
 70343  		_ = yym1
 70344  		if false {
 70345  		} else if z.HasExtensions() && z.EncExt(x) {
 70346  		} else {
 70347  			yysep2 := !z.EncBinary()
 70348  			yy2arr2 := z.EncBasicHandle().StructToArray
 70349  			var yyq2 [7]bool
 70350  			_, _, _ = yysep2, yyq2, yy2arr2
 70351  			const yyr2 bool = false
 70352  			var yynn2 int
 70353  			if yyr2 || yy2arr2 {
 70354  				r.EncodeArrayStart(7)
 70355  			} else {
 70356  				yynn2 = 7
 70357  				for _, b := range yyq2 {
 70358  					if b {
 70359  						yynn2++
 70360  					}
 70361  				}
 70362  				r.EncodeMapStart(yynn2)
 70363  				yynn2 = 0
 70364  			}
 70365  			if yyr2 || yy2arr2 {
 70366  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 70367  				yym4 := z.EncBinary()
 70368  				_ = yym4
 70369  				if false {
 70370  				} else {
 70371  					r.EncodeUint(uint64(x.Ignore))
 70372  				}
 70373  			} else {
 70374  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 70375  				r.EncodeString(codecSelferC_UTF8100, string("Ignore"))
 70376  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 70377  				yym5 := z.EncBinary()
 70378  				_ = yym5
 70379  				if false {
 70380  				} else {
 70381  					r.EncodeUint(uint64(x.Ignore))
 70382  				}
 70383  			}
 70384  			if yyr2 || yy2arr2 {
 70385  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 70386  				yym7 := z.EncBinary()
 70387  				_ = yym7
 70388  				if false {
 70389  				} else {
 70390  					r.EncodeUint(uint64(x.Place))
 70391  				}
 70392  			} else {
 70393  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 70394  				r.EncodeString(codecSelferC_UTF8100, string("Place"))
 70395  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 70396  				yym8 := z.EncBinary()
 70397  				_ = yym8
 70398  				if false {
 70399  				} else {
 70400  					r.EncodeUint(uint64(x.Place))
 70401  				}
 70402  			}
 70403  			if yyr2 || yy2arr2 {
 70404  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 70405  				yym10 := z.EncBinary()
 70406  				_ = yym10
 70407  				if false {
 70408  				} else {
 70409  					r.EncodeUint(uint64(x.Migrate))
 70410  				}
 70411  			} else {
 70412  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 70413  				r.EncodeString(codecSelferC_UTF8100, string("Migrate"))
 70414  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 70415  				yym11 := z.EncBinary()
 70416  				_ = yym11
 70417  				if false {
 70418  				} else {
 70419  					r.EncodeUint(uint64(x.Migrate))
 70420  				}
 70421  			}
 70422  			if yyr2 || yy2arr2 {
 70423  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 70424  				yym13 := z.EncBinary()
 70425  				_ = yym13
 70426  				if false {
 70427  				} else {
 70428  					r.EncodeUint(uint64(x.Stop))
 70429  				}
 70430  			} else {
 70431  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 70432  				r.EncodeString(codecSelferC_UTF8100, string("Stop"))
 70433  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 70434  				yym14 := z.EncBinary()
 70435  				_ = yym14
 70436  				if false {
 70437  				} else {
 70438  					r.EncodeUint(uint64(x.Stop))
 70439  				}
 70440  			}
 70441  			if yyr2 || yy2arr2 {
 70442  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 70443  				yym16 := z.EncBinary()
 70444  				_ = yym16
 70445  				if false {
 70446  				} else {
 70447  					r.EncodeUint(uint64(x.InPlaceUpdate))
 70448  				}
 70449  			} else {
 70450  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 70451  				r.EncodeString(codecSelferC_UTF8100, string("InPlaceUpdate"))
 70452  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 70453  				yym17 := z.EncBinary()
 70454  				_ = yym17
 70455  				if false {
 70456  				} else {
 70457  					r.EncodeUint(uint64(x.InPlaceUpdate))
 70458  				}
 70459  			}
 70460  			if yyr2 || yy2arr2 {
 70461  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 70462  				yym19 := z.EncBinary()
 70463  				_ = yym19
 70464  				if false {
 70465  				} else {
 70466  					r.EncodeUint(uint64(x.DestructiveUpdate))
 70467  				}
 70468  			} else {
 70469  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 70470  				r.EncodeString(codecSelferC_UTF8100, string("DestructiveUpdate"))
 70471  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 70472  				yym20 := z.EncBinary()
 70473  				_ = yym20
 70474  				if false {
 70475  				} else {
 70476  					r.EncodeUint(uint64(x.DestructiveUpdate))
 70477  				}
 70478  			}
 70479  			if yyr2 || yy2arr2 {
 70480  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 70481  				yym22 := z.EncBinary()
 70482  				_ = yym22
 70483  				if false {
 70484  				} else {
 70485  					r.EncodeUint(uint64(x.Canary))
 70486  				}
 70487  			} else {
 70488  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 70489  				r.EncodeString(codecSelferC_UTF8100, string("Canary"))
 70490  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 70491  				yym23 := z.EncBinary()
 70492  				_ = yym23
 70493  				if false {
 70494  				} else {
 70495  					r.EncodeUint(uint64(x.Canary))
 70496  				}
 70497  			}
 70498  			if yyr2 || yy2arr2 {
 70499  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 70500  			} else {
 70501  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 70502  			}
 70503  		}
 70504  	}
 70505  }
 70506  
 70507  func (x *DesiredUpdates) CodecDecodeSelf(d *codec1978.Decoder) {
 70508  	var h codecSelfer100
 70509  	z, r := codec1978.GenHelperDecoder(d)
 70510  	_, _, _ = h, z, r
 70511  	yym1 := z.DecBinary()
 70512  	_ = yym1
 70513  	if false {
 70514  	} else if z.HasExtensions() && z.DecExt(x) {
 70515  	} else {
 70516  		yyct2 := r.ContainerType()
 70517  		if yyct2 == codecSelferValueTypeMap100 {
 70518  			yyl2 := r.ReadMapStart()
 70519  			if yyl2 == 0 {
 70520  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 70521  			} else {
 70522  				x.codecDecodeSelfFromMap(yyl2, d)
 70523  			}
 70524  		} else if yyct2 == codecSelferValueTypeArray100 {
 70525  			yyl2 := r.ReadArrayStart()
 70526  			if yyl2 == 0 {
 70527  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70528  			} else {
 70529  				x.codecDecodeSelfFromArray(yyl2, d)
 70530  			}
 70531  		} else {
 70532  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 70533  		}
 70534  	}
 70535  }
 70536  
 70537  func (x *DesiredUpdates) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 70538  	var h codecSelfer100
 70539  	z, r := codec1978.GenHelperDecoder(d)
 70540  	_, _, _ = h, z, r
 70541  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 70542  	_ = yys3Slc
 70543  	var yyhl3 bool = l >= 0
 70544  	for yyj3 := 0; ; yyj3++ {
 70545  		if yyhl3 {
 70546  			if yyj3 >= l {
 70547  				break
 70548  			}
 70549  		} else {
 70550  			if r.CheckBreak() {
 70551  				break
 70552  			}
 70553  		}
 70554  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 70555  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 70556  		yys3 := string(yys3Slc)
 70557  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 70558  		switch yys3 {
 70559  		case "Ignore":
 70560  			if r.TryDecodeAsNil() {
 70561  				x.Ignore = 0
 70562  			} else {
 70563  				yyv4 := &x.Ignore
 70564  				yym5 := z.DecBinary()
 70565  				_ = yym5
 70566  				if false {
 70567  				} else {
 70568  					*((*uint64)(yyv4)) = uint64(r.DecodeUint(64))
 70569  				}
 70570  			}
 70571  		case "Place":
 70572  			if r.TryDecodeAsNil() {
 70573  				x.Place = 0
 70574  			} else {
 70575  				yyv6 := &x.Place
 70576  				yym7 := z.DecBinary()
 70577  				_ = yym7
 70578  				if false {
 70579  				} else {
 70580  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 70581  				}
 70582  			}
 70583  		case "Migrate":
 70584  			if r.TryDecodeAsNil() {
 70585  				x.Migrate = 0
 70586  			} else {
 70587  				yyv8 := &x.Migrate
 70588  				yym9 := z.DecBinary()
 70589  				_ = yym9
 70590  				if false {
 70591  				} else {
 70592  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 70593  				}
 70594  			}
 70595  		case "Stop":
 70596  			if r.TryDecodeAsNil() {
 70597  				x.Stop = 0
 70598  			} else {
 70599  				yyv10 := &x.Stop
 70600  				yym11 := z.DecBinary()
 70601  				_ = yym11
 70602  				if false {
 70603  				} else {
 70604  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 70605  				}
 70606  			}
 70607  		case "InPlaceUpdate":
 70608  			if r.TryDecodeAsNil() {
 70609  				x.InPlaceUpdate = 0
 70610  			} else {
 70611  				yyv12 := &x.InPlaceUpdate
 70612  				yym13 := z.DecBinary()
 70613  				_ = yym13
 70614  				if false {
 70615  				} else {
 70616  					*((*uint64)(yyv12)) = uint64(r.DecodeUint(64))
 70617  				}
 70618  			}
 70619  		case "DestructiveUpdate":
 70620  			if r.TryDecodeAsNil() {
 70621  				x.DestructiveUpdate = 0
 70622  			} else {
 70623  				yyv14 := &x.DestructiveUpdate
 70624  				yym15 := z.DecBinary()
 70625  				_ = yym15
 70626  				if false {
 70627  				} else {
 70628  					*((*uint64)(yyv14)) = uint64(r.DecodeUint(64))
 70629  				}
 70630  			}
 70631  		case "Canary":
 70632  			if r.TryDecodeAsNil() {
 70633  				x.Canary = 0
 70634  			} else {
 70635  				yyv16 := &x.Canary
 70636  				yym17 := z.DecBinary()
 70637  				_ = yym17
 70638  				if false {
 70639  				} else {
 70640  					*((*uint64)(yyv16)) = uint64(r.DecodeUint(64))
 70641  				}
 70642  			}
 70643  		default:
 70644  			z.DecStructFieldNotFound(-1, yys3)
 70645  		} // end switch yys3
 70646  	} // end for yyj3
 70647  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 70648  }
 70649  
 70650  func (x *DesiredUpdates) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 70651  	var h codecSelfer100
 70652  	z, r := codec1978.GenHelperDecoder(d)
 70653  	_, _, _ = h, z, r
 70654  	var yyj18 int
 70655  	var yyb18 bool
 70656  	var yyhl18 bool = l >= 0
 70657  	yyj18++
 70658  	if yyhl18 {
 70659  		yyb18 = yyj18 > l
 70660  	} else {
 70661  		yyb18 = r.CheckBreak()
 70662  	}
 70663  	if yyb18 {
 70664  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70665  		return
 70666  	}
 70667  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70668  	if r.TryDecodeAsNil() {
 70669  		x.Ignore = 0
 70670  	} else {
 70671  		yyv19 := &x.Ignore
 70672  		yym20 := z.DecBinary()
 70673  		_ = yym20
 70674  		if false {
 70675  		} else {
 70676  			*((*uint64)(yyv19)) = uint64(r.DecodeUint(64))
 70677  		}
 70678  	}
 70679  	yyj18++
 70680  	if yyhl18 {
 70681  		yyb18 = yyj18 > l
 70682  	} else {
 70683  		yyb18 = r.CheckBreak()
 70684  	}
 70685  	if yyb18 {
 70686  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70687  		return
 70688  	}
 70689  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70690  	if r.TryDecodeAsNil() {
 70691  		x.Place = 0
 70692  	} else {
 70693  		yyv21 := &x.Place
 70694  		yym22 := z.DecBinary()
 70695  		_ = yym22
 70696  		if false {
 70697  		} else {
 70698  			*((*uint64)(yyv21)) = uint64(r.DecodeUint(64))
 70699  		}
 70700  	}
 70701  	yyj18++
 70702  	if yyhl18 {
 70703  		yyb18 = yyj18 > l
 70704  	} else {
 70705  		yyb18 = r.CheckBreak()
 70706  	}
 70707  	if yyb18 {
 70708  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70709  		return
 70710  	}
 70711  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70712  	if r.TryDecodeAsNil() {
 70713  		x.Migrate = 0
 70714  	} else {
 70715  		yyv23 := &x.Migrate
 70716  		yym24 := z.DecBinary()
 70717  		_ = yym24
 70718  		if false {
 70719  		} else {
 70720  			*((*uint64)(yyv23)) = uint64(r.DecodeUint(64))
 70721  		}
 70722  	}
 70723  	yyj18++
 70724  	if yyhl18 {
 70725  		yyb18 = yyj18 > l
 70726  	} else {
 70727  		yyb18 = r.CheckBreak()
 70728  	}
 70729  	if yyb18 {
 70730  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70731  		return
 70732  	}
 70733  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70734  	if r.TryDecodeAsNil() {
 70735  		x.Stop = 0
 70736  	} else {
 70737  		yyv25 := &x.Stop
 70738  		yym26 := z.DecBinary()
 70739  		_ = yym26
 70740  		if false {
 70741  		} else {
 70742  			*((*uint64)(yyv25)) = uint64(r.DecodeUint(64))
 70743  		}
 70744  	}
 70745  	yyj18++
 70746  	if yyhl18 {
 70747  		yyb18 = yyj18 > l
 70748  	} else {
 70749  		yyb18 = r.CheckBreak()
 70750  	}
 70751  	if yyb18 {
 70752  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70753  		return
 70754  	}
 70755  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70756  	if r.TryDecodeAsNil() {
 70757  		x.InPlaceUpdate = 0
 70758  	} else {
 70759  		yyv27 := &x.InPlaceUpdate
 70760  		yym28 := z.DecBinary()
 70761  		_ = yym28
 70762  		if false {
 70763  		} else {
 70764  			*((*uint64)(yyv27)) = uint64(r.DecodeUint(64))
 70765  		}
 70766  	}
 70767  	yyj18++
 70768  	if yyhl18 {
 70769  		yyb18 = yyj18 > l
 70770  	} else {
 70771  		yyb18 = r.CheckBreak()
 70772  	}
 70773  	if yyb18 {
 70774  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70775  		return
 70776  	}
 70777  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70778  	if r.TryDecodeAsNil() {
 70779  		x.DestructiveUpdate = 0
 70780  	} else {
 70781  		yyv29 := &x.DestructiveUpdate
 70782  		yym30 := z.DecBinary()
 70783  		_ = yym30
 70784  		if false {
 70785  		} else {
 70786  			*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
 70787  		}
 70788  	}
 70789  	yyj18++
 70790  	if yyhl18 {
 70791  		yyb18 = yyj18 > l
 70792  	} else {
 70793  		yyb18 = r.CheckBreak()
 70794  	}
 70795  	if yyb18 {
 70796  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70797  		return
 70798  	}
 70799  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70800  	if r.TryDecodeAsNil() {
 70801  		x.Canary = 0
 70802  	} else {
 70803  		yyv31 := &x.Canary
 70804  		yym32 := z.DecBinary()
 70805  		_ = yym32
 70806  		if false {
 70807  		} else {
 70808  			*((*uint64)(yyv31)) = uint64(r.DecodeUint(64))
 70809  		}
 70810  	}
 70811  	for {
 70812  		yyj18++
 70813  		if yyhl18 {
 70814  			yyb18 = yyj18 > l
 70815  		} else {
 70816  			yyb18 = r.CheckBreak()
 70817  		}
 70818  		if yyb18 {
 70819  			break
 70820  		}
 70821  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 70822  		z.DecStructFieldNotFound(yyj18-1, "")
 70823  	}
 70824  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70825  }
 70826  
 70827  func (x *KeyringResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 70828  	var h codecSelfer100
 70829  	z, r := codec1978.GenHelperEncoder(e)
 70830  	_, _, _ = h, z, r
 70831  	if x == nil {
 70832  		r.EncodeNil()
 70833  	} else {
 70834  		yym1 := z.EncBinary()
 70835  		_ = yym1
 70836  		if false {
 70837  		} else if z.HasExtensions() && z.EncExt(x) {
 70838  		} else {
 70839  			yysep2 := !z.EncBinary()
 70840  			yy2arr2 := z.EncBasicHandle().StructToArray
 70841  			var yyq2 [3]bool
 70842  			_, _, _ = yysep2, yyq2, yy2arr2
 70843  			const yyr2 bool = false
 70844  			var yynn2 int
 70845  			if yyr2 || yy2arr2 {
 70846  				r.EncodeArrayStart(3)
 70847  			} else {
 70848  				yynn2 = 3
 70849  				for _, b := range yyq2 {
 70850  					if b {
 70851  						yynn2++
 70852  					}
 70853  				}
 70854  				r.EncodeMapStart(yynn2)
 70855  				yynn2 = 0
 70856  			}
 70857  			if yyr2 || yy2arr2 {
 70858  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 70859  				if x.Messages == nil {
 70860  					r.EncodeNil()
 70861  				} else {
 70862  					yym4 := z.EncBinary()
 70863  					_ = yym4
 70864  					if false {
 70865  					} else {
 70866  						z.F.EncMapStringStringV(x.Messages, false, e)
 70867  					}
 70868  				}
 70869  			} else {
 70870  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 70871  				r.EncodeString(codecSelferC_UTF8100, string("Messages"))
 70872  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 70873  				if x.Messages == nil {
 70874  					r.EncodeNil()
 70875  				} else {
 70876  					yym5 := z.EncBinary()
 70877  					_ = yym5
 70878  					if false {
 70879  					} else {
 70880  						z.F.EncMapStringStringV(x.Messages, false, e)
 70881  					}
 70882  				}
 70883  			}
 70884  			if yyr2 || yy2arr2 {
 70885  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 70886  				if x.Keys == nil {
 70887  					r.EncodeNil()
 70888  				} else {
 70889  					yym7 := z.EncBinary()
 70890  					_ = yym7
 70891  					if false {
 70892  					} else {
 70893  						z.F.EncMapStringIntV(x.Keys, false, e)
 70894  					}
 70895  				}
 70896  			} else {
 70897  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 70898  				r.EncodeString(codecSelferC_UTF8100, string("Keys"))
 70899  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 70900  				if x.Keys == nil {
 70901  					r.EncodeNil()
 70902  				} else {
 70903  					yym8 := z.EncBinary()
 70904  					_ = yym8
 70905  					if false {
 70906  					} else {
 70907  						z.F.EncMapStringIntV(x.Keys, false, e)
 70908  					}
 70909  				}
 70910  			}
 70911  			if yyr2 || yy2arr2 {
 70912  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 70913  				yym10 := z.EncBinary()
 70914  				_ = yym10
 70915  				if false {
 70916  				} else {
 70917  					r.EncodeInt(int64(x.NumNodes))
 70918  				}
 70919  			} else {
 70920  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 70921  				r.EncodeString(codecSelferC_UTF8100, string("NumNodes"))
 70922  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 70923  				yym11 := z.EncBinary()
 70924  				_ = yym11
 70925  				if false {
 70926  				} else {
 70927  					r.EncodeInt(int64(x.NumNodes))
 70928  				}
 70929  			}
 70930  			if yyr2 || yy2arr2 {
 70931  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 70932  			} else {
 70933  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 70934  			}
 70935  		}
 70936  	}
 70937  }
 70938  
 70939  func (x *KeyringResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 70940  	var h codecSelfer100
 70941  	z, r := codec1978.GenHelperDecoder(d)
 70942  	_, _, _ = h, z, r
 70943  	yym1 := z.DecBinary()
 70944  	_ = yym1
 70945  	if false {
 70946  	} else if z.HasExtensions() && z.DecExt(x) {
 70947  	} else {
 70948  		yyct2 := r.ContainerType()
 70949  		if yyct2 == codecSelferValueTypeMap100 {
 70950  			yyl2 := r.ReadMapStart()
 70951  			if yyl2 == 0 {
 70952  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 70953  			} else {
 70954  				x.codecDecodeSelfFromMap(yyl2, d)
 70955  			}
 70956  		} else if yyct2 == codecSelferValueTypeArray100 {
 70957  			yyl2 := r.ReadArrayStart()
 70958  			if yyl2 == 0 {
 70959  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 70960  			} else {
 70961  				x.codecDecodeSelfFromArray(yyl2, d)
 70962  			}
 70963  		} else {
 70964  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 70965  		}
 70966  	}
 70967  }
 70968  
 70969  func (x *KeyringResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 70970  	var h codecSelfer100
 70971  	z, r := codec1978.GenHelperDecoder(d)
 70972  	_, _, _ = h, z, r
 70973  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 70974  	_ = yys3Slc
 70975  	var yyhl3 bool = l >= 0
 70976  	for yyj3 := 0; ; yyj3++ {
 70977  		if yyhl3 {
 70978  			if yyj3 >= l {
 70979  				break
 70980  			}
 70981  		} else {
 70982  			if r.CheckBreak() {
 70983  				break
 70984  			}
 70985  		}
 70986  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 70987  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 70988  		yys3 := string(yys3Slc)
 70989  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 70990  		switch yys3 {
 70991  		case "Messages":
 70992  			if r.TryDecodeAsNil() {
 70993  				x.Messages = nil
 70994  			} else {
 70995  				yyv4 := &x.Messages
 70996  				yym5 := z.DecBinary()
 70997  				_ = yym5
 70998  				if false {
 70999  				} else {
 71000  					z.F.DecMapStringStringX(yyv4, false, d)
 71001  				}
 71002  			}
 71003  		case "Keys":
 71004  			if r.TryDecodeAsNil() {
 71005  				x.Keys = nil
 71006  			} else {
 71007  				yyv6 := &x.Keys
 71008  				yym7 := z.DecBinary()
 71009  				_ = yym7
 71010  				if false {
 71011  				} else {
 71012  					z.F.DecMapStringIntX(yyv6, false, d)
 71013  				}
 71014  			}
 71015  		case "NumNodes":
 71016  			if r.TryDecodeAsNil() {
 71017  				x.NumNodes = 0
 71018  			} else {
 71019  				yyv8 := &x.NumNodes
 71020  				yym9 := z.DecBinary()
 71021  				_ = yym9
 71022  				if false {
 71023  				} else {
 71024  					*((*int)(yyv8)) = int(r.DecodeInt(codecSelferBitsize100))
 71025  				}
 71026  			}
 71027  		default:
 71028  			z.DecStructFieldNotFound(-1, yys3)
 71029  		} // end switch yys3
 71030  	} // end for yyj3
 71031  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 71032  }
 71033  
 71034  func (x *KeyringResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 71035  	var h codecSelfer100
 71036  	z, r := codec1978.GenHelperDecoder(d)
 71037  	_, _, _ = h, z, r
 71038  	var yyj10 int
 71039  	var yyb10 bool
 71040  	var yyhl10 bool = l >= 0
 71041  	yyj10++
 71042  	if yyhl10 {
 71043  		yyb10 = yyj10 > l
 71044  	} else {
 71045  		yyb10 = r.CheckBreak()
 71046  	}
 71047  	if yyb10 {
 71048  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 71049  		return
 71050  	}
 71051  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 71052  	if r.TryDecodeAsNil() {
 71053  		x.Messages = nil
 71054  	} else {
 71055  		yyv11 := &x.Messages
 71056  		yym12 := z.DecBinary()
 71057  		_ = yym12
 71058  		if false {
 71059  		} else {
 71060  			z.F.DecMapStringStringX(yyv11, false, d)
 71061  		}
 71062  	}
 71063  	yyj10++
 71064  	if yyhl10 {
 71065  		yyb10 = yyj10 > l
 71066  	} else {
 71067  		yyb10 = r.CheckBreak()
 71068  	}
 71069  	if yyb10 {
 71070  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 71071  		return
 71072  	}
 71073  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 71074  	if r.TryDecodeAsNil() {
 71075  		x.Keys = nil
 71076  	} else {
 71077  		yyv13 := &x.Keys
 71078  		yym14 := z.DecBinary()
 71079  		_ = yym14
 71080  		if false {
 71081  		} else {
 71082  			z.F.DecMapStringIntX(yyv13, false, d)
 71083  		}
 71084  	}
 71085  	yyj10++
 71086  	if yyhl10 {
 71087  		yyb10 = yyj10 > l
 71088  	} else {
 71089  		yyb10 = r.CheckBreak()
 71090  	}
 71091  	if yyb10 {
 71092  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 71093  		return
 71094  	}
 71095  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 71096  	if r.TryDecodeAsNil() {
 71097  		x.NumNodes = 0
 71098  	} else {
 71099  		yyv15 := &x.NumNodes
 71100  		yym16 := z.DecBinary()
 71101  		_ = yym16
 71102  		if false {
 71103  		} else {
 71104  			*((*int)(yyv15)) = int(r.DecodeInt(codecSelferBitsize100))
 71105  		}
 71106  	}
 71107  	for {
 71108  		yyj10++
 71109  		if yyhl10 {
 71110  			yyb10 = yyj10 > l
 71111  		} else {
 71112  			yyb10 = r.CheckBreak()
 71113  		}
 71114  		if yyb10 {
 71115  			break
 71116  		}
 71117  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 71118  		z.DecStructFieldNotFound(yyj10-1, "")
 71119  	}
 71120  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 71121  }
 71122  
 71123  func (x *KeyringRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 71124  	var h codecSelfer100
 71125  	z, r := codec1978.GenHelperEncoder(e)
 71126  	_, _, _ = h, z, r
 71127  	if x == nil {
 71128  		r.EncodeNil()
 71129  	} else {
 71130  		yym1 := z.EncBinary()
 71131  		_ = yym1
 71132  		if false {
 71133  		} else if z.HasExtensions() && z.EncExt(x) {
 71134  		} else {
 71135  			yysep2 := !z.EncBinary()
 71136  			yy2arr2 := z.EncBasicHandle().StructToArray
 71137  			var yyq2 [1]bool
 71138  			_, _, _ = yysep2, yyq2, yy2arr2
 71139  			const yyr2 bool = false
 71140  			var yynn2 int
 71141  			if yyr2 || yy2arr2 {
 71142  				r.EncodeArrayStart(1)
 71143  			} else {
 71144  				yynn2 = 1
 71145  				for _, b := range yyq2 {
 71146  					if b {
 71147  						yynn2++
 71148  					}
 71149  				}
 71150  				r.EncodeMapStart(yynn2)
 71151  				yynn2 = 0
 71152  			}
 71153  			if yyr2 || yy2arr2 {
 71154  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 71155  				yym4 := z.EncBinary()
 71156  				_ = yym4
 71157  				if false {
 71158  				} else {
 71159  					r.EncodeString(codecSelferC_UTF8100, string(x.Key))
 71160  				}
 71161  			} else {
 71162  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 71163  				r.EncodeString(codecSelferC_UTF8100, string("Key"))
 71164  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 71165  				yym5 := z.EncBinary()
 71166  				_ = yym5
 71167  				if false {
 71168  				} else {
 71169  					r.EncodeString(codecSelferC_UTF8100, string(x.Key))
 71170  				}
 71171  			}
 71172  			if yyr2 || yy2arr2 {
 71173  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 71174  			} else {
 71175  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 71176  			}
 71177  		}
 71178  	}
 71179  }
 71180  
 71181  func (x *KeyringRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 71182  	var h codecSelfer100
 71183  	z, r := codec1978.GenHelperDecoder(d)
 71184  	_, _, _ = h, z, r
 71185  	yym1 := z.DecBinary()
 71186  	_ = yym1
 71187  	if false {
 71188  	} else if z.HasExtensions() && z.DecExt(x) {
 71189  	} else {
 71190  		yyct2 := r.ContainerType()
 71191  		if yyct2 == codecSelferValueTypeMap100 {
 71192  			yyl2 := r.ReadMapStart()
 71193  			if yyl2 == 0 {
 71194  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 71195  			} else {
 71196  				x.codecDecodeSelfFromMap(yyl2, d)
 71197  			}
 71198  		} else if yyct2 == codecSelferValueTypeArray100 {
 71199  			yyl2 := r.ReadArrayStart()
 71200  			if yyl2 == 0 {
 71201  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 71202  			} else {
 71203  				x.codecDecodeSelfFromArray(yyl2, d)
 71204  			}
 71205  		} else {
 71206  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 71207  		}
 71208  	}
 71209  }
 71210  
 71211  func (x *KeyringRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 71212  	var h codecSelfer100
 71213  	z, r := codec1978.GenHelperDecoder(d)
 71214  	_, _, _ = h, z, r
 71215  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 71216  	_ = yys3Slc
 71217  	var yyhl3 bool = l >= 0
 71218  	for yyj3 := 0; ; yyj3++ {
 71219  		if yyhl3 {
 71220  			if yyj3 >= l {
 71221  				break
 71222  			}
 71223  		} else {
 71224  			if r.CheckBreak() {
 71225  				break
 71226  			}
 71227  		}
 71228  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 71229  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 71230  		yys3 := string(yys3Slc)
 71231  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 71232  		switch yys3 {
 71233  		case "Key":
 71234  			if r.TryDecodeAsNil() {
 71235  				x.Key = ""
 71236  			} else {
 71237  				yyv4 := &x.Key
 71238  				yym5 := z.DecBinary()
 71239  				_ = yym5
 71240  				if false {
 71241  				} else {
 71242  					*((*string)(yyv4)) = r.DecodeString()
 71243  				}
 71244  			}
 71245  		default:
 71246  			z.DecStructFieldNotFound(-1, yys3)
 71247  		} // end switch yys3
 71248  	} // end for yyj3
 71249  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 71250  }
 71251  
 71252  func (x *KeyringRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 71253  	var h codecSelfer100
 71254  	z, r := codec1978.GenHelperDecoder(d)
 71255  	_, _, _ = h, z, r
 71256  	var yyj6 int
 71257  	var yyb6 bool
 71258  	var yyhl6 bool = l >= 0
 71259  	yyj6++
 71260  	if yyhl6 {
 71261  		yyb6 = yyj6 > l
 71262  	} else {
 71263  		yyb6 = r.CheckBreak()
 71264  	}
 71265  	if yyb6 {
 71266  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 71267  		return
 71268  	}
 71269  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 71270  	if r.TryDecodeAsNil() {
 71271  		x.Key = ""
 71272  	} else {
 71273  		yyv7 := &x.Key
 71274  		yym8 := z.DecBinary()
 71275  		_ = yym8
 71276  		if false {
 71277  		} else {
 71278  			*((*string)(yyv7)) = r.DecodeString()
 71279  		}
 71280  	}
 71281  	for {
 71282  		yyj6++
 71283  		if yyhl6 {
 71284  			yyb6 = yyj6 > l
 71285  		} else {
 71286  			yyb6 = r.CheckBreak()
 71287  		}
 71288  		if yyb6 {
 71289  			break
 71290  		}
 71291  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 71292  		z.DecStructFieldNotFound(yyj6-1, "")
 71293  	}
 71294  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 71295  }
 71296  
 71297  func (x *RecoverableError) CodecEncodeSelf(e *codec1978.Encoder) {
 71298  	var h codecSelfer100
 71299  	z, r := codec1978.GenHelperEncoder(e)
 71300  	_, _, _ = h, z, r
 71301  	if x == nil {
 71302  		r.EncodeNil()
 71303  	} else {
 71304  		yym1 := z.EncBinary()
 71305  		_ = yym1
 71306  		if false {
 71307  		} else if z.HasExtensions() && z.EncExt(x) {
 71308  		} else {
 71309  			yysep2 := !z.EncBinary()
 71310  			yy2arr2 := z.EncBasicHandle().StructToArray
 71311  			var yyq2 [2]bool
 71312  			_, _, _ = yysep2, yyq2, yy2arr2
 71313  			const yyr2 bool = false
 71314  			var yynn2 int
 71315  			if yyr2 || yy2arr2 {
 71316  				r.EncodeArrayStart(2)
 71317  			} else {
 71318  				yynn2 = 2
 71319  				for _, b := range yyq2 {
 71320  					if b {
 71321  						yynn2++
 71322  					}
 71323  				}
 71324  				r.EncodeMapStart(yynn2)
 71325  				yynn2 = 0
 71326  			}
 71327  			if yyr2 || yy2arr2 {
 71328  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 71329  				yym4 := z.EncBinary()
 71330  				_ = yym4
 71331  				if false {
 71332  				} else {
 71333  					r.EncodeString(codecSelferC_UTF8100, string(x.Err))
 71334  				}
 71335  			} else {
 71336  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 71337  				r.EncodeString(codecSelferC_UTF8100, string("Err"))
 71338  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 71339  				yym5 := z.EncBinary()
 71340  				_ = yym5
 71341  				if false {
 71342  				} else {
 71343  					r.EncodeString(codecSelferC_UTF8100, string(x.Err))
 71344  				}
 71345  			}
 71346  			if yyr2 || yy2arr2 {
 71347  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 71348  				yym7 := z.EncBinary()
 71349  				_ = yym7
 71350  				if false {
 71351  				} else {
 71352  					r.EncodeBool(bool(x.Recoverable))
 71353  				}
 71354  			} else {
 71355  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 71356  				r.EncodeString(codecSelferC_UTF8100, string("Recoverable"))
 71357  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 71358  				yym8 := z.EncBinary()
 71359  				_ = yym8
 71360  				if false {
 71361  				} else {
 71362  					r.EncodeBool(bool(x.Recoverable))
 71363  				}
 71364  			}
 71365  			if yyr2 || yy2arr2 {
 71366  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 71367  			} else {
 71368  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 71369  			}
 71370  		}
 71371  	}
 71372  }
 71373  
 71374  func (x *RecoverableError) CodecDecodeSelf(d *codec1978.Decoder) {
 71375  	var h codecSelfer100
 71376  	z, r := codec1978.GenHelperDecoder(d)
 71377  	_, _, _ = h, z, r
 71378  	yym1 := z.DecBinary()
 71379  	_ = yym1
 71380  	if false {
 71381  	} else if z.HasExtensions() && z.DecExt(x) {
 71382  	} else {
 71383  		yyct2 := r.ContainerType()
 71384  		if yyct2 == codecSelferValueTypeMap100 {
 71385  			yyl2 := r.ReadMapStart()
 71386  			if yyl2 == 0 {
 71387  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 71388  			} else {
 71389  				x.codecDecodeSelfFromMap(yyl2, d)
 71390  			}
 71391  		} else if yyct2 == codecSelferValueTypeArray100 {
 71392  			yyl2 := r.ReadArrayStart()
 71393  			if yyl2 == 0 {
 71394  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 71395  			} else {
 71396  				x.codecDecodeSelfFromArray(yyl2, d)
 71397  			}
 71398  		} else {
 71399  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 71400  		}
 71401  	}
 71402  }
 71403  
 71404  func (x *RecoverableError) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 71405  	var h codecSelfer100
 71406  	z, r := codec1978.GenHelperDecoder(d)
 71407  	_, _, _ = h, z, r
 71408  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 71409  	_ = yys3Slc
 71410  	var yyhl3 bool = l >= 0
 71411  	for yyj3 := 0; ; yyj3++ {
 71412  		if yyhl3 {
 71413  			if yyj3 >= l {
 71414  				break
 71415  			}
 71416  		} else {
 71417  			if r.CheckBreak() {
 71418  				break
 71419  			}
 71420  		}
 71421  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 71422  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 71423  		yys3 := string(yys3Slc)
 71424  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 71425  		switch yys3 {
 71426  		case "Err":
 71427  			if r.TryDecodeAsNil() {
 71428  				x.Err = ""
 71429  			} else {
 71430  				yyv4 := &x.Err
 71431  				yym5 := z.DecBinary()
 71432  				_ = yym5
 71433  				if false {
 71434  				} else {
 71435  					*((*string)(yyv4)) = r.DecodeString()
 71436  				}
 71437  			}
 71438  		case "Recoverable":
 71439  			if r.TryDecodeAsNil() {
 71440  				x.Recoverable = false
 71441  			} else {
 71442  				yyv6 := &x.Recoverable
 71443  				yym7 := z.DecBinary()
 71444  				_ = yym7
 71445  				if false {
 71446  				} else {
 71447  					*((*bool)(yyv6)) = r.DecodeBool()
 71448  				}
 71449  			}
 71450  		default:
 71451  			z.DecStructFieldNotFound(-1, yys3)
 71452  		} // end switch yys3
 71453  	} // end for yyj3
 71454  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 71455  }
 71456  
 71457  func (x *RecoverableError) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 71458  	var h codecSelfer100
 71459  	z, r := codec1978.GenHelperDecoder(d)
 71460  	_, _, _ = h, z, r
 71461  	var yyj8 int
 71462  	var yyb8 bool
 71463  	var yyhl8 bool = l >= 0
 71464  	yyj8++
 71465  	if yyhl8 {
 71466  		yyb8 = yyj8 > l
 71467  	} else {
 71468  		yyb8 = r.CheckBreak()
 71469  	}
 71470  	if yyb8 {
 71471  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 71472  		return
 71473  	}
 71474  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 71475  	if r.TryDecodeAsNil() {
 71476  		x.Err = ""
 71477  	} else {
 71478  		yyv9 := &x.Err
 71479  		yym10 := z.DecBinary()
 71480  		_ = yym10
 71481  		if false {
 71482  		} else {
 71483  			*((*string)(yyv9)) = r.DecodeString()
 71484  		}
 71485  	}
 71486  	yyj8++
 71487  	if yyhl8 {
 71488  		yyb8 = yyj8 > l
 71489  	} else {
 71490  		yyb8 = r.CheckBreak()
 71491  	}
 71492  	if yyb8 {
 71493  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 71494  		return
 71495  	}
 71496  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 71497  	if r.TryDecodeAsNil() {
 71498  		x.Recoverable = false
 71499  	} else {
 71500  		yyv11 := &x.Recoverable
 71501  		yym12 := z.DecBinary()
 71502  		_ = yym12
 71503  		if false {
 71504  		} else {
 71505  			*((*bool)(yyv11)) = r.DecodeBool()
 71506  		}
 71507  	}
 71508  	for {
 71509  		yyj8++
 71510  		if yyhl8 {
 71511  			yyb8 = yyj8 > l
 71512  		} else {
 71513  			yyb8 = r.CheckBreak()
 71514  		}
 71515  		if yyb8 {
 71516  			break
 71517  		}
 71518  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 71519  		z.DecStructFieldNotFound(yyj8-1, "")
 71520  	}
 71521  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 71522  }
 71523  
 71524  func (x *WrappedServerError) CodecEncodeSelf(e *codec1978.Encoder) {
 71525  	var h codecSelfer100
 71526  	z, r := codec1978.GenHelperEncoder(e)
 71527  	_, _, _ = h, z, r
 71528  	if x == nil {
 71529  		r.EncodeNil()
 71530  	} else {
 71531  		yym1 := z.EncBinary()
 71532  		_ = yym1
 71533  		if false {
 71534  		} else if z.HasExtensions() && z.EncExt(x) {
 71535  		} else {
 71536  			yysep2 := !z.EncBinary()
 71537  			yy2arr2 := z.EncBasicHandle().StructToArray
 71538  			var yyq2 [1]bool
 71539  			_, _, _ = yysep2, yyq2, yy2arr2
 71540  			const yyr2 bool = false
 71541  			var yynn2 int
 71542  			if yyr2 || yy2arr2 {
 71543  				r.EncodeArrayStart(1)
 71544  			} else {
 71545  				yynn2 = 1
 71546  				for _, b := range yyq2 {
 71547  					if b {
 71548  						yynn2++
 71549  					}
 71550  				}
 71551  				r.EncodeMapStart(yynn2)
 71552  				yynn2 = 0
 71553  			}
 71554  			if yyr2 || yy2arr2 {
 71555  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 71556  				if x.Err == nil {
 71557  					r.EncodeNil()
 71558  				} else {
 71559  					yym4 := z.EncBinary()
 71560  					_ = yym4
 71561  					if false {
 71562  					} else {
 71563  						z.EncFallback(x.Err)
 71564  					}
 71565  				}
 71566  			} else {
 71567  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 71568  				r.EncodeString(codecSelferC_UTF8100, string("Err"))
 71569  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 71570  				if x.Err == nil {
 71571  					r.EncodeNil()
 71572  				} else {
 71573  					yym5 := z.EncBinary()
 71574  					_ = yym5
 71575  					if false {
 71576  					} else {
 71577  						z.EncFallback(x.Err)
 71578  					}
 71579  				}
 71580  			}
 71581  			if yyr2 || yy2arr2 {
 71582  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 71583  			} else {
 71584  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 71585  			}
 71586  		}
 71587  	}
 71588  }
 71589  
 71590  func (x *WrappedServerError) CodecDecodeSelf(d *codec1978.Decoder) {
 71591  	var h codecSelfer100
 71592  	z, r := codec1978.GenHelperDecoder(d)
 71593  	_, _, _ = h, z, r
 71594  	yym1 := z.DecBinary()
 71595  	_ = yym1
 71596  	if false {
 71597  	} else if z.HasExtensions() && z.DecExt(x) {
 71598  	} else {
 71599  		yyct2 := r.ContainerType()
 71600  		if yyct2 == codecSelferValueTypeMap100 {
 71601  			yyl2 := r.ReadMapStart()
 71602  			if yyl2 == 0 {
 71603  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 71604  			} else {
 71605  				x.codecDecodeSelfFromMap(yyl2, d)
 71606  			}
 71607  		} else if yyct2 == codecSelferValueTypeArray100 {
 71608  			yyl2 := r.ReadArrayStart()
 71609  			if yyl2 == 0 {
 71610  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 71611  			} else {
 71612  				x.codecDecodeSelfFromArray(yyl2, d)
 71613  			}
 71614  		} else {
 71615  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 71616  		}
 71617  	}
 71618  }
 71619  
 71620  func (x *WrappedServerError) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 71621  	var h codecSelfer100
 71622  	z, r := codec1978.GenHelperDecoder(d)
 71623  	_, _, _ = h, z, r
 71624  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 71625  	_ = yys3Slc
 71626  	var yyhl3 bool = l >= 0
 71627  	for yyj3 := 0; ; yyj3++ {
 71628  		if yyhl3 {
 71629  			if yyj3 >= l {
 71630  				break
 71631  			}
 71632  		} else {
 71633  			if r.CheckBreak() {
 71634  				break
 71635  			}
 71636  		}
 71637  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 71638  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 71639  		yys3 := string(yys3Slc)
 71640  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 71641  		switch yys3 {
 71642  		case "Err":
 71643  			if r.TryDecodeAsNil() {
 71644  				x.Err = nil
 71645  			} else {
 71646  				yyv4 := &x.Err
 71647  				yym5 := z.DecBinary()
 71648  				_ = yym5
 71649  				if false {
 71650  				} else {
 71651  					z.DecFallback(yyv4, true)
 71652  				}
 71653  			}
 71654  		default:
 71655  			z.DecStructFieldNotFound(-1, yys3)
 71656  		} // end switch yys3
 71657  	} // end for yyj3
 71658  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 71659  }
 71660  
 71661  func (x *WrappedServerError) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 71662  	var h codecSelfer100
 71663  	z, r := codec1978.GenHelperDecoder(d)
 71664  	_, _, _ = h, z, r
 71665  	var yyj6 int
 71666  	var yyb6 bool
 71667  	var yyhl6 bool = l >= 0
 71668  	yyj6++
 71669  	if yyhl6 {
 71670  		yyb6 = yyj6 > l
 71671  	} else {
 71672  		yyb6 = r.CheckBreak()
 71673  	}
 71674  	if yyb6 {
 71675  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 71676  		return
 71677  	}
 71678  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 71679  	if r.TryDecodeAsNil() {
 71680  		x.Err = nil
 71681  	} else {
 71682  		yyv7 := &x.Err
 71683  		yym8 := z.DecBinary()
 71684  		_ = yym8
 71685  		if false {
 71686  		} else {
 71687  			z.DecFallback(yyv7, true)
 71688  		}
 71689  	}
 71690  	for {
 71691  		yyj6++
 71692  		if yyhl6 {
 71693  			yyb6 = yyj6 > l
 71694  		} else {
 71695  			yyb6 = r.CheckBreak()
 71696  		}
 71697  		if yyb6 {
 71698  			break
 71699  		}
 71700  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 71701  		z.DecStructFieldNotFound(yyj6-1, "")
 71702  	}
 71703  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 71704  }
 71705  
 71706  func (x *ACLPolicy) CodecEncodeSelf(e *codec1978.Encoder) {
 71707  	var h codecSelfer100
 71708  	z, r := codec1978.GenHelperEncoder(e)
 71709  	_, _, _ = h, z, r
 71710  	if x == nil {
 71711  		r.EncodeNil()
 71712  	} else {
 71713  		yym1 := z.EncBinary()
 71714  		_ = yym1
 71715  		if false {
 71716  		} else if z.HasExtensions() && z.EncExt(x) {
 71717  		} else {
 71718  			yysep2 := !z.EncBinary()
 71719  			yy2arr2 := z.EncBasicHandle().StructToArray
 71720  			var yyq2 [6]bool
 71721  			_, _, _ = yysep2, yyq2, yy2arr2
 71722  			const yyr2 bool = false
 71723  			var yynn2 int
 71724  			if yyr2 || yy2arr2 {
 71725  				r.EncodeArrayStart(6)
 71726  			} else {
 71727  				yynn2 = 6
 71728  				for _, b := range yyq2 {
 71729  					if b {
 71730  						yynn2++
 71731  					}
 71732  				}
 71733  				r.EncodeMapStart(yynn2)
 71734  				yynn2 = 0
 71735  			}
 71736  			if yyr2 || yy2arr2 {
 71737  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 71738  				yym4 := z.EncBinary()
 71739  				_ = yym4
 71740  				if false {
 71741  				} else {
 71742  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 71743  				}
 71744  			} else {
 71745  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 71746  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 71747  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 71748  				yym5 := z.EncBinary()
 71749  				_ = yym5
 71750  				if false {
 71751  				} else {
 71752  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 71753  				}
 71754  			}
 71755  			if yyr2 || yy2arr2 {
 71756  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 71757  				yym7 := z.EncBinary()
 71758  				_ = yym7
 71759  				if false {
 71760  				} else {
 71761  					r.EncodeString(codecSelferC_UTF8100, string(x.Description))
 71762  				}
 71763  			} else {
 71764  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 71765  				r.EncodeString(codecSelferC_UTF8100, string("Description"))
 71766  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 71767  				yym8 := z.EncBinary()
 71768  				_ = yym8
 71769  				if false {
 71770  				} else {
 71771  					r.EncodeString(codecSelferC_UTF8100, string(x.Description))
 71772  				}
 71773  			}
 71774  			if yyr2 || yy2arr2 {
 71775  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 71776  				yym10 := z.EncBinary()
 71777  				_ = yym10
 71778  				if false {
 71779  				} else {
 71780  					r.EncodeString(codecSelferC_UTF8100, string(x.Rules))
 71781  				}
 71782  			} else {
 71783  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 71784  				r.EncodeString(codecSelferC_UTF8100, string("Rules"))
 71785  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 71786  				yym11 := z.EncBinary()
 71787  				_ = yym11
 71788  				if false {
 71789  				} else {
 71790  					r.EncodeString(codecSelferC_UTF8100, string(x.Rules))
 71791  				}
 71792  			}
 71793  			if yyr2 || yy2arr2 {
 71794  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 71795  				if x.Hash == nil {
 71796  					r.EncodeNil()
 71797  				} else {
 71798  					yym13 := z.EncBinary()
 71799  					_ = yym13
 71800  					if false {
 71801  					} else {
 71802  						r.EncodeStringBytes(codecSelferC_RAW100, []byte(x.Hash))
 71803  					}
 71804  				}
 71805  			} else {
 71806  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 71807  				r.EncodeString(codecSelferC_UTF8100, string("Hash"))
 71808  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 71809  				if x.Hash == nil {
 71810  					r.EncodeNil()
 71811  				} else {
 71812  					yym14 := z.EncBinary()
 71813  					_ = yym14
 71814  					if false {
 71815  					} else {
 71816  						r.EncodeStringBytes(codecSelferC_RAW100, []byte(x.Hash))
 71817  					}
 71818  				}
 71819  			}
 71820  			if yyr2 || yy2arr2 {
 71821  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 71822  				yym16 := z.EncBinary()
 71823  				_ = yym16
 71824  				if false {
 71825  				} else {
 71826  					r.EncodeUint(uint64(x.CreateIndex))
 71827  				}
 71828  			} else {
 71829  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 71830  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 71831  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 71832  				yym17 := z.EncBinary()
 71833  				_ = yym17
 71834  				if false {
 71835  				} else {
 71836  					r.EncodeUint(uint64(x.CreateIndex))
 71837  				}
 71838  			}
 71839  			if yyr2 || yy2arr2 {
 71840  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 71841  				yym19 := z.EncBinary()
 71842  				_ = yym19
 71843  				if false {
 71844  				} else {
 71845  					r.EncodeUint(uint64(x.ModifyIndex))
 71846  				}
 71847  			} else {
 71848  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 71849  				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
 71850  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 71851  				yym20 := z.EncBinary()
 71852  				_ = yym20
 71853  				if false {
 71854  				} else {
 71855  					r.EncodeUint(uint64(x.ModifyIndex))
 71856  				}
 71857  			}
 71858  			if yyr2 || yy2arr2 {
 71859  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 71860  			} else {
 71861  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 71862  			}
 71863  		}
 71864  	}
 71865  }
 71866  
 71867  func (x *ACLPolicy) CodecDecodeSelf(d *codec1978.Decoder) {
 71868  	var h codecSelfer100
 71869  	z, r := codec1978.GenHelperDecoder(d)
 71870  	_, _, _ = h, z, r
 71871  	yym1 := z.DecBinary()
 71872  	_ = yym1
 71873  	if false {
 71874  	} else if z.HasExtensions() && z.DecExt(x) {
 71875  	} else {
 71876  		yyct2 := r.ContainerType()
 71877  		if yyct2 == codecSelferValueTypeMap100 {
 71878  			yyl2 := r.ReadMapStart()
 71879  			if yyl2 == 0 {
 71880  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 71881  			} else {
 71882  				x.codecDecodeSelfFromMap(yyl2, d)
 71883  			}
 71884  		} else if yyct2 == codecSelferValueTypeArray100 {
 71885  			yyl2 := r.ReadArrayStart()
 71886  			if yyl2 == 0 {
 71887  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 71888  			} else {
 71889  				x.codecDecodeSelfFromArray(yyl2, d)
 71890  			}
 71891  		} else {
 71892  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 71893  		}
 71894  	}
 71895  }
 71896  
 71897  func (x *ACLPolicy) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 71898  	var h codecSelfer100
 71899  	z, r := codec1978.GenHelperDecoder(d)
 71900  	_, _, _ = h, z, r
 71901  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 71902  	_ = yys3Slc
 71903  	var yyhl3 bool = l >= 0
 71904  	for yyj3 := 0; ; yyj3++ {
 71905  		if yyhl3 {
 71906  			if yyj3 >= l {
 71907  				break
 71908  			}
 71909  		} else {
 71910  			if r.CheckBreak() {
 71911  				break
 71912  			}
 71913  		}
 71914  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 71915  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 71916  		yys3 := string(yys3Slc)
 71917  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 71918  		switch yys3 {
 71919  		case "Name":
 71920  			if r.TryDecodeAsNil() {
 71921  				x.Name = ""
 71922  			} else {
 71923  				yyv4 := &x.Name
 71924  				yym5 := z.DecBinary()
 71925  				_ = yym5
 71926  				if false {
 71927  				} else {
 71928  					*((*string)(yyv4)) = r.DecodeString()
 71929  				}
 71930  			}
 71931  		case "Description":
 71932  			if r.TryDecodeAsNil() {
 71933  				x.Description = ""
 71934  			} else {
 71935  				yyv6 := &x.Description
 71936  				yym7 := z.DecBinary()
 71937  				_ = yym7
 71938  				if false {
 71939  				} else {
 71940  					*((*string)(yyv6)) = r.DecodeString()
 71941  				}
 71942  			}
 71943  		case "Rules":
 71944  			if r.TryDecodeAsNil() {
 71945  				x.Rules = ""
 71946  			} else {
 71947  				yyv8 := &x.Rules
 71948  				yym9 := z.DecBinary()
 71949  				_ = yym9
 71950  				if false {
 71951  				} else {
 71952  					*((*string)(yyv8)) = r.DecodeString()
 71953  				}
 71954  			}
 71955  		case "Hash":
 71956  			if r.TryDecodeAsNil() {
 71957  				x.Hash = nil
 71958  			} else {
 71959  				yyv10 := &x.Hash
 71960  				yym11 := z.DecBinary()
 71961  				_ = yym11
 71962  				if false {
 71963  				} else {
 71964  					*yyv10 = r.DecodeBytes(*(*[]byte)(yyv10), false, false)
 71965  				}
 71966  			}
 71967  		case "CreateIndex":
 71968  			if r.TryDecodeAsNil() {
 71969  				x.CreateIndex = 0
 71970  			} else {
 71971  				yyv12 := &x.CreateIndex
 71972  				yym13 := z.DecBinary()
 71973  				_ = yym13
 71974  				if false {
 71975  				} else {
 71976  					*((*uint64)(yyv12)) = uint64(r.DecodeUint(64))
 71977  				}
 71978  			}
 71979  		case "ModifyIndex":
 71980  			if r.TryDecodeAsNil() {
 71981  				x.ModifyIndex = 0
 71982  			} else {
 71983  				yyv14 := &x.ModifyIndex
 71984  				yym15 := z.DecBinary()
 71985  				_ = yym15
 71986  				if false {
 71987  				} else {
 71988  					*((*uint64)(yyv14)) = uint64(r.DecodeUint(64))
 71989  				}
 71990  			}
 71991  		default:
 71992  			z.DecStructFieldNotFound(-1, yys3)
 71993  		} // end switch yys3
 71994  	} // end for yyj3
 71995  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 71996  }
 71997  
 71998  func (x *ACLPolicy) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 71999  	var h codecSelfer100
 72000  	z, r := codec1978.GenHelperDecoder(d)
 72001  	_, _, _ = h, z, r
 72002  	var yyj16 int
 72003  	var yyb16 bool
 72004  	var yyhl16 bool = l >= 0
 72005  	yyj16++
 72006  	if yyhl16 {
 72007  		yyb16 = yyj16 > l
 72008  	} else {
 72009  		yyb16 = r.CheckBreak()
 72010  	}
 72011  	if yyb16 {
 72012  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72013  		return
 72014  	}
 72015  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72016  	if r.TryDecodeAsNil() {
 72017  		x.Name = ""
 72018  	} else {
 72019  		yyv17 := &x.Name
 72020  		yym18 := z.DecBinary()
 72021  		_ = yym18
 72022  		if false {
 72023  		} else {
 72024  			*((*string)(yyv17)) = r.DecodeString()
 72025  		}
 72026  	}
 72027  	yyj16++
 72028  	if yyhl16 {
 72029  		yyb16 = yyj16 > l
 72030  	} else {
 72031  		yyb16 = r.CheckBreak()
 72032  	}
 72033  	if yyb16 {
 72034  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72035  		return
 72036  	}
 72037  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72038  	if r.TryDecodeAsNil() {
 72039  		x.Description = ""
 72040  	} else {
 72041  		yyv19 := &x.Description
 72042  		yym20 := z.DecBinary()
 72043  		_ = yym20
 72044  		if false {
 72045  		} else {
 72046  			*((*string)(yyv19)) = r.DecodeString()
 72047  		}
 72048  	}
 72049  	yyj16++
 72050  	if yyhl16 {
 72051  		yyb16 = yyj16 > l
 72052  	} else {
 72053  		yyb16 = r.CheckBreak()
 72054  	}
 72055  	if yyb16 {
 72056  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72057  		return
 72058  	}
 72059  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72060  	if r.TryDecodeAsNil() {
 72061  		x.Rules = ""
 72062  	} else {
 72063  		yyv21 := &x.Rules
 72064  		yym22 := z.DecBinary()
 72065  		_ = yym22
 72066  		if false {
 72067  		} else {
 72068  			*((*string)(yyv21)) = r.DecodeString()
 72069  		}
 72070  	}
 72071  	yyj16++
 72072  	if yyhl16 {
 72073  		yyb16 = yyj16 > l
 72074  	} else {
 72075  		yyb16 = r.CheckBreak()
 72076  	}
 72077  	if yyb16 {
 72078  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72079  		return
 72080  	}
 72081  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72082  	if r.TryDecodeAsNil() {
 72083  		x.Hash = nil
 72084  	} else {
 72085  		yyv23 := &x.Hash
 72086  		yym24 := z.DecBinary()
 72087  		_ = yym24
 72088  		if false {
 72089  		} else {
 72090  			*yyv23 = r.DecodeBytes(*(*[]byte)(yyv23), false, false)
 72091  		}
 72092  	}
 72093  	yyj16++
 72094  	if yyhl16 {
 72095  		yyb16 = yyj16 > l
 72096  	} else {
 72097  		yyb16 = r.CheckBreak()
 72098  	}
 72099  	if yyb16 {
 72100  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72101  		return
 72102  	}
 72103  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72104  	if r.TryDecodeAsNil() {
 72105  		x.CreateIndex = 0
 72106  	} else {
 72107  		yyv25 := &x.CreateIndex
 72108  		yym26 := z.DecBinary()
 72109  		_ = yym26
 72110  		if false {
 72111  		} else {
 72112  			*((*uint64)(yyv25)) = uint64(r.DecodeUint(64))
 72113  		}
 72114  	}
 72115  	yyj16++
 72116  	if yyhl16 {
 72117  		yyb16 = yyj16 > l
 72118  	} else {
 72119  		yyb16 = r.CheckBreak()
 72120  	}
 72121  	if yyb16 {
 72122  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72123  		return
 72124  	}
 72125  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72126  	if r.TryDecodeAsNil() {
 72127  		x.ModifyIndex = 0
 72128  	} else {
 72129  		yyv27 := &x.ModifyIndex
 72130  		yym28 := z.DecBinary()
 72131  		_ = yym28
 72132  		if false {
 72133  		} else {
 72134  			*((*uint64)(yyv27)) = uint64(r.DecodeUint(64))
 72135  		}
 72136  	}
 72137  	for {
 72138  		yyj16++
 72139  		if yyhl16 {
 72140  			yyb16 = yyj16 > l
 72141  		} else {
 72142  			yyb16 = r.CheckBreak()
 72143  		}
 72144  		if yyb16 {
 72145  			break
 72146  		}
 72147  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72148  		z.DecStructFieldNotFound(yyj16-1, "")
 72149  	}
 72150  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72151  }
 72152  
 72153  func (x *ACLPolicyListStub) CodecEncodeSelf(e *codec1978.Encoder) {
 72154  	var h codecSelfer100
 72155  	z, r := codec1978.GenHelperEncoder(e)
 72156  	_, _, _ = h, z, r
 72157  	if x == nil {
 72158  		r.EncodeNil()
 72159  	} else {
 72160  		yym1 := z.EncBinary()
 72161  		_ = yym1
 72162  		if false {
 72163  		} else if z.HasExtensions() && z.EncExt(x) {
 72164  		} else {
 72165  			yysep2 := !z.EncBinary()
 72166  			yy2arr2 := z.EncBasicHandle().StructToArray
 72167  			var yyq2 [5]bool
 72168  			_, _, _ = yysep2, yyq2, yy2arr2
 72169  			const yyr2 bool = false
 72170  			var yynn2 int
 72171  			if yyr2 || yy2arr2 {
 72172  				r.EncodeArrayStart(5)
 72173  			} else {
 72174  				yynn2 = 5
 72175  				for _, b := range yyq2 {
 72176  					if b {
 72177  						yynn2++
 72178  					}
 72179  				}
 72180  				r.EncodeMapStart(yynn2)
 72181  				yynn2 = 0
 72182  			}
 72183  			if yyr2 || yy2arr2 {
 72184  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 72185  				yym4 := z.EncBinary()
 72186  				_ = yym4
 72187  				if false {
 72188  				} else {
 72189  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 72190  				}
 72191  			} else {
 72192  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 72193  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 72194  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 72195  				yym5 := z.EncBinary()
 72196  				_ = yym5
 72197  				if false {
 72198  				} else {
 72199  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 72200  				}
 72201  			}
 72202  			if yyr2 || yy2arr2 {
 72203  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 72204  				yym7 := z.EncBinary()
 72205  				_ = yym7
 72206  				if false {
 72207  				} else {
 72208  					r.EncodeString(codecSelferC_UTF8100, string(x.Description))
 72209  				}
 72210  			} else {
 72211  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 72212  				r.EncodeString(codecSelferC_UTF8100, string("Description"))
 72213  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 72214  				yym8 := z.EncBinary()
 72215  				_ = yym8
 72216  				if false {
 72217  				} else {
 72218  					r.EncodeString(codecSelferC_UTF8100, string(x.Description))
 72219  				}
 72220  			}
 72221  			if yyr2 || yy2arr2 {
 72222  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 72223  				if x.Hash == nil {
 72224  					r.EncodeNil()
 72225  				} else {
 72226  					yym10 := z.EncBinary()
 72227  					_ = yym10
 72228  					if false {
 72229  					} else {
 72230  						r.EncodeStringBytes(codecSelferC_RAW100, []byte(x.Hash))
 72231  					}
 72232  				}
 72233  			} else {
 72234  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 72235  				r.EncodeString(codecSelferC_UTF8100, string("Hash"))
 72236  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 72237  				if x.Hash == nil {
 72238  					r.EncodeNil()
 72239  				} else {
 72240  					yym11 := z.EncBinary()
 72241  					_ = yym11
 72242  					if false {
 72243  					} else {
 72244  						r.EncodeStringBytes(codecSelferC_RAW100, []byte(x.Hash))
 72245  					}
 72246  				}
 72247  			}
 72248  			if yyr2 || yy2arr2 {
 72249  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 72250  				yym13 := z.EncBinary()
 72251  				_ = yym13
 72252  				if false {
 72253  				} else {
 72254  					r.EncodeUint(uint64(x.CreateIndex))
 72255  				}
 72256  			} else {
 72257  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 72258  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 72259  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 72260  				yym14 := z.EncBinary()
 72261  				_ = yym14
 72262  				if false {
 72263  				} else {
 72264  					r.EncodeUint(uint64(x.CreateIndex))
 72265  				}
 72266  			}
 72267  			if yyr2 || yy2arr2 {
 72268  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 72269  				yym16 := z.EncBinary()
 72270  				_ = yym16
 72271  				if false {
 72272  				} else {
 72273  					r.EncodeUint(uint64(x.ModifyIndex))
 72274  				}
 72275  			} else {
 72276  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 72277  				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
 72278  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 72279  				yym17 := z.EncBinary()
 72280  				_ = yym17
 72281  				if false {
 72282  				} else {
 72283  					r.EncodeUint(uint64(x.ModifyIndex))
 72284  				}
 72285  			}
 72286  			if yyr2 || yy2arr2 {
 72287  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 72288  			} else {
 72289  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 72290  			}
 72291  		}
 72292  	}
 72293  }
 72294  
 72295  func (x *ACLPolicyListStub) CodecDecodeSelf(d *codec1978.Decoder) {
 72296  	var h codecSelfer100
 72297  	z, r := codec1978.GenHelperDecoder(d)
 72298  	_, _, _ = h, z, r
 72299  	yym1 := z.DecBinary()
 72300  	_ = yym1
 72301  	if false {
 72302  	} else if z.HasExtensions() && z.DecExt(x) {
 72303  	} else {
 72304  		yyct2 := r.ContainerType()
 72305  		if yyct2 == codecSelferValueTypeMap100 {
 72306  			yyl2 := r.ReadMapStart()
 72307  			if yyl2 == 0 {
 72308  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 72309  			} else {
 72310  				x.codecDecodeSelfFromMap(yyl2, d)
 72311  			}
 72312  		} else if yyct2 == codecSelferValueTypeArray100 {
 72313  			yyl2 := r.ReadArrayStart()
 72314  			if yyl2 == 0 {
 72315  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72316  			} else {
 72317  				x.codecDecodeSelfFromArray(yyl2, d)
 72318  			}
 72319  		} else {
 72320  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 72321  		}
 72322  	}
 72323  }
 72324  
 72325  func (x *ACLPolicyListStub) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 72326  	var h codecSelfer100
 72327  	z, r := codec1978.GenHelperDecoder(d)
 72328  	_, _, _ = h, z, r
 72329  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 72330  	_ = yys3Slc
 72331  	var yyhl3 bool = l >= 0
 72332  	for yyj3 := 0; ; yyj3++ {
 72333  		if yyhl3 {
 72334  			if yyj3 >= l {
 72335  				break
 72336  			}
 72337  		} else {
 72338  			if r.CheckBreak() {
 72339  				break
 72340  			}
 72341  		}
 72342  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 72343  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 72344  		yys3 := string(yys3Slc)
 72345  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 72346  		switch yys3 {
 72347  		case "Name":
 72348  			if r.TryDecodeAsNil() {
 72349  				x.Name = ""
 72350  			} else {
 72351  				yyv4 := &x.Name
 72352  				yym5 := z.DecBinary()
 72353  				_ = yym5
 72354  				if false {
 72355  				} else {
 72356  					*((*string)(yyv4)) = r.DecodeString()
 72357  				}
 72358  			}
 72359  		case "Description":
 72360  			if r.TryDecodeAsNil() {
 72361  				x.Description = ""
 72362  			} else {
 72363  				yyv6 := &x.Description
 72364  				yym7 := z.DecBinary()
 72365  				_ = yym7
 72366  				if false {
 72367  				} else {
 72368  					*((*string)(yyv6)) = r.DecodeString()
 72369  				}
 72370  			}
 72371  		case "Hash":
 72372  			if r.TryDecodeAsNil() {
 72373  				x.Hash = nil
 72374  			} else {
 72375  				yyv8 := &x.Hash
 72376  				yym9 := z.DecBinary()
 72377  				_ = yym9
 72378  				if false {
 72379  				} else {
 72380  					*yyv8 = r.DecodeBytes(*(*[]byte)(yyv8), false, false)
 72381  				}
 72382  			}
 72383  		case "CreateIndex":
 72384  			if r.TryDecodeAsNil() {
 72385  				x.CreateIndex = 0
 72386  			} else {
 72387  				yyv10 := &x.CreateIndex
 72388  				yym11 := z.DecBinary()
 72389  				_ = yym11
 72390  				if false {
 72391  				} else {
 72392  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 72393  				}
 72394  			}
 72395  		case "ModifyIndex":
 72396  			if r.TryDecodeAsNil() {
 72397  				x.ModifyIndex = 0
 72398  			} else {
 72399  				yyv12 := &x.ModifyIndex
 72400  				yym13 := z.DecBinary()
 72401  				_ = yym13
 72402  				if false {
 72403  				} else {
 72404  					*((*uint64)(yyv12)) = uint64(r.DecodeUint(64))
 72405  				}
 72406  			}
 72407  		default:
 72408  			z.DecStructFieldNotFound(-1, yys3)
 72409  		} // end switch yys3
 72410  	} // end for yyj3
 72411  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 72412  }
 72413  
 72414  func (x *ACLPolicyListStub) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 72415  	var h codecSelfer100
 72416  	z, r := codec1978.GenHelperDecoder(d)
 72417  	_, _, _ = h, z, r
 72418  	var yyj14 int
 72419  	var yyb14 bool
 72420  	var yyhl14 bool = l >= 0
 72421  	yyj14++
 72422  	if yyhl14 {
 72423  		yyb14 = yyj14 > l
 72424  	} else {
 72425  		yyb14 = r.CheckBreak()
 72426  	}
 72427  	if yyb14 {
 72428  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72429  		return
 72430  	}
 72431  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72432  	if r.TryDecodeAsNil() {
 72433  		x.Name = ""
 72434  	} else {
 72435  		yyv15 := &x.Name
 72436  		yym16 := z.DecBinary()
 72437  		_ = yym16
 72438  		if false {
 72439  		} else {
 72440  			*((*string)(yyv15)) = r.DecodeString()
 72441  		}
 72442  	}
 72443  	yyj14++
 72444  	if yyhl14 {
 72445  		yyb14 = yyj14 > l
 72446  	} else {
 72447  		yyb14 = r.CheckBreak()
 72448  	}
 72449  	if yyb14 {
 72450  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72451  		return
 72452  	}
 72453  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72454  	if r.TryDecodeAsNil() {
 72455  		x.Description = ""
 72456  	} else {
 72457  		yyv17 := &x.Description
 72458  		yym18 := z.DecBinary()
 72459  		_ = yym18
 72460  		if false {
 72461  		} else {
 72462  			*((*string)(yyv17)) = r.DecodeString()
 72463  		}
 72464  	}
 72465  	yyj14++
 72466  	if yyhl14 {
 72467  		yyb14 = yyj14 > l
 72468  	} else {
 72469  		yyb14 = r.CheckBreak()
 72470  	}
 72471  	if yyb14 {
 72472  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72473  		return
 72474  	}
 72475  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72476  	if r.TryDecodeAsNil() {
 72477  		x.Hash = nil
 72478  	} else {
 72479  		yyv19 := &x.Hash
 72480  		yym20 := z.DecBinary()
 72481  		_ = yym20
 72482  		if false {
 72483  		} else {
 72484  			*yyv19 = r.DecodeBytes(*(*[]byte)(yyv19), false, false)
 72485  		}
 72486  	}
 72487  	yyj14++
 72488  	if yyhl14 {
 72489  		yyb14 = yyj14 > l
 72490  	} else {
 72491  		yyb14 = r.CheckBreak()
 72492  	}
 72493  	if yyb14 {
 72494  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72495  		return
 72496  	}
 72497  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72498  	if r.TryDecodeAsNil() {
 72499  		x.CreateIndex = 0
 72500  	} else {
 72501  		yyv21 := &x.CreateIndex
 72502  		yym22 := z.DecBinary()
 72503  		_ = yym22
 72504  		if false {
 72505  		} else {
 72506  			*((*uint64)(yyv21)) = uint64(r.DecodeUint(64))
 72507  		}
 72508  	}
 72509  	yyj14++
 72510  	if yyhl14 {
 72511  		yyb14 = yyj14 > l
 72512  	} else {
 72513  		yyb14 = r.CheckBreak()
 72514  	}
 72515  	if yyb14 {
 72516  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72517  		return
 72518  	}
 72519  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72520  	if r.TryDecodeAsNil() {
 72521  		x.ModifyIndex = 0
 72522  	} else {
 72523  		yyv23 := &x.ModifyIndex
 72524  		yym24 := z.DecBinary()
 72525  		_ = yym24
 72526  		if false {
 72527  		} else {
 72528  			*((*uint64)(yyv23)) = uint64(r.DecodeUint(64))
 72529  		}
 72530  	}
 72531  	for {
 72532  		yyj14++
 72533  		if yyhl14 {
 72534  			yyb14 = yyj14 > l
 72535  		} else {
 72536  			yyb14 = r.CheckBreak()
 72537  		}
 72538  		if yyb14 {
 72539  			break
 72540  		}
 72541  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72542  		z.DecStructFieldNotFound(yyj14-1, "")
 72543  	}
 72544  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72545  }
 72546  
 72547  func (x *ACLPolicyListRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 72548  	var h codecSelfer100
 72549  	z, r := codec1978.GenHelperEncoder(e)
 72550  	_, _, _ = h, z, r
 72551  	if x == nil {
 72552  		r.EncodeNil()
 72553  	} else {
 72554  		yym1 := z.EncBinary()
 72555  		_ = yym1
 72556  		if false {
 72557  		} else if z.HasExtensions() && z.EncExt(x) {
 72558  		} else {
 72559  			yysep2 := !z.EncBinary()
 72560  			yy2arr2 := z.EncBasicHandle().StructToArray
 72561  			var yyq2 [8]bool
 72562  			_, _, _ = yysep2, yyq2, yy2arr2
 72563  			const yyr2 bool = false
 72564  			var yynn2 int
 72565  			if yyr2 || yy2arr2 {
 72566  				r.EncodeArrayStart(8)
 72567  			} else {
 72568  				yynn2 = 8
 72569  				for _, b := range yyq2 {
 72570  					if b {
 72571  						yynn2++
 72572  					}
 72573  				}
 72574  				r.EncodeMapStart(yynn2)
 72575  				yynn2 = 0
 72576  			}
 72577  			if yyr2 || yy2arr2 {
 72578  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 72579  				yym4 := z.EncBinary()
 72580  				_ = yym4
 72581  				if false {
 72582  				} else {
 72583  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 72584  				}
 72585  			} else {
 72586  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 72587  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 72588  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 72589  				yym5 := z.EncBinary()
 72590  				_ = yym5
 72591  				if false {
 72592  				} else {
 72593  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 72594  				}
 72595  			}
 72596  			if yyr2 || yy2arr2 {
 72597  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 72598  				yym7 := z.EncBinary()
 72599  				_ = yym7
 72600  				if false {
 72601  				} else {
 72602  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 72603  				}
 72604  			} else {
 72605  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 72606  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 72607  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 72608  				yym8 := z.EncBinary()
 72609  				_ = yym8
 72610  				if false {
 72611  				} else {
 72612  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 72613  				}
 72614  			}
 72615  			if yyr2 || yy2arr2 {
 72616  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 72617  				yym10 := z.EncBinary()
 72618  				_ = yym10
 72619  				if false {
 72620  				} else {
 72621  					r.EncodeUint(uint64(x.MinQueryIndex))
 72622  				}
 72623  			} else {
 72624  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 72625  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 72626  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 72627  				yym11 := z.EncBinary()
 72628  				_ = yym11
 72629  				if false {
 72630  				} else {
 72631  					r.EncodeUint(uint64(x.MinQueryIndex))
 72632  				}
 72633  			}
 72634  			if yyr2 || yy2arr2 {
 72635  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 72636  				yym13 := z.EncBinary()
 72637  				_ = yym13
 72638  				if false {
 72639  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 72640  				} else {
 72641  					r.EncodeInt(int64(x.MaxQueryTime))
 72642  				}
 72643  			} else {
 72644  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 72645  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 72646  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 72647  				yym14 := z.EncBinary()
 72648  				_ = yym14
 72649  				if false {
 72650  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 72651  				} else {
 72652  					r.EncodeInt(int64(x.MaxQueryTime))
 72653  				}
 72654  			}
 72655  			if yyr2 || yy2arr2 {
 72656  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 72657  				yym16 := z.EncBinary()
 72658  				_ = yym16
 72659  				if false {
 72660  				} else {
 72661  					r.EncodeBool(bool(x.AllowStale))
 72662  				}
 72663  			} else {
 72664  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 72665  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 72666  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 72667  				yym17 := z.EncBinary()
 72668  				_ = yym17
 72669  				if false {
 72670  				} else {
 72671  					r.EncodeBool(bool(x.AllowStale))
 72672  				}
 72673  			}
 72674  			if yyr2 || yy2arr2 {
 72675  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 72676  				yym19 := z.EncBinary()
 72677  				_ = yym19
 72678  				if false {
 72679  				} else {
 72680  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 72681  				}
 72682  			} else {
 72683  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 72684  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 72685  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 72686  				yym20 := z.EncBinary()
 72687  				_ = yym20
 72688  				if false {
 72689  				} else {
 72690  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 72691  				}
 72692  			}
 72693  			if yyr2 || yy2arr2 {
 72694  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 72695  				yym22 := z.EncBinary()
 72696  				_ = yym22
 72697  				if false {
 72698  				} else {
 72699  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 72700  				}
 72701  			} else {
 72702  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 72703  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 72704  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 72705  				yym23 := z.EncBinary()
 72706  				_ = yym23
 72707  				if false {
 72708  				} else {
 72709  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 72710  				}
 72711  			}
 72712  			if yyr2 || yy2arr2 {
 72713  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 72714  				yym25 := z.EncBinary()
 72715  				_ = yym25
 72716  				if false {
 72717  				} else {
 72718  					r.EncodeBool(bool(x.Forwarded))
 72719  				}
 72720  			} else {
 72721  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 72722  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 72723  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 72724  				yym26 := z.EncBinary()
 72725  				_ = yym26
 72726  				if false {
 72727  				} else {
 72728  					r.EncodeBool(bool(x.Forwarded))
 72729  				}
 72730  			}
 72731  			if yyr2 || yy2arr2 {
 72732  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 72733  			} else {
 72734  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 72735  			}
 72736  		}
 72737  	}
 72738  }
 72739  
 72740  func (x *ACLPolicyListRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 72741  	var h codecSelfer100
 72742  	z, r := codec1978.GenHelperDecoder(d)
 72743  	_, _, _ = h, z, r
 72744  	yym1 := z.DecBinary()
 72745  	_ = yym1
 72746  	if false {
 72747  	} else if z.HasExtensions() && z.DecExt(x) {
 72748  	} else {
 72749  		yyct2 := r.ContainerType()
 72750  		if yyct2 == codecSelferValueTypeMap100 {
 72751  			yyl2 := r.ReadMapStart()
 72752  			if yyl2 == 0 {
 72753  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 72754  			} else {
 72755  				x.codecDecodeSelfFromMap(yyl2, d)
 72756  			}
 72757  		} else if yyct2 == codecSelferValueTypeArray100 {
 72758  			yyl2 := r.ReadArrayStart()
 72759  			if yyl2 == 0 {
 72760  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72761  			} else {
 72762  				x.codecDecodeSelfFromArray(yyl2, d)
 72763  			}
 72764  		} else {
 72765  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 72766  		}
 72767  	}
 72768  }
 72769  
 72770  func (x *ACLPolicyListRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 72771  	var h codecSelfer100
 72772  	z, r := codec1978.GenHelperDecoder(d)
 72773  	_, _, _ = h, z, r
 72774  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 72775  	_ = yys3Slc
 72776  	var yyhl3 bool = l >= 0
 72777  	for yyj3 := 0; ; yyj3++ {
 72778  		if yyhl3 {
 72779  			if yyj3 >= l {
 72780  				break
 72781  			}
 72782  		} else {
 72783  			if r.CheckBreak() {
 72784  				break
 72785  			}
 72786  		}
 72787  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 72788  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 72789  		yys3 := string(yys3Slc)
 72790  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 72791  		switch yys3 {
 72792  		case "Region":
 72793  			if r.TryDecodeAsNil() {
 72794  				x.Region = ""
 72795  			} else {
 72796  				yyv4 := &x.Region
 72797  				yym5 := z.DecBinary()
 72798  				_ = yym5
 72799  				if false {
 72800  				} else {
 72801  					*((*string)(yyv4)) = r.DecodeString()
 72802  				}
 72803  			}
 72804  		case "Namespace":
 72805  			if r.TryDecodeAsNil() {
 72806  				x.Namespace = ""
 72807  			} else {
 72808  				yyv6 := &x.Namespace
 72809  				yym7 := z.DecBinary()
 72810  				_ = yym7
 72811  				if false {
 72812  				} else {
 72813  					*((*string)(yyv6)) = r.DecodeString()
 72814  				}
 72815  			}
 72816  		case "MinQueryIndex":
 72817  			if r.TryDecodeAsNil() {
 72818  				x.MinQueryIndex = 0
 72819  			} else {
 72820  				yyv8 := &x.MinQueryIndex
 72821  				yym9 := z.DecBinary()
 72822  				_ = yym9
 72823  				if false {
 72824  				} else {
 72825  					*((*uint64)(yyv8)) = uint64(r.DecodeUint(64))
 72826  				}
 72827  			}
 72828  		case "MaxQueryTime":
 72829  			if r.TryDecodeAsNil() {
 72830  				x.MaxQueryTime = 0
 72831  			} else {
 72832  				yyv10 := &x.MaxQueryTime
 72833  				yym11 := z.DecBinary()
 72834  				_ = yym11
 72835  				if false {
 72836  				} else if z.HasExtensions() && z.DecExt(yyv10) {
 72837  				} else {
 72838  					*((*int64)(yyv10)) = int64(r.DecodeInt(64))
 72839  				}
 72840  			}
 72841  		case "AllowStale":
 72842  			if r.TryDecodeAsNil() {
 72843  				x.AllowStale = false
 72844  			} else {
 72845  				yyv12 := &x.AllowStale
 72846  				yym13 := z.DecBinary()
 72847  				_ = yym13
 72848  				if false {
 72849  				} else {
 72850  					*((*bool)(yyv12)) = r.DecodeBool()
 72851  				}
 72852  			}
 72853  		case "Prefix":
 72854  			if r.TryDecodeAsNil() {
 72855  				x.Prefix = ""
 72856  			} else {
 72857  				yyv14 := &x.Prefix
 72858  				yym15 := z.DecBinary()
 72859  				_ = yym15
 72860  				if false {
 72861  				} else {
 72862  					*((*string)(yyv14)) = r.DecodeString()
 72863  				}
 72864  			}
 72865  		case "AuthToken":
 72866  			if r.TryDecodeAsNil() {
 72867  				x.AuthToken = ""
 72868  			} else {
 72869  				yyv16 := &x.AuthToken
 72870  				yym17 := z.DecBinary()
 72871  				_ = yym17
 72872  				if false {
 72873  				} else {
 72874  					*((*string)(yyv16)) = r.DecodeString()
 72875  				}
 72876  			}
 72877  		case "Forwarded":
 72878  			if r.TryDecodeAsNil() {
 72879  				x.Forwarded = false
 72880  			} else {
 72881  				yyv18 := &x.Forwarded
 72882  				yym19 := z.DecBinary()
 72883  				_ = yym19
 72884  				if false {
 72885  				} else {
 72886  					*((*bool)(yyv18)) = r.DecodeBool()
 72887  				}
 72888  			}
 72889  		default:
 72890  			z.DecStructFieldNotFound(-1, yys3)
 72891  		} // end switch yys3
 72892  	} // end for yyj3
 72893  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 72894  }
 72895  
 72896  func (x *ACLPolicyListRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 72897  	var h codecSelfer100
 72898  	z, r := codec1978.GenHelperDecoder(d)
 72899  	_, _, _ = h, z, r
 72900  	var yyj20 int
 72901  	var yyb20 bool
 72902  	var yyhl20 bool = l >= 0
 72903  	yyj20++
 72904  	if yyhl20 {
 72905  		yyb20 = yyj20 > l
 72906  	} else {
 72907  		yyb20 = r.CheckBreak()
 72908  	}
 72909  	if yyb20 {
 72910  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72911  		return
 72912  	}
 72913  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72914  	if r.TryDecodeAsNil() {
 72915  		x.Region = ""
 72916  	} else {
 72917  		yyv21 := &x.Region
 72918  		yym22 := z.DecBinary()
 72919  		_ = yym22
 72920  		if false {
 72921  		} else {
 72922  			*((*string)(yyv21)) = r.DecodeString()
 72923  		}
 72924  	}
 72925  	yyj20++
 72926  	if yyhl20 {
 72927  		yyb20 = yyj20 > l
 72928  	} else {
 72929  		yyb20 = r.CheckBreak()
 72930  	}
 72931  	if yyb20 {
 72932  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72933  		return
 72934  	}
 72935  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72936  	if r.TryDecodeAsNil() {
 72937  		x.Namespace = ""
 72938  	} else {
 72939  		yyv23 := &x.Namespace
 72940  		yym24 := z.DecBinary()
 72941  		_ = yym24
 72942  		if false {
 72943  		} else {
 72944  			*((*string)(yyv23)) = r.DecodeString()
 72945  		}
 72946  	}
 72947  	yyj20++
 72948  	if yyhl20 {
 72949  		yyb20 = yyj20 > l
 72950  	} else {
 72951  		yyb20 = r.CheckBreak()
 72952  	}
 72953  	if yyb20 {
 72954  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72955  		return
 72956  	}
 72957  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72958  	if r.TryDecodeAsNil() {
 72959  		x.MinQueryIndex = 0
 72960  	} else {
 72961  		yyv25 := &x.MinQueryIndex
 72962  		yym26 := z.DecBinary()
 72963  		_ = yym26
 72964  		if false {
 72965  		} else {
 72966  			*((*uint64)(yyv25)) = uint64(r.DecodeUint(64))
 72967  		}
 72968  	}
 72969  	yyj20++
 72970  	if yyhl20 {
 72971  		yyb20 = yyj20 > l
 72972  	} else {
 72973  		yyb20 = r.CheckBreak()
 72974  	}
 72975  	if yyb20 {
 72976  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 72977  		return
 72978  	}
 72979  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 72980  	if r.TryDecodeAsNil() {
 72981  		x.MaxQueryTime = 0
 72982  	} else {
 72983  		yyv27 := &x.MaxQueryTime
 72984  		yym28 := z.DecBinary()
 72985  		_ = yym28
 72986  		if false {
 72987  		} else if z.HasExtensions() && z.DecExt(yyv27) {
 72988  		} else {
 72989  			*((*int64)(yyv27)) = int64(r.DecodeInt(64))
 72990  		}
 72991  	}
 72992  	yyj20++
 72993  	if yyhl20 {
 72994  		yyb20 = yyj20 > l
 72995  	} else {
 72996  		yyb20 = r.CheckBreak()
 72997  	}
 72998  	if yyb20 {
 72999  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73000  		return
 73001  	}
 73002  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 73003  	if r.TryDecodeAsNil() {
 73004  		x.AllowStale = false
 73005  	} else {
 73006  		yyv29 := &x.AllowStale
 73007  		yym30 := z.DecBinary()
 73008  		_ = yym30
 73009  		if false {
 73010  		} else {
 73011  			*((*bool)(yyv29)) = r.DecodeBool()
 73012  		}
 73013  	}
 73014  	yyj20++
 73015  	if yyhl20 {
 73016  		yyb20 = yyj20 > l
 73017  	} else {
 73018  		yyb20 = r.CheckBreak()
 73019  	}
 73020  	if yyb20 {
 73021  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73022  		return
 73023  	}
 73024  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 73025  	if r.TryDecodeAsNil() {
 73026  		x.Prefix = ""
 73027  	} else {
 73028  		yyv31 := &x.Prefix
 73029  		yym32 := z.DecBinary()
 73030  		_ = yym32
 73031  		if false {
 73032  		} else {
 73033  			*((*string)(yyv31)) = r.DecodeString()
 73034  		}
 73035  	}
 73036  	yyj20++
 73037  	if yyhl20 {
 73038  		yyb20 = yyj20 > l
 73039  	} else {
 73040  		yyb20 = r.CheckBreak()
 73041  	}
 73042  	if yyb20 {
 73043  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73044  		return
 73045  	}
 73046  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 73047  	if r.TryDecodeAsNil() {
 73048  		x.AuthToken = ""
 73049  	} else {
 73050  		yyv33 := &x.AuthToken
 73051  		yym34 := z.DecBinary()
 73052  		_ = yym34
 73053  		if false {
 73054  		} else {
 73055  			*((*string)(yyv33)) = r.DecodeString()
 73056  		}
 73057  	}
 73058  	yyj20++
 73059  	if yyhl20 {
 73060  		yyb20 = yyj20 > l
 73061  	} else {
 73062  		yyb20 = r.CheckBreak()
 73063  	}
 73064  	if yyb20 {
 73065  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73066  		return
 73067  	}
 73068  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 73069  	if r.TryDecodeAsNil() {
 73070  		x.Forwarded = false
 73071  	} else {
 73072  		yyv35 := &x.Forwarded
 73073  		yym36 := z.DecBinary()
 73074  		_ = yym36
 73075  		if false {
 73076  		} else {
 73077  			*((*bool)(yyv35)) = r.DecodeBool()
 73078  		}
 73079  	}
 73080  	for {
 73081  		yyj20++
 73082  		if yyhl20 {
 73083  			yyb20 = yyj20 > l
 73084  		} else {
 73085  			yyb20 = r.CheckBreak()
 73086  		}
 73087  		if yyb20 {
 73088  			break
 73089  		}
 73090  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 73091  		z.DecStructFieldNotFound(yyj20-1, "")
 73092  	}
 73093  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73094  }
 73095  
 73096  func (x *ACLPolicySpecificRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 73097  	var h codecSelfer100
 73098  	z, r := codec1978.GenHelperEncoder(e)
 73099  	_, _, _ = h, z, r
 73100  	if x == nil {
 73101  		r.EncodeNil()
 73102  	} else {
 73103  		yym1 := z.EncBinary()
 73104  		_ = yym1
 73105  		if false {
 73106  		} else if z.HasExtensions() && z.EncExt(x) {
 73107  		} else {
 73108  			yysep2 := !z.EncBinary()
 73109  			yy2arr2 := z.EncBasicHandle().StructToArray
 73110  			var yyq2 [9]bool
 73111  			_, _, _ = yysep2, yyq2, yy2arr2
 73112  			const yyr2 bool = false
 73113  			var yynn2 int
 73114  			if yyr2 || yy2arr2 {
 73115  				r.EncodeArrayStart(9)
 73116  			} else {
 73117  				yynn2 = 9
 73118  				for _, b := range yyq2 {
 73119  					if b {
 73120  						yynn2++
 73121  					}
 73122  				}
 73123  				r.EncodeMapStart(yynn2)
 73124  				yynn2 = 0
 73125  			}
 73126  			if yyr2 || yy2arr2 {
 73127  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73128  				yym4 := z.EncBinary()
 73129  				_ = yym4
 73130  				if false {
 73131  				} else {
 73132  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 73133  				}
 73134  			} else {
 73135  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73136  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 73137  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73138  				yym5 := z.EncBinary()
 73139  				_ = yym5
 73140  				if false {
 73141  				} else {
 73142  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 73143  				}
 73144  			}
 73145  			if yyr2 || yy2arr2 {
 73146  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73147  				yym7 := z.EncBinary()
 73148  				_ = yym7
 73149  				if false {
 73150  				} else {
 73151  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 73152  				}
 73153  			} else {
 73154  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73155  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 73156  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73157  				yym8 := z.EncBinary()
 73158  				_ = yym8
 73159  				if false {
 73160  				} else {
 73161  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 73162  				}
 73163  			}
 73164  			if yyr2 || yy2arr2 {
 73165  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73166  				yym10 := z.EncBinary()
 73167  				_ = yym10
 73168  				if false {
 73169  				} else {
 73170  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 73171  				}
 73172  			} else {
 73173  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73174  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 73175  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73176  				yym11 := z.EncBinary()
 73177  				_ = yym11
 73178  				if false {
 73179  				} else {
 73180  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 73181  				}
 73182  			}
 73183  			if yyr2 || yy2arr2 {
 73184  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73185  				yym13 := z.EncBinary()
 73186  				_ = yym13
 73187  				if false {
 73188  				} else {
 73189  					r.EncodeUint(uint64(x.MinQueryIndex))
 73190  				}
 73191  			} else {
 73192  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73193  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 73194  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73195  				yym14 := z.EncBinary()
 73196  				_ = yym14
 73197  				if false {
 73198  				} else {
 73199  					r.EncodeUint(uint64(x.MinQueryIndex))
 73200  				}
 73201  			}
 73202  			if yyr2 || yy2arr2 {
 73203  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73204  				yym16 := z.EncBinary()
 73205  				_ = yym16
 73206  				if false {
 73207  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 73208  				} else {
 73209  					r.EncodeInt(int64(x.MaxQueryTime))
 73210  				}
 73211  			} else {
 73212  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73213  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 73214  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73215  				yym17 := z.EncBinary()
 73216  				_ = yym17
 73217  				if false {
 73218  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 73219  				} else {
 73220  					r.EncodeInt(int64(x.MaxQueryTime))
 73221  				}
 73222  			}
 73223  			if yyr2 || yy2arr2 {
 73224  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73225  				yym19 := z.EncBinary()
 73226  				_ = yym19
 73227  				if false {
 73228  				} else {
 73229  					r.EncodeBool(bool(x.AllowStale))
 73230  				}
 73231  			} else {
 73232  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73233  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 73234  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73235  				yym20 := z.EncBinary()
 73236  				_ = yym20
 73237  				if false {
 73238  				} else {
 73239  					r.EncodeBool(bool(x.AllowStale))
 73240  				}
 73241  			}
 73242  			if yyr2 || yy2arr2 {
 73243  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73244  				yym22 := z.EncBinary()
 73245  				_ = yym22
 73246  				if false {
 73247  				} else {
 73248  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 73249  				}
 73250  			} else {
 73251  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73252  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 73253  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73254  				yym23 := z.EncBinary()
 73255  				_ = yym23
 73256  				if false {
 73257  				} else {
 73258  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 73259  				}
 73260  			}
 73261  			if yyr2 || yy2arr2 {
 73262  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73263  				yym25 := z.EncBinary()
 73264  				_ = yym25
 73265  				if false {
 73266  				} else {
 73267  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 73268  				}
 73269  			} else {
 73270  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73271  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 73272  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73273  				yym26 := z.EncBinary()
 73274  				_ = yym26
 73275  				if false {
 73276  				} else {
 73277  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 73278  				}
 73279  			}
 73280  			if yyr2 || yy2arr2 {
 73281  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73282  				yym28 := z.EncBinary()
 73283  				_ = yym28
 73284  				if false {
 73285  				} else {
 73286  					r.EncodeBool(bool(x.Forwarded))
 73287  				}
 73288  			} else {
 73289  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73290  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 73291  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73292  				yym29 := z.EncBinary()
 73293  				_ = yym29
 73294  				if false {
 73295  				} else {
 73296  					r.EncodeBool(bool(x.Forwarded))
 73297  				}
 73298  			}
 73299  			if yyr2 || yy2arr2 {
 73300  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 73301  			} else {
 73302  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 73303  			}
 73304  		}
 73305  	}
 73306  }
 73307  
 73308  func (x *ACLPolicySpecificRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 73309  	var h codecSelfer100
 73310  	z, r := codec1978.GenHelperDecoder(d)
 73311  	_, _, _ = h, z, r
 73312  	yym1 := z.DecBinary()
 73313  	_ = yym1
 73314  	if false {
 73315  	} else if z.HasExtensions() && z.DecExt(x) {
 73316  	} else {
 73317  		yyct2 := r.ContainerType()
 73318  		if yyct2 == codecSelferValueTypeMap100 {
 73319  			yyl2 := r.ReadMapStart()
 73320  			if yyl2 == 0 {
 73321  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 73322  			} else {
 73323  				x.codecDecodeSelfFromMap(yyl2, d)
 73324  			}
 73325  		} else if yyct2 == codecSelferValueTypeArray100 {
 73326  			yyl2 := r.ReadArrayStart()
 73327  			if yyl2 == 0 {
 73328  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73329  			} else {
 73330  				x.codecDecodeSelfFromArray(yyl2, d)
 73331  			}
 73332  		} else {
 73333  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 73334  		}
 73335  	}
 73336  }
 73337  
 73338  func (x *ACLPolicySpecificRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 73339  	var h codecSelfer100
 73340  	z, r := codec1978.GenHelperDecoder(d)
 73341  	_, _, _ = h, z, r
 73342  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 73343  	_ = yys3Slc
 73344  	var yyhl3 bool = l >= 0
 73345  	for yyj3 := 0; ; yyj3++ {
 73346  		if yyhl3 {
 73347  			if yyj3 >= l {
 73348  				break
 73349  			}
 73350  		} else {
 73351  			if r.CheckBreak() {
 73352  				break
 73353  			}
 73354  		}
 73355  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 73356  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 73357  		yys3 := string(yys3Slc)
 73358  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 73359  		switch yys3 {
 73360  		case "Name":
 73361  			if r.TryDecodeAsNil() {
 73362  				x.Name = ""
 73363  			} else {
 73364  				yyv4 := &x.Name
 73365  				yym5 := z.DecBinary()
 73366  				_ = yym5
 73367  				if false {
 73368  				} else {
 73369  					*((*string)(yyv4)) = r.DecodeString()
 73370  				}
 73371  			}
 73372  		case "Region":
 73373  			if r.TryDecodeAsNil() {
 73374  				x.Region = ""
 73375  			} else {
 73376  				yyv6 := &x.Region
 73377  				yym7 := z.DecBinary()
 73378  				_ = yym7
 73379  				if false {
 73380  				} else {
 73381  					*((*string)(yyv6)) = r.DecodeString()
 73382  				}
 73383  			}
 73384  		case "Namespace":
 73385  			if r.TryDecodeAsNil() {
 73386  				x.Namespace = ""
 73387  			} else {
 73388  				yyv8 := &x.Namespace
 73389  				yym9 := z.DecBinary()
 73390  				_ = yym9
 73391  				if false {
 73392  				} else {
 73393  					*((*string)(yyv8)) = r.DecodeString()
 73394  				}
 73395  			}
 73396  		case "MinQueryIndex":
 73397  			if r.TryDecodeAsNil() {
 73398  				x.MinQueryIndex = 0
 73399  			} else {
 73400  				yyv10 := &x.MinQueryIndex
 73401  				yym11 := z.DecBinary()
 73402  				_ = yym11
 73403  				if false {
 73404  				} else {
 73405  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 73406  				}
 73407  			}
 73408  		case "MaxQueryTime":
 73409  			if r.TryDecodeAsNil() {
 73410  				x.MaxQueryTime = 0
 73411  			} else {
 73412  				yyv12 := &x.MaxQueryTime
 73413  				yym13 := z.DecBinary()
 73414  				_ = yym13
 73415  				if false {
 73416  				} else if z.HasExtensions() && z.DecExt(yyv12) {
 73417  				} else {
 73418  					*((*int64)(yyv12)) = int64(r.DecodeInt(64))
 73419  				}
 73420  			}
 73421  		case "AllowStale":
 73422  			if r.TryDecodeAsNil() {
 73423  				x.AllowStale = false
 73424  			} else {
 73425  				yyv14 := &x.AllowStale
 73426  				yym15 := z.DecBinary()
 73427  				_ = yym15
 73428  				if false {
 73429  				} else {
 73430  					*((*bool)(yyv14)) = r.DecodeBool()
 73431  				}
 73432  			}
 73433  		case "Prefix":
 73434  			if r.TryDecodeAsNil() {
 73435  				x.Prefix = ""
 73436  			} else {
 73437  				yyv16 := &x.Prefix
 73438  				yym17 := z.DecBinary()
 73439  				_ = yym17
 73440  				if false {
 73441  				} else {
 73442  					*((*string)(yyv16)) = r.DecodeString()
 73443  				}
 73444  			}
 73445  		case "AuthToken":
 73446  			if r.TryDecodeAsNil() {
 73447  				x.AuthToken = ""
 73448  			} else {
 73449  				yyv18 := &x.AuthToken
 73450  				yym19 := z.DecBinary()
 73451  				_ = yym19
 73452  				if false {
 73453  				} else {
 73454  					*((*string)(yyv18)) = r.DecodeString()
 73455  				}
 73456  			}
 73457  		case "Forwarded":
 73458  			if r.TryDecodeAsNil() {
 73459  				x.Forwarded = false
 73460  			} else {
 73461  				yyv20 := &x.Forwarded
 73462  				yym21 := z.DecBinary()
 73463  				_ = yym21
 73464  				if false {
 73465  				} else {
 73466  					*((*bool)(yyv20)) = r.DecodeBool()
 73467  				}
 73468  			}
 73469  		default:
 73470  			z.DecStructFieldNotFound(-1, yys3)
 73471  		} // end switch yys3
 73472  	} // end for yyj3
 73473  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 73474  }
 73475  
 73476  func (x *ACLPolicySpecificRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 73477  	var h codecSelfer100
 73478  	z, r := codec1978.GenHelperDecoder(d)
 73479  	_, _, _ = h, z, r
 73480  	var yyj22 int
 73481  	var yyb22 bool
 73482  	var yyhl22 bool = l >= 0
 73483  	yyj22++
 73484  	if yyhl22 {
 73485  		yyb22 = yyj22 > l
 73486  	} else {
 73487  		yyb22 = r.CheckBreak()
 73488  	}
 73489  	if yyb22 {
 73490  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73491  		return
 73492  	}
 73493  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 73494  	if r.TryDecodeAsNil() {
 73495  		x.Name = ""
 73496  	} else {
 73497  		yyv23 := &x.Name
 73498  		yym24 := z.DecBinary()
 73499  		_ = yym24
 73500  		if false {
 73501  		} else {
 73502  			*((*string)(yyv23)) = r.DecodeString()
 73503  		}
 73504  	}
 73505  	yyj22++
 73506  	if yyhl22 {
 73507  		yyb22 = yyj22 > l
 73508  	} else {
 73509  		yyb22 = r.CheckBreak()
 73510  	}
 73511  	if yyb22 {
 73512  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73513  		return
 73514  	}
 73515  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 73516  	if r.TryDecodeAsNil() {
 73517  		x.Region = ""
 73518  	} else {
 73519  		yyv25 := &x.Region
 73520  		yym26 := z.DecBinary()
 73521  		_ = yym26
 73522  		if false {
 73523  		} else {
 73524  			*((*string)(yyv25)) = r.DecodeString()
 73525  		}
 73526  	}
 73527  	yyj22++
 73528  	if yyhl22 {
 73529  		yyb22 = yyj22 > l
 73530  	} else {
 73531  		yyb22 = r.CheckBreak()
 73532  	}
 73533  	if yyb22 {
 73534  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73535  		return
 73536  	}
 73537  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 73538  	if r.TryDecodeAsNil() {
 73539  		x.Namespace = ""
 73540  	} else {
 73541  		yyv27 := &x.Namespace
 73542  		yym28 := z.DecBinary()
 73543  		_ = yym28
 73544  		if false {
 73545  		} else {
 73546  			*((*string)(yyv27)) = r.DecodeString()
 73547  		}
 73548  	}
 73549  	yyj22++
 73550  	if yyhl22 {
 73551  		yyb22 = yyj22 > l
 73552  	} else {
 73553  		yyb22 = r.CheckBreak()
 73554  	}
 73555  	if yyb22 {
 73556  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73557  		return
 73558  	}
 73559  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 73560  	if r.TryDecodeAsNil() {
 73561  		x.MinQueryIndex = 0
 73562  	} else {
 73563  		yyv29 := &x.MinQueryIndex
 73564  		yym30 := z.DecBinary()
 73565  		_ = yym30
 73566  		if false {
 73567  		} else {
 73568  			*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
 73569  		}
 73570  	}
 73571  	yyj22++
 73572  	if yyhl22 {
 73573  		yyb22 = yyj22 > l
 73574  	} else {
 73575  		yyb22 = r.CheckBreak()
 73576  	}
 73577  	if yyb22 {
 73578  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73579  		return
 73580  	}
 73581  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 73582  	if r.TryDecodeAsNil() {
 73583  		x.MaxQueryTime = 0
 73584  	} else {
 73585  		yyv31 := &x.MaxQueryTime
 73586  		yym32 := z.DecBinary()
 73587  		_ = yym32
 73588  		if false {
 73589  		} else if z.HasExtensions() && z.DecExt(yyv31) {
 73590  		} else {
 73591  			*((*int64)(yyv31)) = int64(r.DecodeInt(64))
 73592  		}
 73593  	}
 73594  	yyj22++
 73595  	if yyhl22 {
 73596  		yyb22 = yyj22 > l
 73597  	} else {
 73598  		yyb22 = r.CheckBreak()
 73599  	}
 73600  	if yyb22 {
 73601  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73602  		return
 73603  	}
 73604  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 73605  	if r.TryDecodeAsNil() {
 73606  		x.AllowStale = false
 73607  	} else {
 73608  		yyv33 := &x.AllowStale
 73609  		yym34 := z.DecBinary()
 73610  		_ = yym34
 73611  		if false {
 73612  		} else {
 73613  			*((*bool)(yyv33)) = r.DecodeBool()
 73614  		}
 73615  	}
 73616  	yyj22++
 73617  	if yyhl22 {
 73618  		yyb22 = yyj22 > l
 73619  	} else {
 73620  		yyb22 = r.CheckBreak()
 73621  	}
 73622  	if yyb22 {
 73623  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73624  		return
 73625  	}
 73626  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 73627  	if r.TryDecodeAsNil() {
 73628  		x.Prefix = ""
 73629  	} else {
 73630  		yyv35 := &x.Prefix
 73631  		yym36 := z.DecBinary()
 73632  		_ = yym36
 73633  		if false {
 73634  		} else {
 73635  			*((*string)(yyv35)) = r.DecodeString()
 73636  		}
 73637  	}
 73638  	yyj22++
 73639  	if yyhl22 {
 73640  		yyb22 = yyj22 > l
 73641  	} else {
 73642  		yyb22 = r.CheckBreak()
 73643  	}
 73644  	if yyb22 {
 73645  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73646  		return
 73647  	}
 73648  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 73649  	if r.TryDecodeAsNil() {
 73650  		x.AuthToken = ""
 73651  	} else {
 73652  		yyv37 := &x.AuthToken
 73653  		yym38 := z.DecBinary()
 73654  		_ = yym38
 73655  		if false {
 73656  		} else {
 73657  			*((*string)(yyv37)) = r.DecodeString()
 73658  		}
 73659  	}
 73660  	yyj22++
 73661  	if yyhl22 {
 73662  		yyb22 = yyj22 > l
 73663  	} else {
 73664  		yyb22 = r.CheckBreak()
 73665  	}
 73666  	if yyb22 {
 73667  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73668  		return
 73669  	}
 73670  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 73671  	if r.TryDecodeAsNil() {
 73672  		x.Forwarded = false
 73673  	} else {
 73674  		yyv39 := &x.Forwarded
 73675  		yym40 := z.DecBinary()
 73676  		_ = yym40
 73677  		if false {
 73678  		} else {
 73679  			*((*bool)(yyv39)) = r.DecodeBool()
 73680  		}
 73681  	}
 73682  	for {
 73683  		yyj22++
 73684  		if yyhl22 {
 73685  			yyb22 = yyj22 > l
 73686  		} else {
 73687  			yyb22 = r.CheckBreak()
 73688  		}
 73689  		if yyb22 {
 73690  			break
 73691  		}
 73692  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 73693  		z.DecStructFieldNotFound(yyj22-1, "")
 73694  	}
 73695  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73696  }
 73697  
 73698  func (x *ACLPolicySetRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 73699  	var h codecSelfer100
 73700  	z, r := codec1978.GenHelperEncoder(e)
 73701  	_, _, _ = h, z, r
 73702  	if x == nil {
 73703  		r.EncodeNil()
 73704  	} else {
 73705  		yym1 := z.EncBinary()
 73706  		_ = yym1
 73707  		if false {
 73708  		} else if z.HasExtensions() && z.EncExt(x) {
 73709  		} else {
 73710  			yysep2 := !z.EncBinary()
 73711  			yy2arr2 := z.EncBasicHandle().StructToArray
 73712  			var yyq2 [9]bool
 73713  			_, _, _ = yysep2, yyq2, yy2arr2
 73714  			const yyr2 bool = false
 73715  			var yynn2 int
 73716  			if yyr2 || yy2arr2 {
 73717  				r.EncodeArrayStart(9)
 73718  			} else {
 73719  				yynn2 = 9
 73720  				for _, b := range yyq2 {
 73721  					if b {
 73722  						yynn2++
 73723  					}
 73724  				}
 73725  				r.EncodeMapStart(yynn2)
 73726  				yynn2 = 0
 73727  			}
 73728  			if yyr2 || yy2arr2 {
 73729  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73730  				if x.Names == nil {
 73731  					r.EncodeNil()
 73732  				} else {
 73733  					yym4 := z.EncBinary()
 73734  					_ = yym4
 73735  					if false {
 73736  					} else {
 73737  						z.F.EncSliceStringV(x.Names, false, e)
 73738  					}
 73739  				}
 73740  			} else {
 73741  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73742  				r.EncodeString(codecSelferC_UTF8100, string("Names"))
 73743  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73744  				if x.Names == nil {
 73745  					r.EncodeNil()
 73746  				} else {
 73747  					yym5 := z.EncBinary()
 73748  					_ = yym5
 73749  					if false {
 73750  					} else {
 73751  						z.F.EncSliceStringV(x.Names, false, e)
 73752  					}
 73753  				}
 73754  			}
 73755  			if yyr2 || yy2arr2 {
 73756  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73757  				yym7 := z.EncBinary()
 73758  				_ = yym7
 73759  				if false {
 73760  				} else {
 73761  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 73762  				}
 73763  			} else {
 73764  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73765  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 73766  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73767  				yym8 := z.EncBinary()
 73768  				_ = yym8
 73769  				if false {
 73770  				} else {
 73771  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 73772  				}
 73773  			}
 73774  			if yyr2 || yy2arr2 {
 73775  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73776  				yym10 := z.EncBinary()
 73777  				_ = yym10
 73778  				if false {
 73779  				} else {
 73780  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 73781  				}
 73782  			} else {
 73783  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73784  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 73785  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73786  				yym11 := z.EncBinary()
 73787  				_ = yym11
 73788  				if false {
 73789  				} else {
 73790  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 73791  				}
 73792  			}
 73793  			if yyr2 || yy2arr2 {
 73794  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73795  				yym13 := z.EncBinary()
 73796  				_ = yym13
 73797  				if false {
 73798  				} else {
 73799  					r.EncodeUint(uint64(x.MinQueryIndex))
 73800  				}
 73801  			} else {
 73802  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73803  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 73804  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73805  				yym14 := z.EncBinary()
 73806  				_ = yym14
 73807  				if false {
 73808  				} else {
 73809  					r.EncodeUint(uint64(x.MinQueryIndex))
 73810  				}
 73811  			}
 73812  			if yyr2 || yy2arr2 {
 73813  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73814  				yym16 := z.EncBinary()
 73815  				_ = yym16
 73816  				if false {
 73817  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 73818  				} else {
 73819  					r.EncodeInt(int64(x.MaxQueryTime))
 73820  				}
 73821  			} else {
 73822  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73823  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 73824  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73825  				yym17 := z.EncBinary()
 73826  				_ = yym17
 73827  				if false {
 73828  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 73829  				} else {
 73830  					r.EncodeInt(int64(x.MaxQueryTime))
 73831  				}
 73832  			}
 73833  			if yyr2 || yy2arr2 {
 73834  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73835  				yym19 := z.EncBinary()
 73836  				_ = yym19
 73837  				if false {
 73838  				} else {
 73839  					r.EncodeBool(bool(x.AllowStale))
 73840  				}
 73841  			} else {
 73842  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73843  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 73844  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73845  				yym20 := z.EncBinary()
 73846  				_ = yym20
 73847  				if false {
 73848  				} else {
 73849  					r.EncodeBool(bool(x.AllowStale))
 73850  				}
 73851  			}
 73852  			if yyr2 || yy2arr2 {
 73853  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73854  				yym22 := z.EncBinary()
 73855  				_ = yym22
 73856  				if false {
 73857  				} else {
 73858  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 73859  				}
 73860  			} else {
 73861  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73862  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 73863  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73864  				yym23 := z.EncBinary()
 73865  				_ = yym23
 73866  				if false {
 73867  				} else {
 73868  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 73869  				}
 73870  			}
 73871  			if yyr2 || yy2arr2 {
 73872  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73873  				yym25 := z.EncBinary()
 73874  				_ = yym25
 73875  				if false {
 73876  				} else {
 73877  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 73878  				}
 73879  			} else {
 73880  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73881  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 73882  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73883  				yym26 := z.EncBinary()
 73884  				_ = yym26
 73885  				if false {
 73886  				} else {
 73887  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 73888  				}
 73889  			}
 73890  			if yyr2 || yy2arr2 {
 73891  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 73892  				yym28 := z.EncBinary()
 73893  				_ = yym28
 73894  				if false {
 73895  				} else {
 73896  					r.EncodeBool(bool(x.Forwarded))
 73897  				}
 73898  			} else {
 73899  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 73900  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 73901  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 73902  				yym29 := z.EncBinary()
 73903  				_ = yym29
 73904  				if false {
 73905  				} else {
 73906  					r.EncodeBool(bool(x.Forwarded))
 73907  				}
 73908  			}
 73909  			if yyr2 || yy2arr2 {
 73910  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 73911  			} else {
 73912  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 73913  			}
 73914  		}
 73915  	}
 73916  }
 73917  
 73918  func (x *ACLPolicySetRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 73919  	var h codecSelfer100
 73920  	z, r := codec1978.GenHelperDecoder(d)
 73921  	_, _, _ = h, z, r
 73922  	yym1 := z.DecBinary()
 73923  	_ = yym1
 73924  	if false {
 73925  	} else if z.HasExtensions() && z.DecExt(x) {
 73926  	} else {
 73927  		yyct2 := r.ContainerType()
 73928  		if yyct2 == codecSelferValueTypeMap100 {
 73929  			yyl2 := r.ReadMapStart()
 73930  			if yyl2 == 0 {
 73931  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 73932  			} else {
 73933  				x.codecDecodeSelfFromMap(yyl2, d)
 73934  			}
 73935  		} else if yyct2 == codecSelferValueTypeArray100 {
 73936  			yyl2 := r.ReadArrayStart()
 73937  			if yyl2 == 0 {
 73938  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 73939  			} else {
 73940  				x.codecDecodeSelfFromArray(yyl2, d)
 73941  			}
 73942  		} else {
 73943  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 73944  		}
 73945  	}
 73946  }
 73947  
 73948  func (x *ACLPolicySetRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 73949  	var h codecSelfer100
 73950  	z, r := codec1978.GenHelperDecoder(d)
 73951  	_, _, _ = h, z, r
 73952  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 73953  	_ = yys3Slc
 73954  	var yyhl3 bool = l >= 0
 73955  	for yyj3 := 0; ; yyj3++ {
 73956  		if yyhl3 {
 73957  			if yyj3 >= l {
 73958  				break
 73959  			}
 73960  		} else {
 73961  			if r.CheckBreak() {
 73962  				break
 73963  			}
 73964  		}
 73965  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 73966  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 73967  		yys3 := string(yys3Slc)
 73968  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 73969  		switch yys3 {
 73970  		case "Names":
 73971  			if r.TryDecodeAsNil() {
 73972  				x.Names = nil
 73973  			} else {
 73974  				yyv4 := &x.Names
 73975  				yym5 := z.DecBinary()
 73976  				_ = yym5
 73977  				if false {
 73978  				} else {
 73979  					z.F.DecSliceStringX(yyv4, false, d)
 73980  				}
 73981  			}
 73982  		case "Region":
 73983  			if r.TryDecodeAsNil() {
 73984  				x.Region = ""
 73985  			} else {
 73986  				yyv6 := &x.Region
 73987  				yym7 := z.DecBinary()
 73988  				_ = yym7
 73989  				if false {
 73990  				} else {
 73991  					*((*string)(yyv6)) = r.DecodeString()
 73992  				}
 73993  			}
 73994  		case "Namespace":
 73995  			if r.TryDecodeAsNil() {
 73996  				x.Namespace = ""
 73997  			} else {
 73998  				yyv8 := &x.Namespace
 73999  				yym9 := z.DecBinary()
 74000  				_ = yym9
 74001  				if false {
 74002  				} else {
 74003  					*((*string)(yyv8)) = r.DecodeString()
 74004  				}
 74005  			}
 74006  		case "MinQueryIndex":
 74007  			if r.TryDecodeAsNil() {
 74008  				x.MinQueryIndex = 0
 74009  			} else {
 74010  				yyv10 := &x.MinQueryIndex
 74011  				yym11 := z.DecBinary()
 74012  				_ = yym11
 74013  				if false {
 74014  				} else {
 74015  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 74016  				}
 74017  			}
 74018  		case "MaxQueryTime":
 74019  			if r.TryDecodeAsNil() {
 74020  				x.MaxQueryTime = 0
 74021  			} else {
 74022  				yyv12 := &x.MaxQueryTime
 74023  				yym13 := z.DecBinary()
 74024  				_ = yym13
 74025  				if false {
 74026  				} else if z.HasExtensions() && z.DecExt(yyv12) {
 74027  				} else {
 74028  					*((*int64)(yyv12)) = int64(r.DecodeInt(64))
 74029  				}
 74030  			}
 74031  		case "AllowStale":
 74032  			if r.TryDecodeAsNil() {
 74033  				x.AllowStale = false
 74034  			} else {
 74035  				yyv14 := &x.AllowStale
 74036  				yym15 := z.DecBinary()
 74037  				_ = yym15
 74038  				if false {
 74039  				} else {
 74040  					*((*bool)(yyv14)) = r.DecodeBool()
 74041  				}
 74042  			}
 74043  		case "Prefix":
 74044  			if r.TryDecodeAsNil() {
 74045  				x.Prefix = ""
 74046  			} else {
 74047  				yyv16 := &x.Prefix
 74048  				yym17 := z.DecBinary()
 74049  				_ = yym17
 74050  				if false {
 74051  				} else {
 74052  					*((*string)(yyv16)) = r.DecodeString()
 74053  				}
 74054  			}
 74055  		case "AuthToken":
 74056  			if r.TryDecodeAsNil() {
 74057  				x.AuthToken = ""
 74058  			} else {
 74059  				yyv18 := &x.AuthToken
 74060  				yym19 := z.DecBinary()
 74061  				_ = yym19
 74062  				if false {
 74063  				} else {
 74064  					*((*string)(yyv18)) = r.DecodeString()
 74065  				}
 74066  			}
 74067  		case "Forwarded":
 74068  			if r.TryDecodeAsNil() {
 74069  				x.Forwarded = false
 74070  			} else {
 74071  				yyv20 := &x.Forwarded
 74072  				yym21 := z.DecBinary()
 74073  				_ = yym21
 74074  				if false {
 74075  				} else {
 74076  					*((*bool)(yyv20)) = r.DecodeBool()
 74077  				}
 74078  			}
 74079  		default:
 74080  			z.DecStructFieldNotFound(-1, yys3)
 74081  		} // end switch yys3
 74082  	} // end for yyj3
 74083  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 74084  }
 74085  
 74086  func (x *ACLPolicySetRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 74087  	var h codecSelfer100
 74088  	z, r := codec1978.GenHelperDecoder(d)
 74089  	_, _, _ = h, z, r
 74090  	var yyj22 int
 74091  	var yyb22 bool
 74092  	var yyhl22 bool = l >= 0
 74093  	yyj22++
 74094  	if yyhl22 {
 74095  		yyb22 = yyj22 > l
 74096  	} else {
 74097  		yyb22 = r.CheckBreak()
 74098  	}
 74099  	if yyb22 {
 74100  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74101  		return
 74102  	}
 74103  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74104  	if r.TryDecodeAsNil() {
 74105  		x.Names = nil
 74106  	} else {
 74107  		yyv23 := &x.Names
 74108  		yym24 := z.DecBinary()
 74109  		_ = yym24
 74110  		if false {
 74111  		} else {
 74112  			z.F.DecSliceStringX(yyv23, false, d)
 74113  		}
 74114  	}
 74115  	yyj22++
 74116  	if yyhl22 {
 74117  		yyb22 = yyj22 > l
 74118  	} else {
 74119  		yyb22 = r.CheckBreak()
 74120  	}
 74121  	if yyb22 {
 74122  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74123  		return
 74124  	}
 74125  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74126  	if r.TryDecodeAsNil() {
 74127  		x.Region = ""
 74128  	} else {
 74129  		yyv25 := &x.Region
 74130  		yym26 := z.DecBinary()
 74131  		_ = yym26
 74132  		if false {
 74133  		} else {
 74134  			*((*string)(yyv25)) = r.DecodeString()
 74135  		}
 74136  	}
 74137  	yyj22++
 74138  	if yyhl22 {
 74139  		yyb22 = yyj22 > l
 74140  	} else {
 74141  		yyb22 = r.CheckBreak()
 74142  	}
 74143  	if yyb22 {
 74144  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74145  		return
 74146  	}
 74147  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74148  	if r.TryDecodeAsNil() {
 74149  		x.Namespace = ""
 74150  	} else {
 74151  		yyv27 := &x.Namespace
 74152  		yym28 := z.DecBinary()
 74153  		_ = yym28
 74154  		if false {
 74155  		} else {
 74156  			*((*string)(yyv27)) = r.DecodeString()
 74157  		}
 74158  	}
 74159  	yyj22++
 74160  	if yyhl22 {
 74161  		yyb22 = yyj22 > l
 74162  	} else {
 74163  		yyb22 = r.CheckBreak()
 74164  	}
 74165  	if yyb22 {
 74166  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74167  		return
 74168  	}
 74169  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74170  	if r.TryDecodeAsNil() {
 74171  		x.MinQueryIndex = 0
 74172  	} else {
 74173  		yyv29 := &x.MinQueryIndex
 74174  		yym30 := z.DecBinary()
 74175  		_ = yym30
 74176  		if false {
 74177  		} else {
 74178  			*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
 74179  		}
 74180  	}
 74181  	yyj22++
 74182  	if yyhl22 {
 74183  		yyb22 = yyj22 > l
 74184  	} else {
 74185  		yyb22 = r.CheckBreak()
 74186  	}
 74187  	if yyb22 {
 74188  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74189  		return
 74190  	}
 74191  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74192  	if r.TryDecodeAsNil() {
 74193  		x.MaxQueryTime = 0
 74194  	} else {
 74195  		yyv31 := &x.MaxQueryTime
 74196  		yym32 := z.DecBinary()
 74197  		_ = yym32
 74198  		if false {
 74199  		} else if z.HasExtensions() && z.DecExt(yyv31) {
 74200  		} else {
 74201  			*((*int64)(yyv31)) = int64(r.DecodeInt(64))
 74202  		}
 74203  	}
 74204  	yyj22++
 74205  	if yyhl22 {
 74206  		yyb22 = yyj22 > l
 74207  	} else {
 74208  		yyb22 = r.CheckBreak()
 74209  	}
 74210  	if yyb22 {
 74211  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74212  		return
 74213  	}
 74214  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74215  	if r.TryDecodeAsNil() {
 74216  		x.AllowStale = false
 74217  	} else {
 74218  		yyv33 := &x.AllowStale
 74219  		yym34 := z.DecBinary()
 74220  		_ = yym34
 74221  		if false {
 74222  		} else {
 74223  			*((*bool)(yyv33)) = r.DecodeBool()
 74224  		}
 74225  	}
 74226  	yyj22++
 74227  	if yyhl22 {
 74228  		yyb22 = yyj22 > l
 74229  	} else {
 74230  		yyb22 = r.CheckBreak()
 74231  	}
 74232  	if yyb22 {
 74233  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74234  		return
 74235  	}
 74236  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74237  	if r.TryDecodeAsNil() {
 74238  		x.Prefix = ""
 74239  	} else {
 74240  		yyv35 := &x.Prefix
 74241  		yym36 := z.DecBinary()
 74242  		_ = yym36
 74243  		if false {
 74244  		} else {
 74245  			*((*string)(yyv35)) = r.DecodeString()
 74246  		}
 74247  	}
 74248  	yyj22++
 74249  	if yyhl22 {
 74250  		yyb22 = yyj22 > l
 74251  	} else {
 74252  		yyb22 = r.CheckBreak()
 74253  	}
 74254  	if yyb22 {
 74255  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74256  		return
 74257  	}
 74258  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74259  	if r.TryDecodeAsNil() {
 74260  		x.AuthToken = ""
 74261  	} else {
 74262  		yyv37 := &x.AuthToken
 74263  		yym38 := z.DecBinary()
 74264  		_ = yym38
 74265  		if false {
 74266  		} else {
 74267  			*((*string)(yyv37)) = r.DecodeString()
 74268  		}
 74269  	}
 74270  	yyj22++
 74271  	if yyhl22 {
 74272  		yyb22 = yyj22 > l
 74273  	} else {
 74274  		yyb22 = r.CheckBreak()
 74275  	}
 74276  	if yyb22 {
 74277  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74278  		return
 74279  	}
 74280  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74281  	if r.TryDecodeAsNil() {
 74282  		x.Forwarded = false
 74283  	} else {
 74284  		yyv39 := &x.Forwarded
 74285  		yym40 := z.DecBinary()
 74286  		_ = yym40
 74287  		if false {
 74288  		} else {
 74289  			*((*bool)(yyv39)) = r.DecodeBool()
 74290  		}
 74291  	}
 74292  	for {
 74293  		yyj22++
 74294  		if yyhl22 {
 74295  			yyb22 = yyj22 > l
 74296  		} else {
 74297  			yyb22 = r.CheckBreak()
 74298  		}
 74299  		if yyb22 {
 74300  			break
 74301  		}
 74302  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74303  		z.DecStructFieldNotFound(yyj22-1, "")
 74304  	}
 74305  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74306  }
 74307  
 74308  func (x *ACLPolicyListResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 74309  	var h codecSelfer100
 74310  	z, r := codec1978.GenHelperEncoder(e)
 74311  	_, _, _ = h, z, r
 74312  	if x == nil {
 74313  		r.EncodeNil()
 74314  	} else {
 74315  		yym1 := z.EncBinary()
 74316  		_ = yym1
 74317  		if false {
 74318  		} else if z.HasExtensions() && z.EncExt(x) {
 74319  		} else {
 74320  			yysep2 := !z.EncBinary()
 74321  			yy2arr2 := z.EncBasicHandle().StructToArray
 74322  			var yyq2 [4]bool
 74323  			_, _, _ = yysep2, yyq2, yy2arr2
 74324  			const yyr2 bool = false
 74325  			var yynn2 int
 74326  			if yyr2 || yy2arr2 {
 74327  				r.EncodeArrayStart(4)
 74328  			} else {
 74329  				yynn2 = 4
 74330  				for _, b := range yyq2 {
 74331  					if b {
 74332  						yynn2++
 74333  					}
 74334  				}
 74335  				r.EncodeMapStart(yynn2)
 74336  				yynn2 = 0
 74337  			}
 74338  			if yyr2 || yy2arr2 {
 74339  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 74340  				if x.Policies == nil {
 74341  					r.EncodeNil()
 74342  				} else {
 74343  					yym4 := z.EncBinary()
 74344  					_ = yym4
 74345  					if false {
 74346  					} else {
 74347  						h.encSlicePtrtoACLPolicyListStub(([]*ACLPolicyListStub)(x.Policies), e)
 74348  					}
 74349  				}
 74350  			} else {
 74351  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 74352  				r.EncodeString(codecSelferC_UTF8100, string("Policies"))
 74353  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 74354  				if x.Policies == nil {
 74355  					r.EncodeNil()
 74356  				} else {
 74357  					yym5 := z.EncBinary()
 74358  					_ = yym5
 74359  					if false {
 74360  					} else {
 74361  						h.encSlicePtrtoACLPolicyListStub(([]*ACLPolicyListStub)(x.Policies), e)
 74362  					}
 74363  				}
 74364  			}
 74365  			if yyr2 || yy2arr2 {
 74366  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 74367  				yym7 := z.EncBinary()
 74368  				_ = yym7
 74369  				if false {
 74370  				} else {
 74371  					r.EncodeUint(uint64(x.Index))
 74372  				}
 74373  			} else {
 74374  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 74375  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 74376  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 74377  				yym8 := z.EncBinary()
 74378  				_ = yym8
 74379  				if false {
 74380  				} else {
 74381  					r.EncodeUint(uint64(x.Index))
 74382  				}
 74383  			}
 74384  			if yyr2 || yy2arr2 {
 74385  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 74386  				yym10 := z.EncBinary()
 74387  				_ = yym10
 74388  				if false {
 74389  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 74390  				} else {
 74391  					r.EncodeInt(int64(x.LastContact))
 74392  				}
 74393  			} else {
 74394  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 74395  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 74396  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 74397  				yym11 := z.EncBinary()
 74398  				_ = yym11
 74399  				if false {
 74400  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 74401  				} else {
 74402  					r.EncodeInt(int64(x.LastContact))
 74403  				}
 74404  			}
 74405  			if yyr2 || yy2arr2 {
 74406  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 74407  				yym13 := z.EncBinary()
 74408  				_ = yym13
 74409  				if false {
 74410  				} else {
 74411  					r.EncodeBool(bool(x.KnownLeader))
 74412  				}
 74413  			} else {
 74414  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 74415  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 74416  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 74417  				yym14 := z.EncBinary()
 74418  				_ = yym14
 74419  				if false {
 74420  				} else {
 74421  					r.EncodeBool(bool(x.KnownLeader))
 74422  				}
 74423  			}
 74424  			if yyr2 || yy2arr2 {
 74425  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 74426  			} else {
 74427  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 74428  			}
 74429  		}
 74430  	}
 74431  }
 74432  
 74433  func (x *ACLPolicyListResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 74434  	var h codecSelfer100
 74435  	z, r := codec1978.GenHelperDecoder(d)
 74436  	_, _, _ = h, z, r
 74437  	yym1 := z.DecBinary()
 74438  	_ = yym1
 74439  	if false {
 74440  	} else if z.HasExtensions() && z.DecExt(x) {
 74441  	} else {
 74442  		yyct2 := r.ContainerType()
 74443  		if yyct2 == codecSelferValueTypeMap100 {
 74444  			yyl2 := r.ReadMapStart()
 74445  			if yyl2 == 0 {
 74446  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 74447  			} else {
 74448  				x.codecDecodeSelfFromMap(yyl2, d)
 74449  			}
 74450  		} else if yyct2 == codecSelferValueTypeArray100 {
 74451  			yyl2 := r.ReadArrayStart()
 74452  			if yyl2 == 0 {
 74453  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74454  			} else {
 74455  				x.codecDecodeSelfFromArray(yyl2, d)
 74456  			}
 74457  		} else {
 74458  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 74459  		}
 74460  	}
 74461  }
 74462  
 74463  func (x *ACLPolicyListResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 74464  	var h codecSelfer100
 74465  	z, r := codec1978.GenHelperDecoder(d)
 74466  	_, _, _ = h, z, r
 74467  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 74468  	_ = yys3Slc
 74469  	var yyhl3 bool = l >= 0
 74470  	for yyj3 := 0; ; yyj3++ {
 74471  		if yyhl3 {
 74472  			if yyj3 >= l {
 74473  				break
 74474  			}
 74475  		} else {
 74476  			if r.CheckBreak() {
 74477  				break
 74478  			}
 74479  		}
 74480  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 74481  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 74482  		yys3 := string(yys3Slc)
 74483  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 74484  		switch yys3 {
 74485  		case "Policies":
 74486  			if r.TryDecodeAsNil() {
 74487  				x.Policies = nil
 74488  			} else {
 74489  				yyv4 := &x.Policies
 74490  				yym5 := z.DecBinary()
 74491  				_ = yym5
 74492  				if false {
 74493  				} else {
 74494  					h.decSlicePtrtoACLPolicyListStub((*[]*ACLPolicyListStub)(yyv4), d)
 74495  				}
 74496  			}
 74497  		case "Index":
 74498  			if r.TryDecodeAsNil() {
 74499  				x.Index = 0
 74500  			} else {
 74501  				yyv6 := &x.Index
 74502  				yym7 := z.DecBinary()
 74503  				_ = yym7
 74504  				if false {
 74505  				} else {
 74506  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 74507  				}
 74508  			}
 74509  		case "LastContact":
 74510  			if r.TryDecodeAsNil() {
 74511  				x.LastContact = 0
 74512  			} else {
 74513  				yyv8 := &x.LastContact
 74514  				yym9 := z.DecBinary()
 74515  				_ = yym9
 74516  				if false {
 74517  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 74518  				} else {
 74519  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 74520  				}
 74521  			}
 74522  		case "KnownLeader":
 74523  			if r.TryDecodeAsNil() {
 74524  				x.KnownLeader = false
 74525  			} else {
 74526  				yyv10 := &x.KnownLeader
 74527  				yym11 := z.DecBinary()
 74528  				_ = yym11
 74529  				if false {
 74530  				} else {
 74531  					*((*bool)(yyv10)) = r.DecodeBool()
 74532  				}
 74533  			}
 74534  		default:
 74535  			z.DecStructFieldNotFound(-1, yys3)
 74536  		} // end switch yys3
 74537  	} // end for yyj3
 74538  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 74539  }
 74540  
 74541  func (x *ACLPolicyListResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 74542  	var h codecSelfer100
 74543  	z, r := codec1978.GenHelperDecoder(d)
 74544  	_, _, _ = h, z, r
 74545  	var yyj12 int
 74546  	var yyb12 bool
 74547  	var yyhl12 bool = l >= 0
 74548  	yyj12++
 74549  	if yyhl12 {
 74550  		yyb12 = yyj12 > l
 74551  	} else {
 74552  		yyb12 = r.CheckBreak()
 74553  	}
 74554  	if yyb12 {
 74555  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74556  		return
 74557  	}
 74558  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74559  	if r.TryDecodeAsNil() {
 74560  		x.Policies = nil
 74561  	} else {
 74562  		yyv13 := &x.Policies
 74563  		yym14 := z.DecBinary()
 74564  		_ = yym14
 74565  		if false {
 74566  		} else {
 74567  			h.decSlicePtrtoACLPolicyListStub((*[]*ACLPolicyListStub)(yyv13), d)
 74568  		}
 74569  	}
 74570  	yyj12++
 74571  	if yyhl12 {
 74572  		yyb12 = yyj12 > l
 74573  	} else {
 74574  		yyb12 = r.CheckBreak()
 74575  	}
 74576  	if yyb12 {
 74577  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74578  		return
 74579  	}
 74580  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74581  	if r.TryDecodeAsNil() {
 74582  		x.Index = 0
 74583  	} else {
 74584  		yyv15 := &x.Index
 74585  		yym16 := z.DecBinary()
 74586  		_ = yym16
 74587  		if false {
 74588  		} else {
 74589  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 74590  		}
 74591  	}
 74592  	yyj12++
 74593  	if yyhl12 {
 74594  		yyb12 = yyj12 > l
 74595  	} else {
 74596  		yyb12 = r.CheckBreak()
 74597  	}
 74598  	if yyb12 {
 74599  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74600  		return
 74601  	}
 74602  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74603  	if r.TryDecodeAsNil() {
 74604  		x.LastContact = 0
 74605  	} else {
 74606  		yyv17 := &x.LastContact
 74607  		yym18 := z.DecBinary()
 74608  		_ = yym18
 74609  		if false {
 74610  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 74611  		} else {
 74612  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 74613  		}
 74614  	}
 74615  	yyj12++
 74616  	if yyhl12 {
 74617  		yyb12 = yyj12 > l
 74618  	} else {
 74619  		yyb12 = r.CheckBreak()
 74620  	}
 74621  	if yyb12 {
 74622  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74623  		return
 74624  	}
 74625  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74626  	if r.TryDecodeAsNil() {
 74627  		x.KnownLeader = false
 74628  	} else {
 74629  		yyv19 := &x.KnownLeader
 74630  		yym20 := z.DecBinary()
 74631  		_ = yym20
 74632  		if false {
 74633  		} else {
 74634  			*((*bool)(yyv19)) = r.DecodeBool()
 74635  		}
 74636  	}
 74637  	for {
 74638  		yyj12++
 74639  		if yyhl12 {
 74640  			yyb12 = yyj12 > l
 74641  		} else {
 74642  			yyb12 = r.CheckBreak()
 74643  		}
 74644  		if yyb12 {
 74645  			break
 74646  		}
 74647  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74648  		z.DecStructFieldNotFound(yyj12-1, "")
 74649  	}
 74650  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74651  }
 74652  
 74653  func (x *SingleACLPolicyResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 74654  	var h codecSelfer100
 74655  	z, r := codec1978.GenHelperEncoder(e)
 74656  	_, _, _ = h, z, r
 74657  	if x == nil {
 74658  		r.EncodeNil()
 74659  	} else {
 74660  		yym1 := z.EncBinary()
 74661  		_ = yym1
 74662  		if false {
 74663  		} else if z.HasExtensions() && z.EncExt(x) {
 74664  		} else {
 74665  			yysep2 := !z.EncBinary()
 74666  			yy2arr2 := z.EncBasicHandle().StructToArray
 74667  			var yyq2 [4]bool
 74668  			_, _, _ = yysep2, yyq2, yy2arr2
 74669  			const yyr2 bool = false
 74670  			var yynn2 int
 74671  			if yyr2 || yy2arr2 {
 74672  				r.EncodeArrayStart(4)
 74673  			} else {
 74674  				yynn2 = 4
 74675  				for _, b := range yyq2 {
 74676  					if b {
 74677  						yynn2++
 74678  					}
 74679  				}
 74680  				r.EncodeMapStart(yynn2)
 74681  				yynn2 = 0
 74682  			}
 74683  			if yyr2 || yy2arr2 {
 74684  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 74685  				if x.Policy == nil {
 74686  					r.EncodeNil()
 74687  				} else {
 74688  					x.Policy.CodecEncodeSelf(e)
 74689  				}
 74690  			} else {
 74691  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 74692  				r.EncodeString(codecSelferC_UTF8100, string("Policy"))
 74693  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 74694  				if x.Policy == nil {
 74695  					r.EncodeNil()
 74696  				} else {
 74697  					x.Policy.CodecEncodeSelf(e)
 74698  				}
 74699  			}
 74700  			if yyr2 || yy2arr2 {
 74701  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 74702  				yym7 := z.EncBinary()
 74703  				_ = yym7
 74704  				if false {
 74705  				} else {
 74706  					r.EncodeUint(uint64(x.Index))
 74707  				}
 74708  			} else {
 74709  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 74710  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 74711  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 74712  				yym8 := z.EncBinary()
 74713  				_ = yym8
 74714  				if false {
 74715  				} else {
 74716  					r.EncodeUint(uint64(x.Index))
 74717  				}
 74718  			}
 74719  			if yyr2 || yy2arr2 {
 74720  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 74721  				yym10 := z.EncBinary()
 74722  				_ = yym10
 74723  				if false {
 74724  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 74725  				} else {
 74726  					r.EncodeInt(int64(x.LastContact))
 74727  				}
 74728  			} else {
 74729  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 74730  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 74731  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 74732  				yym11 := z.EncBinary()
 74733  				_ = yym11
 74734  				if false {
 74735  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 74736  				} else {
 74737  					r.EncodeInt(int64(x.LastContact))
 74738  				}
 74739  			}
 74740  			if yyr2 || yy2arr2 {
 74741  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 74742  				yym13 := z.EncBinary()
 74743  				_ = yym13
 74744  				if false {
 74745  				} else {
 74746  					r.EncodeBool(bool(x.KnownLeader))
 74747  				}
 74748  			} else {
 74749  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 74750  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 74751  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 74752  				yym14 := z.EncBinary()
 74753  				_ = yym14
 74754  				if false {
 74755  				} else {
 74756  					r.EncodeBool(bool(x.KnownLeader))
 74757  				}
 74758  			}
 74759  			if yyr2 || yy2arr2 {
 74760  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 74761  			} else {
 74762  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 74763  			}
 74764  		}
 74765  	}
 74766  }
 74767  
 74768  func (x *SingleACLPolicyResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 74769  	var h codecSelfer100
 74770  	z, r := codec1978.GenHelperDecoder(d)
 74771  	_, _, _ = h, z, r
 74772  	yym1 := z.DecBinary()
 74773  	_ = yym1
 74774  	if false {
 74775  	} else if z.HasExtensions() && z.DecExt(x) {
 74776  	} else {
 74777  		yyct2 := r.ContainerType()
 74778  		if yyct2 == codecSelferValueTypeMap100 {
 74779  			yyl2 := r.ReadMapStart()
 74780  			if yyl2 == 0 {
 74781  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 74782  			} else {
 74783  				x.codecDecodeSelfFromMap(yyl2, d)
 74784  			}
 74785  		} else if yyct2 == codecSelferValueTypeArray100 {
 74786  			yyl2 := r.ReadArrayStart()
 74787  			if yyl2 == 0 {
 74788  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74789  			} else {
 74790  				x.codecDecodeSelfFromArray(yyl2, d)
 74791  			}
 74792  		} else {
 74793  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 74794  		}
 74795  	}
 74796  }
 74797  
 74798  func (x *SingleACLPolicyResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 74799  	var h codecSelfer100
 74800  	z, r := codec1978.GenHelperDecoder(d)
 74801  	_, _, _ = h, z, r
 74802  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 74803  	_ = yys3Slc
 74804  	var yyhl3 bool = l >= 0
 74805  	for yyj3 := 0; ; yyj3++ {
 74806  		if yyhl3 {
 74807  			if yyj3 >= l {
 74808  				break
 74809  			}
 74810  		} else {
 74811  			if r.CheckBreak() {
 74812  				break
 74813  			}
 74814  		}
 74815  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 74816  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 74817  		yys3 := string(yys3Slc)
 74818  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 74819  		switch yys3 {
 74820  		case "Policy":
 74821  			if r.TryDecodeAsNil() {
 74822  				if x.Policy != nil {
 74823  					x.Policy = nil
 74824  				}
 74825  			} else {
 74826  				if x.Policy == nil {
 74827  					x.Policy = new(ACLPolicy)
 74828  				}
 74829  				x.Policy.CodecDecodeSelf(d)
 74830  			}
 74831  		case "Index":
 74832  			if r.TryDecodeAsNil() {
 74833  				x.Index = 0
 74834  			} else {
 74835  				yyv5 := &x.Index
 74836  				yym6 := z.DecBinary()
 74837  				_ = yym6
 74838  				if false {
 74839  				} else {
 74840  					*((*uint64)(yyv5)) = uint64(r.DecodeUint(64))
 74841  				}
 74842  			}
 74843  		case "LastContact":
 74844  			if r.TryDecodeAsNil() {
 74845  				x.LastContact = 0
 74846  			} else {
 74847  				yyv7 := &x.LastContact
 74848  				yym8 := z.DecBinary()
 74849  				_ = yym8
 74850  				if false {
 74851  				} else if z.HasExtensions() && z.DecExt(yyv7) {
 74852  				} else {
 74853  					*((*int64)(yyv7)) = int64(r.DecodeInt(64))
 74854  				}
 74855  			}
 74856  		case "KnownLeader":
 74857  			if r.TryDecodeAsNil() {
 74858  				x.KnownLeader = false
 74859  			} else {
 74860  				yyv9 := &x.KnownLeader
 74861  				yym10 := z.DecBinary()
 74862  				_ = yym10
 74863  				if false {
 74864  				} else {
 74865  					*((*bool)(yyv9)) = r.DecodeBool()
 74866  				}
 74867  			}
 74868  		default:
 74869  			z.DecStructFieldNotFound(-1, yys3)
 74870  		} // end switch yys3
 74871  	} // end for yyj3
 74872  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 74873  }
 74874  
 74875  func (x *SingleACLPolicyResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 74876  	var h codecSelfer100
 74877  	z, r := codec1978.GenHelperDecoder(d)
 74878  	_, _, _ = h, z, r
 74879  	var yyj11 int
 74880  	var yyb11 bool
 74881  	var yyhl11 bool = l >= 0
 74882  	yyj11++
 74883  	if yyhl11 {
 74884  		yyb11 = yyj11 > l
 74885  	} else {
 74886  		yyb11 = r.CheckBreak()
 74887  	}
 74888  	if yyb11 {
 74889  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74890  		return
 74891  	}
 74892  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74893  	if r.TryDecodeAsNil() {
 74894  		if x.Policy != nil {
 74895  			x.Policy = nil
 74896  		}
 74897  	} else {
 74898  		if x.Policy == nil {
 74899  			x.Policy = new(ACLPolicy)
 74900  		}
 74901  		x.Policy.CodecDecodeSelf(d)
 74902  	}
 74903  	yyj11++
 74904  	if yyhl11 {
 74905  		yyb11 = yyj11 > l
 74906  	} else {
 74907  		yyb11 = r.CheckBreak()
 74908  	}
 74909  	if yyb11 {
 74910  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74911  		return
 74912  	}
 74913  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74914  	if r.TryDecodeAsNil() {
 74915  		x.Index = 0
 74916  	} else {
 74917  		yyv13 := &x.Index
 74918  		yym14 := z.DecBinary()
 74919  		_ = yym14
 74920  		if false {
 74921  		} else {
 74922  			*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 74923  		}
 74924  	}
 74925  	yyj11++
 74926  	if yyhl11 {
 74927  		yyb11 = yyj11 > l
 74928  	} else {
 74929  		yyb11 = r.CheckBreak()
 74930  	}
 74931  	if yyb11 {
 74932  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74933  		return
 74934  	}
 74935  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74936  	if r.TryDecodeAsNil() {
 74937  		x.LastContact = 0
 74938  	} else {
 74939  		yyv15 := &x.LastContact
 74940  		yym16 := z.DecBinary()
 74941  		_ = yym16
 74942  		if false {
 74943  		} else if z.HasExtensions() && z.DecExt(yyv15) {
 74944  		} else {
 74945  			*((*int64)(yyv15)) = int64(r.DecodeInt(64))
 74946  		}
 74947  	}
 74948  	yyj11++
 74949  	if yyhl11 {
 74950  		yyb11 = yyj11 > l
 74951  	} else {
 74952  		yyb11 = r.CheckBreak()
 74953  	}
 74954  	if yyb11 {
 74955  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74956  		return
 74957  	}
 74958  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74959  	if r.TryDecodeAsNil() {
 74960  		x.KnownLeader = false
 74961  	} else {
 74962  		yyv17 := &x.KnownLeader
 74963  		yym18 := z.DecBinary()
 74964  		_ = yym18
 74965  		if false {
 74966  		} else {
 74967  			*((*bool)(yyv17)) = r.DecodeBool()
 74968  		}
 74969  	}
 74970  	for {
 74971  		yyj11++
 74972  		if yyhl11 {
 74973  			yyb11 = yyj11 > l
 74974  		} else {
 74975  			yyb11 = r.CheckBreak()
 74976  		}
 74977  		if yyb11 {
 74978  			break
 74979  		}
 74980  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 74981  		z.DecStructFieldNotFound(yyj11-1, "")
 74982  	}
 74983  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 74984  }
 74985  
 74986  func (x *ACLPolicySetResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 74987  	var h codecSelfer100
 74988  	z, r := codec1978.GenHelperEncoder(e)
 74989  	_, _, _ = h, z, r
 74990  	if x == nil {
 74991  		r.EncodeNil()
 74992  	} else {
 74993  		yym1 := z.EncBinary()
 74994  		_ = yym1
 74995  		if false {
 74996  		} else if z.HasExtensions() && z.EncExt(x) {
 74997  		} else {
 74998  			yysep2 := !z.EncBinary()
 74999  			yy2arr2 := z.EncBasicHandle().StructToArray
 75000  			var yyq2 [4]bool
 75001  			_, _, _ = yysep2, yyq2, yy2arr2
 75002  			const yyr2 bool = false
 75003  			var yynn2 int
 75004  			if yyr2 || yy2arr2 {
 75005  				r.EncodeArrayStart(4)
 75006  			} else {
 75007  				yynn2 = 4
 75008  				for _, b := range yyq2 {
 75009  					if b {
 75010  						yynn2++
 75011  					}
 75012  				}
 75013  				r.EncodeMapStart(yynn2)
 75014  				yynn2 = 0
 75015  			}
 75016  			if yyr2 || yy2arr2 {
 75017  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 75018  				if x.Policies == nil {
 75019  					r.EncodeNil()
 75020  				} else {
 75021  					yym4 := z.EncBinary()
 75022  					_ = yym4
 75023  					if false {
 75024  					} else {
 75025  						h.encMapstringPtrtoACLPolicy((map[string]*ACLPolicy)(x.Policies), e)
 75026  					}
 75027  				}
 75028  			} else {
 75029  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 75030  				r.EncodeString(codecSelferC_UTF8100, string("Policies"))
 75031  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 75032  				if x.Policies == nil {
 75033  					r.EncodeNil()
 75034  				} else {
 75035  					yym5 := z.EncBinary()
 75036  					_ = yym5
 75037  					if false {
 75038  					} else {
 75039  						h.encMapstringPtrtoACLPolicy((map[string]*ACLPolicy)(x.Policies), e)
 75040  					}
 75041  				}
 75042  			}
 75043  			if yyr2 || yy2arr2 {
 75044  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 75045  				yym7 := z.EncBinary()
 75046  				_ = yym7
 75047  				if false {
 75048  				} else {
 75049  					r.EncodeUint(uint64(x.Index))
 75050  				}
 75051  			} else {
 75052  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 75053  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 75054  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 75055  				yym8 := z.EncBinary()
 75056  				_ = yym8
 75057  				if false {
 75058  				} else {
 75059  					r.EncodeUint(uint64(x.Index))
 75060  				}
 75061  			}
 75062  			if yyr2 || yy2arr2 {
 75063  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 75064  				yym10 := z.EncBinary()
 75065  				_ = yym10
 75066  				if false {
 75067  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 75068  				} else {
 75069  					r.EncodeInt(int64(x.LastContact))
 75070  				}
 75071  			} else {
 75072  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 75073  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 75074  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 75075  				yym11 := z.EncBinary()
 75076  				_ = yym11
 75077  				if false {
 75078  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 75079  				} else {
 75080  					r.EncodeInt(int64(x.LastContact))
 75081  				}
 75082  			}
 75083  			if yyr2 || yy2arr2 {
 75084  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 75085  				yym13 := z.EncBinary()
 75086  				_ = yym13
 75087  				if false {
 75088  				} else {
 75089  					r.EncodeBool(bool(x.KnownLeader))
 75090  				}
 75091  			} else {
 75092  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 75093  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 75094  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 75095  				yym14 := z.EncBinary()
 75096  				_ = yym14
 75097  				if false {
 75098  				} else {
 75099  					r.EncodeBool(bool(x.KnownLeader))
 75100  				}
 75101  			}
 75102  			if yyr2 || yy2arr2 {
 75103  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 75104  			} else {
 75105  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 75106  			}
 75107  		}
 75108  	}
 75109  }
 75110  
 75111  func (x *ACLPolicySetResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 75112  	var h codecSelfer100
 75113  	z, r := codec1978.GenHelperDecoder(d)
 75114  	_, _, _ = h, z, r
 75115  	yym1 := z.DecBinary()
 75116  	_ = yym1
 75117  	if false {
 75118  	} else if z.HasExtensions() && z.DecExt(x) {
 75119  	} else {
 75120  		yyct2 := r.ContainerType()
 75121  		if yyct2 == codecSelferValueTypeMap100 {
 75122  			yyl2 := r.ReadMapStart()
 75123  			if yyl2 == 0 {
 75124  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 75125  			} else {
 75126  				x.codecDecodeSelfFromMap(yyl2, d)
 75127  			}
 75128  		} else if yyct2 == codecSelferValueTypeArray100 {
 75129  			yyl2 := r.ReadArrayStart()
 75130  			if yyl2 == 0 {
 75131  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 75132  			} else {
 75133  				x.codecDecodeSelfFromArray(yyl2, d)
 75134  			}
 75135  		} else {
 75136  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 75137  		}
 75138  	}
 75139  }
 75140  
 75141  func (x *ACLPolicySetResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 75142  	var h codecSelfer100
 75143  	z, r := codec1978.GenHelperDecoder(d)
 75144  	_, _, _ = h, z, r
 75145  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 75146  	_ = yys3Slc
 75147  	var yyhl3 bool = l >= 0
 75148  	for yyj3 := 0; ; yyj3++ {
 75149  		if yyhl3 {
 75150  			if yyj3 >= l {
 75151  				break
 75152  			}
 75153  		} else {
 75154  			if r.CheckBreak() {
 75155  				break
 75156  			}
 75157  		}
 75158  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 75159  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 75160  		yys3 := string(yys3Slc)
 75161  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 75162  		switch yys3 {
 75163  		case "Policies":
 75164  			if r.TryDecodeAsNil() {
 75165  				x.Policies = nil
 75166  			} else {
 75167  				yyv4 := &x.Policies
 75168  				yym5 := z.DecBinary()
 75169  				_ = yym5
 75170  				if false {
 75171  				} else {
 75172  					h.decMapstringPtrtoACLPolicy((*map[string]*ACLPolicy)(yyv4), d)
 75173  				}
 75174  			}
 75175  		case "Index":
 75176  			if r.TryDecodeAsNil() {
 75177  				x.Index = 0
 75178  			} else {
 75179  				yyv6 := &x.Index
 75180  				yym7 := z.DecBinary()
 75181  				_ = yym7
 75182  				if false {
 75183  				} else {
 75184  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 75185  				}
 75186  			}
 75187  		case "LastContact":
 75188  			if r.TryDecodeAsNil() {
 75189  				x.LastContact = 0
 75190  			} else {
 75191  				yyv8 := &x.LastContact
 75192  				yym9 := z.DecBinary()
 75193  				_ = yym9
 75194  				if false {
 75195  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 75196  				} else {
 75197  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 75198  				}
 75199  			}
 75200  		case "KnownLeader":
 75201  			if r.TryDecodeAsNil() {
 75202  				x.KnownLeader = false
 75203  			} else {
 75204  				yyv10 := &x.KnownLeader
 75205  				yym11 := z.DecBinary()
 75206  				_ = yym11
 75207  				if false {
 75208  				} else {
 75209  					*((*bool)(yyv10)) = r.DecodeBool()
 75210  				}
 75211  			}
 75212  		default:
 75213  			z.DecStructFieldNotFound(-1, yys3)
 75214  		} // end switch yys3
 75215  	} // end for yyj3
 75216  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 75217  }
 75218  
 75219  func (x *ACLPolicySetResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 75220  	var h codecSelfer100
 75221  	z, r := codec1978.GenHelperDecoder(d)
 75222  	_, _, _ = h, z, r
 75223  	var yyj12 int
 75224  	var yyb12 bool
 75225  	var yyhl12 bool = l >= 0
 75226  	yyj12++
 75227  	if yyhl12 {
 75228  		yyb12 = yyj12 > l
 75229  	} else {
 75230  		yyb12 = r.CheckBreak()
 75231  	}
 75232  	if yyb12 {
 75233  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 75234  		return
 75235  	}
 75236  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 75237  	if r.TryDecodeAsNil() {
 75238  		x.Policies = nil
 75239  	} else {
 75240  		yyv13 := &x.Policies
 75241  		yym14 := z.DecBinary()
 75242  		_ = yym14
 75243  		if false {
 75244  		} else {
 75245  			h.decMapstringPtrtoACLPolicy((*map[string]*ACLPolicy)(yyv13), d)
 75246  		}
 75247  	}
 75248  	yyj12++
 75249  	if yyhl12 {
 75250  		yyb12 = yyj12 > l
 75251  	} else {
 75252  		yyb12 = r.CheckBreak()
 75253  	}
 75254  	if yyb12 {
 75255  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 75256  		return
 75257  	}
 75258  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 75259  	if r.TryDecodeAsNil() {
 75260  		x.Index = 0
 75261  	} else {
 75262  		yyv15 := &x.Index
 75263  		yym16 := z.DecBinary()
 75264  		_ = yym16
 75265  		if false {
 75266  		} else {
 75267  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 75268  		}
 75269  	}
 75270  	yyj12++
 75271  	if yyhl12 {
 75272  		yyb12 = yyj12 > l
 75273  	} else {
 75274  		yyb12 = r.CheckBreak()
 75275  	}
 75276  	if yyb12 {
 75277  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 75278  		return
 75279  	}
 75280  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 75281  	if r.TryDecodeAsNil() {
 75282  		x.LastContact = 0
 75283  	} else {
 75284  		yyv17 := &x.LastContact
 75285  		yym18 := z.DecBinary()
 75286  		_ = yym18
 75287  		if false {
 75288  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 75289  		} else {
 75290  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 75291  		}
 75292  	}
 75293  	yyj12++
 75294  	if yyhl12 {
 75295  		yyb12 = yyj12 > l
 75296  	} else {
 75297  		yyb12 = r.CheckBreak()
 75298  	}
 75299  	if yyb12 {
 75300  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 75301  		return
 75302  	}
 75303  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 75304  	if r.TryDecodeAsNil() {
 75305  		x.KnownLeader = false
 75306  	} else {
 75307  		yyv19 := &x.KnownLeader
 75308  		yym20 := z.DecBinary()
 75309  		_ = yym20
 75310  		if false {
 75311  		} else {
 75312  			*((*bool)(yyv19)) = r.DecodeBool()
 75313  		}
 75314  	}
 75315  	for {
 75316  		yyj12++
 75317  		if yyhl12 {
 75318  			yyb12 = yyj12 > l
 75319  		} else {
 75320  			yyb12 = r.CheckBreak()
 75321  		}
 75322  		if yyb12 {
 75323  			break
 75324  		}
 75325  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 75326  		z.DecStructFieldNotFound(yyj12-1, "")
 75327  	}
 75328  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 75329  }
 75330  
 75331  func (x *ACLPolicyDeleteRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 75332  	var h codecSelfer100
 75333  	z, r := codec1978.GenHelperEncoder(e)
 75334  	_, _, _ = h, z, r
 75335  	if x == nil {
 75336  		r.EncodeNil()
 75337  	} else {
 75338  		yym1 := z.EncBinary()
 75339  		_ = yym1
 75340  		if false {
 75341  		} else if z.HasExtensions() && z.EncExt(x) {
 75342  		} else {
 75343  			yysep2 := !z.EncBinary()
 75344  			yy2arr2 := z.EncBasicHandle().StructToArray
 75345  			var yyq2 [5]bool
 75346  			_, _, _ = yysep2, yyq2, yy2arr2
 75347  			const yyr2 bool = false
 75348  			var yynn2 int
 75349  			if yyr2 || yy2arr2 {
 75350  				r.EncodeArrayStart(5)
 75351  			} else {
 75352  				yynn2 = 5
 75353  				for _, b := range yyq2 {
 75354  					if b {
 75355  						yynn2++
 75356  					}
 75357  				}
 75358  				r.EncodeMapStart(yynn2)
 75359  				yynn2 = 0
 75360  			}
 75361  			if yyr2 || yy2arr2 {
 75362  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 75363  				if x.Names == nil {
 75364  					r.EncodeNil()
 75365  				} else {
 75366  					yym4 := z.EncBinary()
 75367  					_ = yym4
 75368  					if false {
 75369  					} else {
 75370  						z.F.EncSliceStringV(x.Names, false, e)
 75371  					}
 75372  				}
 75373  			} else {
 75374  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 75375  				r.EncodeString(codecSelferC_UTF8100, string("Names"))
 75376  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 75377  				if x.Names == nil {
 75378  					r.EncodeNil()
 75379  				} else {
 75380  					yym5 := z.EncBinary()
 75381  					_ = yym5
 75382  					if false {
 75383  					} else {
 75384  						z.F.EncSliceStringV(x.Names, false, e)
 75385  					}
 75386  				}
 75387  			}
 75388  			if yyr2 || yy2arr2 {
 75389  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 75390  				yym7 := z.EncBinary()
 75391  				_ = yym7
 75392  				if false {
 75393  				} else {
 75394  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 75395  				}
 75396  			} else {
 75397  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 75398  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 75399  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 75400  				yym8 := z.EncBinary()
 75401  				_ = yym8
 75402  				if false {
 75403  				} else {
 75404  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 75405  				}
 75406  			}
 75407  			if yyr2 || yy2arr2 {
 75408  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 75409  				yym10 := z.EncBinary()
 75410  				_ = yym10
 75411  				if false {
 75412  				} else {
 75413  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 75414  				}
 75415  			} else {
 75416  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 75417  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 75418  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 75419  				yym11 := z.EncBinary()
 75420  				_ = yym11
 75421  				if false {
 75422  				} else {
 75423  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 75424  				}
 75425  			}
 75426  			if yyr2 || yy2arr2 {
 75427  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 75428  				yym13 := z.EncBinary()
 75429  				_ = yym13
 75430  				if false {
 75431  				} else {
 75432  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 75433  				}
 75434  			} else {
 75435  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 75436  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 75437  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 75438  				yym14 := z.EncBinary()
 75439  				_ = yym14
 75440  				if false {
 75441  				} else {
 75442  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 75443  				}
 75444  			}
 75445  			if yyr2 || yy2arr2 {
 75446  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 75447  				yym16 := z.EncBinary()
 75448  				_ = yym16
 75449  				if false {
 75450  				} else {
 75451  					r.EncodeBool(bool(x.Forwarded))
 75452  				}
 75453  			} else {
 75454  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 75455  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 75456  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 75457  				yym17 := z.EncBinary()
 75458  				_ = yym17
 75459  				if false {
 75460  				} else {
 75461  					r.EncodeBool(bool(x.Forwarded))
 75462  				}
 75463  			}
 75464  			if yyr2 || yy2arr2 {
 75465  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 75466  			} else {
 75467  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 75468  			}
 75469  		}
 75470  	}
 75471  }
 75472  
 75473  func (x *ACLPolicyDeleteRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 75474  	var h codecSelfer100
 75475  	z, r := codec1978.GenHelperDecoder(d)
 75476  	_, _, _ = h, z, r
 75477  	yym1 := z.DecBinary()
 75478  	_ = yym1
 75479  	if false {
 75480  	} else if z.HasExtensions() && z.DecExt(x) {
 75481  	} else {
 75482  		yyct2 := r.ContainerType()
 75483  		if yyct2 == codecSelferValueTypeMap100 {
 75484  			yyl2 := r.ReadMapStart()
 75485  			if yyl2 == 0 {
 75486  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 75487  			} else {
 75488  				x.codecDecodeSelfFromMap(yyl2, d)
 75489  			}
 75490  		} else if yyct2 == codecSelferValueTypeArray100 {
 75491  			yyl2 := r.ReadArrayStart()
 75492  			if yyl2 == 0 {
 75493  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 75494  			} else {
 75495  				x.codecDecodeSelfFromArray(yyl2, d)
 75496  			}
 75497  		} else {
 75498  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 75499  		}
 75500  	}
 75501  }
 75502  
 75503  func (x *ACLPolicyDeleteRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 75504  	var h codecSelfer100
 75505  	z, r := codec1978.GenHelperDecoder(d)
 75506  	_, _, _ = h, z, r
 75507  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 75508  	_ = yys3Slc
 75509  	var yyhl3 bool = l >= 0
 75510  	for yyj3 := 0; ; yyj3++ {
 75511  		if yyhl3 {
 75512  			if yyj3 >= l {
 75513  				break
 75514  			}
 75515  		} else {
 75516  			if r.CheckBreak() {
 75517  				break
 75518  			}
 75519  		}
 75520  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 75521  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 75522  		yys3 := string(yys3Slc)
 75523  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 75524  		switch yys3 {
 75525  		case "Names":
 75526  			if r.TryDecodeAsNil() {
 75527  				x.Names = nil
 75528  			} else {
 75529  				yyv4 := &x.Names
 75530  				yym5 := z.DecBinary()
 75531  				_ = yym5
 75532  				if false {
 75533  				} else {
 75534  					z.F.DecSliceStringX(yyv4, false, d)
 75535  				}
 75536  			}
 75537  		case "Region":
 75538  			if r.TryDecodeAsNil() {
 75539  				x.Region = ""
 75540  			} else {
 75541  				yyv6 := &x.Region
 75542  				yym7 := z.DecBinary()
 75543  				_ = yym7
 75544  				if false {
 75545  				} else {
 75546  					*((*string)(yyv6)) = r.DecodeString()
 75547  				}
 75548  			}
 75549  		case "Namespace":
 75550  			if r.TryDecodeAsNil() {
 75551  				x.Namespace = ""
 75552  			} else {
 75553  				yyv8 := &x.Namespace
 75554  				yym9 := z.DecBinary()
 75555  				_ = yym9
 75556  				if false {
 75557  				} else {
 75558  					*((*string)(yyv8)) = r.DecodeString()
 75559  				}
 75560  			}
 75561  		case "AuthToken":
 75562  			if r.TryDecodeAsNil() {
 75563  				x.AuthToken = ""
 75564  			} else {
 75565  				yyv10 := &x.AuthToken
 75566  				yym11 := z.DecBinary()
 75567  				_ = yym11
 75568  				if false {
 75569  				} else {
 75570  					*((*string)(yyv10)) = r.DecodeString()
 75571  				}
 75572  			}
 75573  		case "Forwarded":
 75574  			if r.TryDecodeAsNil() {
 75575  				x.Forwarded = false
 75576  			} else {
 75577  				yyv12 := &x.Forwarded
 75578  				yym13 := z.DecBinary()
 75579  				_ = yym13
 75580  				if false {
 75581  				} else {
 75582  					*((*bool)(yyv12)) = r.DecodeBool()
 75583  				}
 75584  			}
 75585  		default:
 75586  			z.DecStructFieldNotFound(-1, yys3)
 75587  		} // end switch yys3
 75588  	} // end for yyj3
 75589  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 75590  }
 75591  
 75592  func (x *ACLPolicyDeleteRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 75593  	var h codecSelfer100
 75594  	z, r := codec1978.GenHelperDecoder(d)
 75595  	_, _, _ = h, z, r
 75596  	var yyj14 int
 75597  	var yyb14 bool
 75598  	var yyhl14 bool = l >= 0
 75599  	yyj14++
 75600  	if yyhl14 {
 75601  		yyb14 = yyj14 > l
 75602  	} else {
 75603  		yyb14 = r.CheckBreak()
 75604  	}
 75605  	if yyb14 {
 75606  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 75607  		return
 75608  	}
 75609  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 75610  	if r.TryDecodeAsNil() {
 75611  		x.Names = nil
 75612  	} else {
 75613  		yyv15 := &x.Names
 75614  		yym16 := z.DecBinary()
 75615  		_ = yym16
 75616  		if false {
 75617  		} else {
 75618  			z.F.DecSliceStringX(yyv15, false, d)
 75619  		}
 75620  	}
 75621  	yyj14++
 75622  	if yyhl14 {
 75623  		yyb14 = yyj14 > l
 75624  	} else {
 75625  		yyb14 = r.CheckBreak()
 75626  	}
 75627  	if yyb14 {
 75628  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 75629  		return
 75630  	}
 75631  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 75632  	if r.TryDecodeAsNil() {
 75633  		x.Region = ""
 75634  	} else {
 75635  		yyv17 := &x.Region
 75636  		yym18 := z.DecBinary()
 75637  		_ = yym18
 75638  		if false {
 75639  		} else {
 75640  			*((*string)(yyv17)) = r.DecodeString()
 75641  		}
 75642  	}
 75643  	yyj14++
 75644  	if yyhl14 {
 75645  		yyb14 = yyj14 > l
 75646  	} else {
 75647  		yyb14 = r.CheckBreak()
 75648  	}
 75649  	if yyb14 {
 75650  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 75651  		return
 75652  	}
 75653  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 75654  	if r.TryDecodeAsNil() {
 75655  		x.Namespace = ""
 75656  	} else {
 75657  		yyv19 := &x.Namespace
 75658  		yym20 := z.DecBinary()
 75659  		_ = yym20
 75660  		if false {
 75661  		} else {
 75662  			*((*string)(yyv19)) = r.DecodeString()
 75663  		}
 75664  	}
 75665  	yyj14++
 75666  	if yyhl14 {
 75667  		yyb14 = yyj14 > l
 75668  	} else {
 75669  		yyb14 = r.CheckBreak()
 75670  	}
 75671  	if yyb14 {
 75672  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 75673  		return
 75674  	}
 75675  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 75676  	if r.TryDecodeAsNil() {
 75677  		x.AuthToken = ""
 75678  	} else {
 75679  		yyv21 := &x.AuthToken
 75680  		yym22 := z.DecBinary()
 75681  		_ = yym22
 75682  		if false {
 75683  		} else {
 75684  			*((*string)(yyv21)) = r.DecodeString()
 75685  		}
 75686  	}
 75687  	yyj14++
 75688  	if yyhl14 {
 75689  		yyb14 = yyj14 > l
 75690  	} else {
 75691  		yyb14 = r.CheckBreak()
 75692  	}
 75693  	if yyb14 {
 75694  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 75695  		return
 75696  	}
 75697  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 75698  	if r.TryDecodeAsNil() {
 75699  		x.Forwarded = false
 75700  	} else {
 75701  		yyv23 := &x.Forwarded
 75702  		yym24 := z.DecBinary()
 75703  		_ = yym24
 75704  		if false {
 75705  		} else {
 75706  			*((*bool)(yyv23)) = r.DecodeBool()
 75707  		}
 75708  	}
 75709  	for {
 75710  		yyj14++
 75711  		if yyhl14 {
 75712  			yyb14 = yyj14 > l
 75713  		} else {
 75714  			yyb14 = r.CheckBreak()
 75715  		}
 75716  		if yyb14 {
 75717  			break
 75718  		}
 75719  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 75720  		z.DecStructFieldNotFound(yyj14-1, "")
 75721  	}
 75722  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 75723  }
 75724  
 75725  func (x *ACLPolicyUpsertRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 75726  	var h codecSelfer100
 75727  	z, r := codec1978.GenHelperEncoder(e)
 75728  	_, _, _ = h, z, r
 75729  	if x == nil {
 75730  		r.EncodeNil()
 75731  	} else {
 75732  		yym1 := z.EncBinary()
 75733  		_ = yym1
 75734  		if false {
 75735  		} else if z.HasExtensions() && z.EncExt(x) {
 75736  		} else {
 75737  			yysep2 := !z.EncBinary()
 75738  			yy2arr2 := z.EncBasicHandle().StructToArray
 75739  			var yyq2 [5]bool
 75740  			_, _, _ = yysep2, yyq2, yy2arr2
 75741  			const yyr2 bool = false
 75742  			var yynn2 int
 75743  			if yyr2 || yy2arr2 {
 75744  				r.EncodeArrayStart(5)
 75745  			} else {
 75746  				yynn2 = 5
 75747  				for _, b := range yyq2 {
 75748  					if b {
 75749  						yynn2++
 75750  					}
 75751  				}
 75752  				r.EncodeMapStart(yynn2)
 75753  				yynn2 = 0
 75754  			}
 75755  			if yyr2 || yy2arr2 {
 75756  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 75757  				if x.Policies == nil {
 75758  					r.EncodeNil()
 75759  				} else {
 75760  					yym4 := z.EncBinary()
 75761  					_ = yym4
 75762  					if false {
 75763  					} else {
 75764  						h.encSlicePtrtoACLPolicy(([]*ACLPolicy)(x.Policies), e)
 75765  					}
 75766  				}
 75767  			} else {
 75768  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 75769  				r.EncodeString(codecSelferC_UTF8100, string("Policies"))
 75770  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 75771  				if x.Policies == nil {
 75772  					r.EncodeNil()
 75773  				} else {
 75774  					yym5 := z.EncBinary()
 75775  					_ = yym5
 75776  					if false {
 75777  					} else {
 75778  						h.encSlicePtrtoACLPolicy(([]*ACLPolicy)(x.Policies), e)
 75779  					}
 75780  				}
 75781  			}
 75782  			if yyr2 || yy2arr2 {
 75783  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 75784  				yym7 := z.EncBinary()
 75785  				_ = yym7
 75786  				if false {
 75787  				} else {
 75788  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 75789  				}
 75790  			} else {
 75791  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 75792  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 75793  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 75794  				yym8 := z.EncBinary()
 75795  				_ = yym8
 75796  				if false {
 75797  				} else {
 75798  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 75799  				}
 75800  			}
 75801  			if yyr2 || yy2arr2 {
 75802  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 75803  				yym10 := z.EncBinary()
 75804  				_ = yym10
 75805  				if false {
 75806  				} else {
 75807  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 75808  				}
 75809  			} else {
 75810  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 75811  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 75812  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 75813  				yym11 := z.EncBinary()
 75814  				_ = yym11
 75815  				if false {
 75816  				} else {
 75817  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 75818  				}
 75819  			}
 75820  			if yyr2 || yy2arr2 {
 75821  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 75822  				yym13 := z.EncBinary()
 75823  				_ = yym13
 75824  				if false {
 75825  				} else {
 75826  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 75827  				}
 75828  			} else {
 75829  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 75830  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 75831  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 75832  				yym14 := z.EncBinary()
 75833  				_ = yym14
 75834  				if false {
 75835  				} else {
 75836  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 75837  				}
 75838  			}
 75839  			if yyr2 || yy2arr2 {
 75840  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 75841  				yym16 := z.EncBinary()
 75842  				_ = yym16
 75843  				if false {
 75844  				} else {
 75845  					r.EncodeBool(bool(x.Forwarded))
 75846  				}
 75847  			} else {
 75848  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 75849  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 75850  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 75851  				yym17 := z.EncBinary()
 75852  				_ = yym17
 75853  				if false {
 75854  				} else {
 75855  					r.EncodeBool(bool(x.Forwarded))
 75856  				}
 75857  			}
 75858  			if yyr2 || yy2arr2 {
 75859  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 75860  			} else {
 75861  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 75862  			}
 75863  		}
 75864  	}
 75865  }
 75866  
 75867  func (x *ACLPolicyUpsertRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 75868  	var h codecSelfer100
 75869  	z, r := codec1978.GenHelperDecoder(d)
 75870  	_, _, _ = h, z, r
 75871  	yym1 := z.DecBinary()
 75872  	_ = yym1
 75873  	if false {
 75874  	} else if z.HasExtensions() && z.DecExt(x) {
 75875  	} else {
 75876  		yyct2 := r.ContainerType()
 75877  		if yyct2 == codecSelferValueTypeMap100 {
 75878  			yyl2 := r.ReadMapStart()
 75879  			if yyl2 == 0 {
 75880  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 75881  			} else {
 75882  				x.codecDecodeSelfFromMap(yyl2, d)
 75883  			}
 75884  		} else if yyct2 == codecSelferValueTypeArray100 {
 75885  			yyl2 := r.ReadArrayStart()
 75886  			if yyl2 == 0 {
 75887  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 75888  			} else {
 75889  				x.codecDecodeSelfFromArray(yyl2, d)
 75890  			}
 75891  		} else {
 75892  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 75893  		}
 75894  	}
 75895  }
 75896  
 75897  func (x *ACLPolicyUpsertRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 75898  	var h codecSelfer100
 75899  	z, r := codec1978.GenHelperDecoder(d)
 75900  	_, _, _ = h, z, r
 75901  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 75902  	_ = yys3Slc
 75903  	var yyhl3 bool = l >= 0
 75904  	for yyj3 := 0; ; yyj3++ {
 75905  		if yyhl3 {
 75906  			if yyj3 >= l {
 75907  				break
 75908  			}
 75909  		} else {
 75910  			if r.CheckBreak() {
 75911  				break
 75912  			}
 75913  		}
 75914  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 75915  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 75916  		yys3 := string(yys3Slc)
 75917  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 75918  		switch yys3 {
 75919  		case "Policies":
 75920  			if r.TryDecodeAsNil() {
 75921  				x.Policies = nil
 75922  			} else {
 75923  				yyv4 := &x.Policies
 75924  				yym5 := z.DecBinary()
 75925  				_ = yym5
 75926  				if false {
 75927  				} else {
 75928  					h.decSlicePtrtoACLPolicy((*[]*ACLPolicy)(yyv4), d)
 75929  				}
 75930  			}
 75931  		case "Region":
 75932  			if r.TryDecodeAsNil() {
 75933  				x.Region = ""
 75934  			} else {
 75935  				yyv6 := &x.Region
 75936  				yym7 := z.DecBinary()
 75937  				_ = yym7
 75938  				if false {
 75939  				} else {
 75940  					*((*string)(yyv6)) = r.DecodeString()
 75941  				}
 75942  			}
 75943  		case "Namespace":
 75944  			if r.TryDecodeAsNil() {
 75945  				x.Namespace = ""
 75946  			} else {
 75947  				yyv8 := &x.Namespace
 75948  				yym9 := z.DecBinary()
 75949  				_ = yym9
 75950  				if false {
 75951  				} else {
 75952  					*((*string)(yyv8)) = r.DecodeString()
 75953  				}
 75954  			}
 75955  		case "AuthToken":
 75956  			if r.TryDecodeAsNil() {
 75957  				x.AuthToken = ""
 75958  			} else {
 75959  				yyv10 := &x.AuthToken
 75960  				yym11 := z.DecBinary()
 75961  				_ = yym11
 75962  				if false {
 75963  				} else {
 75964  					*((*string)(yyv10)) = r.DecodeString()
 75965  				}
 75966  			}
 75967  		case "Forwarded":
 75968  			if r.TryDecodeAsNil() {
 75969  				x.Forwarded = false
 75970  			} else {
 75971  				yyv12 := &x.Forwarded
 75972  				yym13 := z.DecBinary()
 75973  				_ = yym13
 75974  				if false {
 75975  				} else {
 75976  					*((*bool)(yyv12)) = r.DecodeBool()
 75977  				}
 75978  			}
 75979  		default:
 75980  			z.DecStructFieldNotFound(-1, yys3)
 75981  		} // end switch yys3
 75982  	} // end for yyj3
 75983  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 75984  }
 75985  
 75986  func (x *ACLPolicyUpsertRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 75987  	var h codecSelfer100
 75988  	z, r := codec1978.GenHelperDecoder(d)
 75989  	_, _, _ = h, z, r
 75990  	var yyj14 int
 75991  	var yyb14 bool
 75992  	var yyhl14 bool = l >= 0
 75993  	yyj14++
 75994  	if yyhl14 {
 75995  		yyb14 = yyj14 > l
 75996  	} else {
 75997  		yyb14 = r.CheckBreak()
 75998  	}
 75999  	if yyb14 {
 76000  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76001  		return
 76002  	}
 76003  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76004  	if r.TryDecodeAsNil() {
 76005  		x.Policies = nil
 76006  	} else {
 76007  		yyv15 := &x.Policies
 76008  		yym16 := z.DecBinary()
 76009  		_ = yym16
 76010  		if false {
 76011  		} else {
 76012  			h.decSlicePtrtoACLPolicy((*[]*ACLPolicy)(yyv15), d)
 76013  		}
 76014  	}
 76015  	yyj14++
 76016  	if yyhl14 {
 76017  		yyb14 = yyj14 > l
 76018  	} else {
 76019  		yyb14 = r.CheckBreak()
 76020  	}
 76021  	if yyb14 {
 76022  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76023  		return
 76024  	}
 76025  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76026  	if r.TryDecodeAsNil() {
 76027  		x.Region = ""
 76028  	} else {
 76029  		yyv17 := &x.Region
 76030  		yym18 := z.DecBinary()
 76031  		_ = yym18
 76032  		if false {
 76033  		} else {
 76034  			*((*string)(yyv17)) = r.DecodeString()
 76035  		}
 76036  	}
 76037  	yyj14++
 76038  	if yyhl14 {
 76039  		yyb14 = yyj14 > l
 76040  	} else {
 76041  		yyb14 = r.CheckBreak()
 76042  	}
 76043  	if yyb14 {
 76044  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76045  		return
 76046  	}
 76047  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76048  	if r.TryDecodeAsNil() {
 76049  		x.Namespace = ""
 76050  	} else {
 76051  		yyv19 := &x.Namespace
 76052  		yym20 := z.DecBinary()
 76053  		_ = yym20
 76054  		if false {
 76055  		} else {
 76056  			*((*string)(yyv19)) = r.DecodeString()
 76057  		}
 76058  	}
 76059  	yyj14++
 76060  	if yyhl14 {
 76061  		yyb14 = yyj14 > l
 76062  	} else {
 76063  		yyb14 = r.CheckBreak()
 76064  	}
 76065  	if yyb14 {
 76066  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76067  		return
 76068  	}
 76069  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76070  	if r.TryDecodeAsNil() {
 76071  		x.AuthToken = ""
 76072  	} else {
 76073  		yyv21 := &x.AuthToken
 76074  		yym22 := z.DecBinary()
 76075  		_ = yym22
 76076  		if false {
 76077  		} else {
 76078  			*((*string)(yyv21)) = r.DecodeString()
 76079  		}
 76080  	}
 76081  	yyj14++
 76082  	if yyhl14 {
 76083  		yyb14 = yyj14 > l
 76084  	} else {
 76085  		yyb14 = r.CheckBreak()
 76086  	}
 76087  	if yyb14 {
 76088  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76089  		return
 76090  	}
 76091  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76092  	if r.TryDecodeAsNil() {
 76093  		x.Forwarded = false
 76094  	} else {
 76095  		yyv23 := &x.Forwarded
 76096  		yym24 := z.DecBinary()
 76097  		_ = yym24
 76098  		if false {
 76099  		} else {
 76100  			*((*bool)(yyv23)) = r.DecodeBool()
 76101  		}
 76102  	}
 76103  	for {
 76104  		yyj14++
 76105  		if yyhl14 {
 76106  			yyb14 = yyj14 > l
 76107  		} else {
 76108  			yyb14 = r.CheckBreak()
 76109  		}
 76110  		if yyb14 {
 76111  			break
 76112  		}
 76113  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76114  		z.DecStructFieldNotFound(yyj14-1, "")
 76115  	}
 76116  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76117  }
 76118  
 76119  func (x *ACLToken) CodecEncodeSelf(e *codec1978.Encoder) {
 76120  	var h codecSelfer100
 76121  	z, r := codec1978.GenHelperEncoder(e)
 76122  	_, _, _ = h, z, r
 76123  	if x == nil {
 76124  		r.EncodeNil()
 76125  	} else {
 76126  		yym1 := z.EncBinary()
 76127  		_ = yym1
 76128  		if false {
 76129  		} else if z.HasExtensions() && z.EncExt(x) {
 76130  		} else {
 76131  			yysep2 := !z.EncBinary()
 76132  			yy2arr2 := z.EncBasicHandle().StructToArray
 76133  			var yyq2 [10]bool
 76134  			_, _, _ = yysep2, yyq2, yy2arr2
 76135  			const yyr2 bool = false
 76136  			var yynn2 int
 76137  			if yyr2 || yy2arr2 {
 76138  				r.EncodeArrayStart(10)
 76139  			} else {
 76140  				yynn2 = 10
 76141  				for _, b := range yyq2 {
 76142  					if b {
 76143  						yynn2++
 76144  					}
 76145  				}
 76146  				r.EncodeMapStart(yynn2)
 76147  				yynn2 = 0
 76148  			}
 76149  			if yyr2 || yy2arr2 {
 76150  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76151  				yym4 := z.EncBinary()
 76152  				_ = yym4
 76153  				if false {
 76154  				} else {
 76155  					r.EncodeString(codecSelferC_UTF8100, string(x.AccessorID))
 76156  				}
 76157  			} else {
 76158  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76159  				r.EncodeString(codecSelferC_UTF8100, string("AccessorID"))
 76160  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76161  				yym5 := z.EncBinary()
 76162  				_ = yym5
 76163  				if false {
 76164  				} else {
 76165  					r.EncodeString(codecSelferC_UTF8100, string(x.AccessorID))
 76166  				}
 76167  			}
 76168  			if yyr2 || yy2arr2 {
 76169  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76170  				yym7 := z.EncBinary()
 76171  				_ = yym7
 76172  				if false {
 76173  				} else {
 76174  					r.EncodeString(codecSelferC_UTF8100, string(x.SecretID))
 76175  				}
 76176  			} else {
 76177  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76178  				r.EncodeString(codecSelferC_UTF8100, string("SecretID"))
 76179  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76180  				yym8 := z.EncBinary()
 76181  				_ = yym8
 76182  				if false {
 76183  				} else {
 76184  					r.EncodeString(codecSelferC_UTF8100, string(x.SecretID))
 76185  				}
 76186  			}
 76187  			if yyr2 || yy2arr2 {
 76188  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76189  				yym10 := z.EncBinary()
 76190  				_ = yym10
 76191  				if false {
 76192  				} else {
 76193  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 76194  				}
 76195  			} else {
 76196  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76197  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 76198  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76199  				yym11 := z.EncBinary()
 76200  				_ = yym11
 76201  				if false {
 76202  				} else {
 76203  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 76204  				}
 76205  			}
 76206  			if yyr2 || yy2arr2 {
 76207  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76208  				yym13 := z.EncBinary()
 76209  				_ = yym13
 76210  				if false {
 76211  				} else {
 76212  					r.EncodeString(codecSelferC_UTF8100, string(x.Type))
 76213  				}
 76214  			} else {
 76215  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76216  				r.EncodeString(codecSelferC_UTF8100, string("Type"))
 76217  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76218  				yym14 := z.EncBinary()
 76219  				_ = yym14
 76220  				if false {
 76221  				} else {
 76222  					r.EncodeString(codecSelferC_UTF8100, string(x.Type))
 76223  				}
 76224  			}
 76225  			if yyr2 || yy2arr2 {
 76226  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76227  				if x.Policies == nil {
 76228  					r.EncodeNil()
 76229  				} else {
 76230  					yym16 := z.EncBinary()
 76231  					_ = yym16
 76232  					if false {
 76233  					} else {
 76234  						z.F.EncSliceStringV(x.Policies, false, e)
 76235  					}
 76236  				}
 76237  			} else {
 76238  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76239  				r.EncodeString(codecSelferC_UTF8100, string("Policies"))
 76240  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76241  				if x.Policies == nil {
 76242  					r.EncodeNil()
 76243  				} else {
 76244  					yym17 := z.EncBinary()
 76245  					_ = yym17
 76246  					if false {
 76247  					} else {
 76248  						z.F.EncSliceStringV(x.Policies, false, e)
 76249  					}
 76250  				}
 76251  			}
 76252  			if yyr2 || yy2arr2 {
 76253  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76254  				yym19 := z.EncBinary()
 76255  				_ = yym19
 76256  				if false {
 76257  				} else {
 76258  					r.EncodeBool(bool(x.Global))
 76259  				}
 76260  			} else {
 76261  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76262  				r.EncodeString(codecSelferC_UTF8100, string("Global"))
 76263  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76264  				yym20 := z.EncBinary()
 76265  				_ = yym20
 76266  				if false {
 76267  				} else {
 76268  					r.EncodeBool(bool(x.Global))
 76269  				}
 76270  			}
 76271  			if yyr2 || yy2arr2 {
 76272  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76273  				if x.Hash == nil {
 76274  					r.EncodeNil()
 76275  				} else {
 76276  					yym22 := z.EncBinary()
 76277  					_ = yym22
 76278  					if false {
 76279  					} else {
 76280  						r.EncodeStringBytes(codecSelferC_RAW100, []byte(x.Hash))
 76281  					}
 76282  				}
 76283  			} else {
 76284  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76285  				r.EncodeString(codecSelferC_UTF8100, string("Hash"))
 76286  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76287  				if x.Hash == nil {
 76288  					r.EncodeNil()
 76289  				} else {
 76290  					yym23 := z.EncBinary()
 76291  					_ = yym23
 76292  					if false {
 76293  					} else {
 76294  						r.EncodeStringBytes(codecSelferC_RAW100, []byte(x.Hash))
 76295  					}
 76296  				}
 76297  			}
 76298  			if yyr2 || yy2arr2 {
 76299  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76300  				yy25 := &x.CreateTime
 76301  				yym26 := z.EncBinary()
 76302  				_ = yym26
 76303  				if false {
 76304  				} else if yym27 := z.TimeRtidIfBinc(); yym27 != 0 {
 76305  					r.EncodeBuiltin(yym27, yy25)
 76306  				} else if z.HasExtensions() && z.EncExt(yy25) {
 76307  				} else if yym26 {
 76308  					z.EncBinaryMarshal(yy25)
 76309  				} else if !yym26 && z.IsJSONHandle() {
 76310  					z.EncJSONMarshal(yy25)
 76311  				} else {
 76312  					z.EncFallback(yy25)
 76313  				}
 76314  			} else {
 76315  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76316  				r.EncodeString(codecSelferC_UTF8100, string("CreateTime"))
 76317  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76318  				yy28 := &x.CreateTime
 76319  				yym29 := z.EncBinary()
 76320  				_ = yym29
 76321  				if false {
 76322  				} else if yym30 := z.TimeRtidIfBinc(); yym30 != 0 {
 76323  					r.EncodeBuiltin(yym30, yy28)
 76324  				} else if z.HasExtensions() && z.EncExt(yy28) {
 76325  				} else if yym29 {
 76326  					z.EncBinaryMarshal(yy28)
 76327  				} else if !yym29 && z.IsJSONHandle() {
 76328  					z.EncJSONMarshal(yy28)
 76329  				} else {
 76330  					z.EncFallback(yy28)
 76331  				}
 76332  			}
 76333  			if yyr2 || yy2arr2 {
 76334  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76335  				yym32 := z.EncBinary()
 76336  				_ = yym32
 76337  				if false {
 76338  				} else {
 76339  					r.EncodeUint(uint64(x.CreateIndex))
 76340  				}
 76341  			} else {
 76342  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76343  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 76344  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76345  				yym33 := z.EncBinary()
 76346  				_ = yym33
 76347  				if false {
 76348  				} else {
 76349  					r.EncodeUint(uint64(x.CreateIndex))
 76350  				}
 76351  			}
 76352  			if yyr2 || yy2arr2 {
 76353  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76354  				yym35 := z.EncBinary()
 76355  				_ = yym35
 76356  				if false {
 76357  				} else {
 76358  					r.EncodeUint(uint64(x.ModifyIndex))
 76359  				}
 76360  			} else {
 76361  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76362  				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
 76363  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76364  				yym36 := z.EncBinary()
 76365  				_ = yym36
 76366  				if false {
 76367  				} else {
 76368  					r.EncodeUint(uint64(x.ModifyIndex))
 76369  				}
 76370  			}
 76371  			if yyr2 || yy2arr2 {
 76372  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 76373  			} else {
 76374  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 76375  			}
 76376  		}
 76377  	}
 76378  }
 76379  
 76380  func (x *ACLToken) CodecDecodeSelf(d *codec1978.Decoder) {
 76381  	var h codecSelfer100
 76382  	z, r := codec1978.GenHelperDecoder(d)
 76383  	_, _, _ = h, z, r
 76384  	yym1 := z.DecBinary()
 76385  	_ = yym1
 76386  	if false {
 76387  	} else if z.HasExtensions() && z.DecExt(x) {
 76388  	} else {
 76389  		yyct2 := r.ContainerType()
 76390  		if yyct2 == codecSelferValueTypeMap100 {
 76391  			yyl2 := r.ReadMapStart()
 76392  			if yyl2 == 0 {
 76393  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 76394  			} else {
 76395  				x.codecDecodeSelfFromMap(yyl2, d)
 76396  			}
 76397  		} else if yyct2 == codecSelferValueTypeArray100 {
 76398  			yyl2 := r.ReadArrayStart()
 76399  			if yyl2 == 0 {
 76400  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76401  			} else {
 76402  				x.codecDecodeSelfFromArray(yyl2, d)
 76403  			}
 76404  		} else {
 76405  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 76406  		}
 76407  	}
 76408  }
 76409  
 76410  func (x *ACLToken) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 76411  	var h codecSelfer100
 76412  	z, r := codec1978.GenHelperDecoder(d)
 76413  	_, _, _ = h, z, r
 76414  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 76415  	_ = yys3Slc
 76416  	var yyhl3 bool = l >= 0
 76417  	for yyj3 := 0; ; yyj3++ {
 76418  		if yyhl3 {
 76419  			if yyj3 >= l {
 76420  				break
 76421  			}
 76422  		} else {
 76423  			if r.CheckBreak() {
 76424  				break
 76425  			}
 76426  		}
 76427  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 76428  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 76429  		yys3 := string(yys3Slc)
 76430  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 76431  		switch yys3 {
 76432  		case "AccessorID":
 76433  			if r.TryDecodeAsNil() {
 76434  				x.AccessorID = ""
 76435  			} else {
 76436  				yyv4 := &x.AccessorID
 76437  				yym5 := z.DecBinary()
 76438  				_ = yym5
 76439  				if false {
 76440  				} else {
 76441  					*((*string)(yyv4)) = r.DecodeString()
 76442  				}
 76443  			}
 76444  		case "SecretID":
 76445  			if r.TryDecodeAsNil() {
 76446  				x.SecretID = ""
 76447  			} else {
 76448  				yyv6 := &x.SecretID
 76449  				yym7 := z.DecBinary()
 76450  				_ = yym7
 76451  				if false {
 76452  				} else {
 76453  					*((*string)(yyv6)) = r.DecodeString()
 76454  				}
 76455  			}
 76456  		case "Name":
 76457  			if r.TryDecodeAsNil() {
 76458  				x.Name = ""
 76459  			} else {
 76460  				yyv8 := &x.Name
 76461  				yym9 := z.DecBinary()
 76462  				_ = yym9
 76463  				if false {
 76464  				} else {
 76465  					*((*string)(yyv8)) = r.DecodeString()
 76466  				}
 76467  			}
 76468  		case "Type":
 76469  			if r.TryDecodeAsNil() {
 76470  				x.Type = ""
 76471  			} else {
 76472  				yyv10 := &x.Type
 76473  				yym11 := z.DecBinary()
 76474  				_ = yym11
 76475  				if false {
 76476  				} else {
 76477  					*((*string)(yyv10)) = r.DecodeString()
 76478  				}
 76479  			}
 76480  		case "Policies":
 76481  			if r.TryDecodeAsNil() {
 76482  				x.Policies = nil
 76483  			} else {
 76484  				yyv12 := &x.Policies
 76485  				yym13 := z.DecBinary()
 76486  				_ = yym13
 76487  				if false {
 76488  				} else {
 76489  					z.F.DecSliceStringX(yyv12, false, d)
 76490  				}
 76491  			}
 76492  		case "Global":
 76493  			if r.TryDecodeAsNil() {
 76494  				x.Global = false
 76495  			} else {
 76496  				yyv14 := &x.Global
 76497  				yym15 := z.DecBinary()
 76498  				_ = yym15
 76499  				if false {
 76500  				} else {
 76501  					*((*bool)(yyv14)) = r.DecodeBool()
 76502  				}
 76503  			}
 76504  		case "Hash":
 76505  			if r.TryDecodeAsNil() {
 76506  				x.Hash = nil
 76507  			} else {
 76508  				yyv16 := &x.Hash
 76509  				yym17 := z.DecBinary()
 76510  				_ = yym17
 76511  				if false {
 76512  				} else {
 76513  					*yyv16 = r.DecodeBytes(*(*[]byte)(yyv16), false, false)
 76514  				}
 76515  			}
 76516  		case "CreateTime":
 76517  			if r.TryDecodeAsNil() {
 76518  				x.CreateTime = time.Time{}
 76519  			} else {
 76520  				yyv18 := &x.CreateTime
 76521  				yym19 := z.DecBinary()
 76522  				_ = yym19
 76523  				if false {
 76524  				} else if yym20 := z.TimeRtidIfBinc(); yym20 != 0 {
 76525  					r.DecodeBuiltin(yym20, yyv18)
 76526  				} else if z.HasExtensions() && z.DecExt(yyv18) {
 76527  				} else if yym19 {
 76528  					z.DecBinaryUnmarshal(yyv18)
 76529  				} else if !yym19 && z.IsJSONHandle() {
 76530  					z.DecJSONUnmarshal(yyv18)
 76531  				} else {
 76532  					z.DecFallback(yyv18, false)
 76533  				}
 76534  			}
 76535  		case "CreateIndex":
 76536  			if r.TryDecodeAsNil() {
 76537  				x.CreateIndex = 0
 76538  			} else {
 76539  				yyv21 := &x.CreateIndex
 76540  				yym22 := z.DecBinary()
 76541  				_ = yym22
 76542  				if false {
 76543  				} else {
 76544  					*((*uint64)(yyv21)) = uint64(r.DecodeUint(64))
 76545  				}
 76546  			}
 76547  		case "ModifyIndex":
 76548  			if r.TryDecodeAsNil() {
 76549  				x.ModifyIndex = 0
 76550  			} else {
 76551  				yyv23 := &x.ModifyIndex
 76552  				yym24 := z.DecBinary()
 76553  				_ = yym24
 76554  				if false {
 76555  				} else {
 76556  					*((*uint64)(yyv23)) = uint64(r.DecodeUint(64))
 76557  				}
 76558  			}
 76559  		default:
 76560  			z.DecStructFieldNotFound(-1, yys3)
 76561  		} // end switch yys3
 76562  	} // end for yyj3
 76563  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 76564  }
 76565  
 76566  func (x *ACLToken) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 76567  	var h codecSelfer100
 76568  	z, r := codec1978.GenHelperDecoder(d)
 76569  	_, _, _ = h, z, r
 76570  	var yyj25 int
 76571  	var yyb25 bool
 76572  	var yyhl25 bool = l >= 0
 76573  	yyj25++
 76574  	if yyhl25 {
 76575  		yyb25 = yyj25 > l
 76576  	} else {
 76577  		yyb25 = r.CheckBreak()
 76578  	}
 76579  	if yyb25 {
 76580  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76581  		return
 76582  	}
 76583  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76584  	if r.TryDecodeAsNil() {
 76585  		x.AccessorID = ""
 76586  	} else {
 76587  		yyv26 := &x.AccessorID
 76588  		yym27 := z.DecBinary()
 76589  		_ = yym27
 76590  		if false {
 76591  		} else {
 76592  			*((*string)(yyv26)) = r.DecodeString()
 76593  		}
 76594  	}
 76595  	yyj25++
 76596  	if yyhl25 {
 76597  		yyb25 = yyj25 > l
 76598  	} else {
 76599  		yyb25 = r.CheckBreak()
 76600  	}
 76601  	if yyb25 {
 76602  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76603  		return
 76604  	}
 76605  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76606  	if r.TryDecodeAsNil() {
 76607  		x.SecretID = ""
 76608  	} else {
 76609  		yyv28 := &x.SecretID
 76610  		yym29 := z.DecBinary()
 76611  		_ = yym29
 76612  		if false {
 76613  		} else {
 76614  			*((*string)(yyv28)) = r.DecodeString()
 76615  		}
 76616  	}
 76617  	yyj25++
 76618  	if yyhl25 {
 76619  		yyb25 = yyj25 > l
 76620  	} else {
 76621  		yyb25 = r.CheckBreak()
 76622  	}
 76623  	if yyb25 {
 76624  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76625  		return
 76626  	}
 76627  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76628  	if r.TryDecodeAsNil() {
 76629  		x.Name = ""
 76630  	} else {
 76631  		yyv30 := &x.Name
 76632  		yym31 := z.DecBinary()
 76633  		_ = yym31
 76634  		if false {
 76635  		} else {
 76636  			*((*string)(yyv30)) = r.DecodeString()
 76637  		}
 76638  	}
 76639  	yyj25++
 76640  	if yyhl25 {
 76641  		yyb25 = yyj25 > l
 76642  	} else {
 76643  		yyb25 = r.CheckBreak()
 76644  	}
 76645  	if yyb25 {
 76646  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76647  		return
 76648  	}
 76649  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76650  	if r.TryDecodeAsNil() {
 76651  		x.Type = ""
 76652  	} else {
 76653  		yyv32 := &x.Type
 76654  		yym33 := z.DecBinary()
 76655  		_ = yym33
 76656  		if false {
 76657  		} else {
 76658  			*((*string)(yyv32)) = r.DecodeString()
 76659  		}
 76660  	}
 76661  	yyj25++
 76662  	if yyhl25 {
 76663  		yyb25 = yyj25 > l
 76664  	} else {
 76665  		yyb25 = r.CheckBreak()
 76666  	}
 76667  	if yyb25 {
 76668  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76669  		return
 76670  	}
 76671  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76672  	if r.TryDecodeAsNil() {
 76673  		x.Policies = nil
 76674  	} else {
 76675  		yyv34 := &x.Policies
 76676  		yym35 := z.DecBinary()
 76677  		_ = yym35
 76678  		if false {
 76679  		} else {
 76680  			z.F.DecSliceStringX(yyv34, false, d)
 76681  		}
 76682  	}
 76683  	yyj25++
 76684  	if yyhl25 {
 76685  		yyb25 = yyj25 > l
 76686  	} else {
 76687  		yyb25 = r.CheckBreak()
 76688  	}
 76689  	if yyb25 {
 76690  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76691  		return
 76692  	}
 76693  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76694  	if r.TryDecodeAsNil() {
 76695  		x.Global = false
 76696  	} else {
 76697  		yyv36 := &x.Global
 76698  		yym37 := z.DecBinary()
 76699  		_ = yym37
 76700  		if false {
 76701  		} else {
 76702  			*((*bool)(yyv36)) = r.DecodeBool()
 76703  		}
 76704  	}
 76705  	yyj25++
 76706  	if yyhl25 {
 76707  		yyb25 = yyj25 > l
 76708  	} else {
 76709  		yyb25 = r.CheckBreak()
 76710  	}
 76711  	if yyb25 {
 76712  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76713  		return
 76714  	}
 76715  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76716  	if r.TryDecodeAsNil() {
 76717  		x.Hash = nil
 76718  	} else {
 76719  		yyv38 := &x.Hash
 76720  		yym39 := z.DecBinary()
 76721  		_ = yym39
 76722  		if false {
 76723  		} else {
 76724  			*yyv38 = r.DecodeBytes(*(*[]byte)(yyv38), false, false)
 76725  		}
 76726  	}
 76727  	yyj25++
 76728  	if yyhl25 {
 76729  		yyb25 = yyj25 > l
 76730  	} else {
 76731  		yyb25 = r.CheckBreak()
 76732  	}
 76733  	if yyb25 {
 76734  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76735  		return
 76736  	}
 76737  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76738  	if r.TryDecodeAsNil() {
 76739  		x.CreateTime = time.Time{}
 76740  	} else {
 76741  		yyv40 := &x.CreateTime
 76742  		yym41 := z.DecBinary()
 76743  		_ = yym41
 76744  		if false {
 76745  		} else if yym42 := z.TimeRtidIfBinc(); yym42 != 0 {
 76746  			r.DecodeBuiltin(yym42, yyv40)
 76747  		} else if z.HasExtensions() && z.DecExt(yyv40) {
 76748  		} else if yym41 {
 76749  			z.DecBinaryUnmarshal(yyv40)
 76750  		} else if !yym41 && z.IsJSONHandle() {
 76751  			z.DecJSONUnmarshal(yyv40)
 76752  		} else {
 76753  			z.DecFallback(yyv40, false)
 76754  		}
 76755  	}
 76756  	yyj25++
 76757  	if yyhl25 {
 76758  		yyb25 = yyj25 > l
 76759  	} else {
 76760  		yyb25 = r.CheckBreak()
 76761  	}
 76762  	if yyb25 {
 76763  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76764  		return
 76765  	}
 76766  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76767  	if r.TryDecodeAsNil() {
 76768  		x.CreateIndex = 0
 76769  	} else {
 76770  		yyv43 := &x.CreateIndex
 76771  		yym44 := z.DecBinary()
 76772  		_ = yym44
 76773  		if false {
 76774  		} else {
 76775  			*((*uint64)(yyv43)) = uint64(r.DecodeUint(64))
 76776  		}
 76777  	}
 76778  	yyj25++
 76779  	if yyhl25 {
 76780  		yyb25 = yyj25 > l
 76781  	} else {
 76782  		yyb25 = r.CheckBreak()
 76783  	}
 76784  	if yyb25 {
 76785  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76786  		return
 76787  	}
 76788  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76789  	if r.TryDecodeAsNil() {
 76790  		x.ModifyIndex = 0
 76791  	} else {
 76792  		yyv45 := &x.ModifyIndex
 76793  		yym46 := z.DecBinary()
 76794  		_ = yym46
 76795  		if false {
 76796  		} else {
 76797  			*((*uint64)(yyv45)) = uint64(r.DecodeUint(64))
 76798  		}
 76799  	}
 76800  	for {
 76801  		yyj25++
 76802  		if yyhl25 {
 76803  			yyb25 = yyj25 > l
 76804  		} else {
 76805  			yyb25 = r.CheckBreak()
 76806  		}
 76807  		if yyb25 {
 76808  			break
 76809  		}
 76810  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 76811  		z.DecStructFieldNotFound(yyj25-1, "")
 76812  	}
 76813  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 76814  }
 76815  
 76816  func (x *ACLTokenListStub) CodecEncodeSelf(e *codec1978.Encoder) {
 76817  	var h codecSelfer100
 76818  	z, r := codec1978.GenHelperEncoder(e)
 76819  	_, _, _ = h, z, r
 76820  	if x == nil {
 76821  		r.EncodeNil()
 76822  	} else {
 76823  		yym1 := z.EncBinary()
 76824  		_ = yym1
 76825  		if false {
 76826  		} else if z.HasExtensions() && z.EncExt(x) {
 76827  		} else {
 76828  			yysep2 := !z.EncBinary()
 76829  			yy2arr2 := z.EncBasicHandle().StructToArray
 76830  			var yyq2 [9]bool
 76831  			_, _, _ = yysep2, yyq2, yy2arr2
 76832  			const yyr2 bool = false
 76833  			var yynn2 int
 76834  			if yyr2 || yy2arr2 {
 76835  				r.EncodeArrayStart(9)
 76836  			} else {
 76837  				yynn2 = 9
 76838  				for _, b := range yyq2 {
 76839  					if b {
 76840  						yynn2++
 76841  					}
 76842  				}
 76843  				r.EncodeMapStart(yynn2)
 76844  				yynn2 = 0
 76845  			}
 76846  			if yyr2 || yy2arr2 {
 76847  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76848  				yym4 := z.EncBinary()
 76849  				_ = yym4
 76850  				if false {
 76851  				} else {
 76852  					r.EncodeString(codecSelferC_UTF8100, string(x.AccessorID))
 76853  				}
 76854  			} else {
 76855  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76856  				r.EncodeString(codecSelferC_UTF8100, string("AccessorID"))
 76857  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76858  				yym5 := z.EncBinary()
 76859  				_ = yym5
 76860  				if false {
 76861  				} else {
 76862  					r.EncodeString(codecSelferC_UTF8100, string(x.AccessorID))
 76863  				}
 76864  			}
 76865  			if yyr2 || yy2arr2 {
 76866  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76867  				yym7 := z.EncBinary()
 76868  				_ = yym7
 76869  				if false {
 76870  				} else {
 76871  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 76872  				}
 76873  			} else {
 76874  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76875  				r.EncodeString(codecSelferC_UTF8100, string("Name"))
 76876  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76877  				yym8 := z.EncBinary()
 76878  				_ = yym8
 76879  				if false {
 76880  				} else {
 76881  					r.EncodeString(codecSelferC_UTF8100, string(x.Name))
 76882  				}
 76883  			}
 76884  			if yyr2 || yy2arr2 {
 76885  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76886  				yym10 := z.EncBinary()
 76887  				_ = yym10
 76888  				if false {
 76889  				} else {
 76890  					r.EncodeString(codecSelferC_UTF8100, string(x.Type))
 76891  				}
 76892  			} else {
 76893  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76894  				r.EncodeString(codecSelferC_UTF8100, string("Type"))
 76895  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76896  				yym11 := z.EncBinary()
 76897  				_ = yym11
 76898  				if false {
 76899  				} else {
 76900  					r.EncodeString(codecSelferC_UTF8100, string(x.Type))
 76901  				}
 76902  			}
 76903  			if yyr2 || yy2arr2 {
 76904  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76905  				if x.Policies == nil {
 76906  					r.EncodeNil()
 76907  				} else {
 76908  					yym13 := z.EncBinary()
 76909  					_ = yym13
 76910  					if false {
 76911  					} else {
 76912  						z.F.EncSliceStringV(x.Policies, false, e)
 76913  					}
 76914  				}
 76915  			} else {
 76916  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76917  				r.EncodeString(codecSelferC_UTF8100, string("Policies"))
 76918  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76919  				if x.Policies == nil {
 76920  					r.EncodeNil()
 76921  				} else {
 76922  					yym14 := z.EncBinary()
 76923  					_ = yym14
 76924  					if false {
 76925  					} else {
 76926  						z.F.EncSliceStringV(x.Policies, false, e)
 76927  					}
 76928  				}
 76929  			}
 76930  			if yyr2 || yy2arr2 {
 76931  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76932  				yym16 := z.EncBinary()
 76933  				_ = yym16
 76934  				if false {
 76935  				} else {
 76936  					r.EncodeBool(bool(x.Global))
 76937  				}
 76938  			} else {
 76939  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76940  				r.EncodeString(codecSelferC_UTF8100, string("Global"))
 76941  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76942  				yym17 := z.EncBinary()
 76943  				_ = yym17
 76944  				if false {
 76945  				} else {
 76946  					r.EncodeBool(bool(x.Global))
 76947  				}
 76948  			}
 76949  			if yyr2 || yy2arr2 {
 76950  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76951  				if x.Hash == nil {
 76952  					r.EncodeNil()
 76953  				} else {
 76954  					yym19 := z.EncBinary()
 76955  					_ = yym19
 76956  					if false {
 76957  					} else {
 76958  						r.EncodeStringBytes(codecSelferC_RAW100, []byte(x.Hash))
 76959  					}
 76960  				}
 76961  			} else {
 76962  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76963  				r.EncodeString(codecSelferC_UTF8100, string("Hash"))
 76964  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76965  				if x.Hash == nil {
 76966  					r.EncodeNil()
 76967  				} else {
 76968  					yym20 := z.EncBinary()
 76969  					_ = yym20
 76970  					if false {
 76971  					} else {
 76972  						r.EncodeStringBytes(codecSelferC_RAW100, []byte(x.Hash))
 76973  					}
 76974  				}
 76975  			}
 76976  			if yyr2 || yy2arr2 {
 76977  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 76978  				yy22 := &x.CreateTime
 76979  				yym23 := z.EncBinary()
 76980  				_ = yym23
 76981  				if false {
 76982  				} else if yym24 := z.TimeRtidIfBinc(); yym24 != 0 {
 76983  					r.EncodeBuiltin(yym24, yy22)
 76984  				} else if z.HasExtensions() && z.EncExt(yy22) {
 76985  				} else if yym23 {
 76986  					z.EncBinaryMarshal(yy22)
 76987  				} else if !yym23 && z.IsJSONHandle() {
 76988  					z.EncJSONMarshal(yy22)
 76989  				} else {
 76990  					z.EncFallback(yy22)
 76991  				}
 76992  			} else {
 76993  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 76994  				r.EncodeString(codecSelferC_UTF8100, string("CreateTime"))
 76995  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 76996  				yy25 := &x.CreateTime
 76997  				yym26 := z.EncBinary()
 76998  				_ = yym26
 76999  				if false {
 77000  				} else if yym27 := z.TimeRtidIfBinc(); yym27 != 0 {
 77001  					r.EncodeBuiltin(yym27, yy25)
 77002  				} else if z.HasExtensions() && z.EncExt(yy25) {
 77003  				} else if yym26 {
 77004  					z.EncBinaryMarshal(yy25)
 77005  				} else if !yym26 && z.IsJSONHandle() {
 77006  					z.EncJSONMarshal(yy25)
 77007  				} else {
 77008  					z.EncFallback(yy25)
 77009  				}
 77010  			}
 77011  			if yyr2 || yy2arr2 {
 77012  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 77013  				yym29 := z.EncBinary()
 77014  				_ = yym29
 77015  				if false {
 77016  				} else {
 77017  					r.EncodeUint(uint64(x.CreateIndex))
 77018  				}
 77019  			} else {
 77020  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 77021  				r.EncodeString(codecSelferC_UTF8100, string("CreateIndex"))
 77022  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 77023  				yym30 := z.EncBinary()
 77024  				_ = yym30
 77025  				if false {
 77026  				} else {
 77027  					r.EncodeUint(uint64(x.CreateIndex))
 77028  				}
 77029  			}
 77030  			if yyr2 || yy2arr2 {
 77031  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 77032  				yym32 := z.EncBinary()
 77033  				_ = yym32
 77034  				if false {
 77035  				} else {
 77036  					r.EncodeUint(uint64(x.ModifyIndex))
 77037  				}
 77038  			} else {
 77039  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 77040  				r.EncodeString(codecSelferC_UTF8100, string("ModifyIndex"))
 77041  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 77042  				yym33 := z.EncBinary()
 77043  				_ = yym33
 77044  				if false {
 77045  				} else {
 77046  					r.EncodeUint(uint64(x.ModifyIndex))
 77047  				}
 77048  			}
 77049  			if yyr2 || yy2arr2 {
 77050  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 77051  			} else {
 77052  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 77053  			}
 77054  		}
 77055  	}
 77056  }
 77057  
 77058  func (x *ACLTokenListStub) CodecDecodeSelf(d *codec1978.Decoder) {
 77059  	var h codecSelfer100
 77060  	z, r := codec1978.GenHelperDecoder(d)
 77061  	_, _, _ = h, z, r
 77062  	yym1 := z.DecBinary()
 77063  	_ = yym1
 77064  	if false {
 77065  	} else if z.HasExtensions() && z.DecExt(x) {
 77066  	} else {
 77067  		yyct2 := r.ContainerType()
 77068  		if yyct2 == codecSelferValueTypeMap100 {
 77069  			yyl2 := r.ReadMapStart()
 77070  			if yyl2 == 0 {
 77071  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 77072  			} else {
 77073  				x.codecDecodeSelfFromMap(yyl2, d)
 77074  			}
 77075  		} else if yyct2 == codecSelferValueTypeArray100 {
 77076  			yyl2 := r.ReadArrayStart()
 77077  			if yyl2 == 0 {
 77078  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77079  			} else {
 77080  				x.codecDecodeSelfFromArray(yyl2, d)
 77081  			}
 77082  		} else {
 77083  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 77084  		}
 77085  	}
 77086  }
 77087  
 77088  func (x *ACLTokenListStub) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 77089  	var h codecSelfer100
 77090  	z, r := codec1978.GenHelperDecoder(d)
 77091  	_, _, _ = h, z, r
 77092  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 77093  	_ = yys3Slc
 77094  	var yyhl3 bool = l >= 0
 77095  	for yyj3 := 0; ; yyj3++ {
 77096  		if yyhl3 {
 77097  			if yyj3 >= l {
 77098  				break
 77099  			}
 77100  		} else {
 77101  			if r.CheckBreak() {
 77102  				break
 77103  			}
 77104  		}
 77105  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 77106  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 77107  		yys3 := string(yys3Slc)
 77108  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 77109  		switch yys3 {
 77110  		case "AccessorID":
 77111  			if r.TryDecodeAsNil() {
 77112  				x.AccessorID = ""
 77113  			} else {
 77114  				yyv4 := &x.AccessorID
 77115  				yym5 := z.DecBinary()
 77116  				_ = yym5
 77117  				if false {
 77118  				} else {
 77119  					*((*string)(yyv4)) = r.DecodeString()
 77120  				}
 77121  			}
 77122  		case "Name":
 77123  			if r.TryDecodeAsNil() {
 77124  				x.Name = ""
 77125  			} else {
 77126  				yyv6 := &x.Name
 77127  				yym7 := z.DecBinary()
 77128  				_ = yym7
 77129  				if false {
 77130  				} else {
 77131  					*((*string)(yyv6)) = r.DecodeString()
 77132  				}
 77133  			}
 77134  		case "Type":
 77135  			if r.TryDecodeAsNil() {
 77136  				x.Type = ""
 77137  			} else {
 77138  				yyv8 := &x.Type
 77139  				yym9 := z.DecBinary()
 77140  				_ = yym9
 77141  				if false {
 77142  				} else {
 77143  					*((*string)(yyv8)) = r.DecodeString()
 77144  				}
 77145  			}
 77146  		case "Policies":
 77147  			if r.TryDecodeAsNil() {
 77148  				x.Policies = nil
 77149  			} else {
 77150  				yyv10 := &x.Policies
 77151  				yym11 := z.DecBinary()
 77152  				_ = yym11
 77153  				if false {
 77154  				} else {
 77155  					z.F.DecSliceStringX(yyv10, false, d)
 77156  				}
 77157  			}
 77158  		case "Global":
 77159  			if r.TryDecodeAsNil() {
 77160  				x.Global = false
 77161  			} else {
 77162  				yyv12 := &x.Global
 77163  				yym13 := z.DecBinary()
 77164  				_ = yym13
 77165  				if false {
 77166  				} else {
 77167  					*((*bool)(yyv12)) = r.DecodeBool()
 77168  				}
 77169  			}
 77170  		case "Hash":
 77171  			if r.TryDecodeAsNil() {
 77172  				x.Hash = nil
 77173  			} else {
 77174  				yyv14 := &x.Hash
 77175  				yym15 := z.DecBinary()
 77176  				_ = yym15
 77177  				if false {
 77178  				} else {
 77179  					*yyv14 = r.DecodeBytes(*(*[]byte)(yyv14), false, false)
 77180  				}
 77181  			}
 77182  		case "CreateTime":
 77183  			if r.TryDecodeAsNil() {
 77184  				x.CreateTime = time.Time{}
 77185  			} else {
 77186  				yyv16 := &x.CreateTime
 77187  				yym17 := z.DecBinary()
 77188  				_ = yym17
 77189  				if false {
 77190  				} else if yym18 := z.TimeRtidIfBinc(); yym18 != 0 {
 77191  					r.DecodeBuiltin(yym18, yyv16)
 77192  				} else if z.HasExtensions() && z.DecExt(yyv16) {
 77193  				} else if yym17 {
 77194  					z.DecBinaryUnmarshal(yyv16)
 77195  				} else if !yym17 && z.IsJSONHandle() {
 77196  					z.DecJSONUnmarshal(yyv16)
 77197  				} else {
 77198  					z.DecFallback(yyv16, false)
 77199  				}
 77200  			}
 77201  		case "CreateIndex":
 77202  			if r.TryDecodeAsNil() {
 77203  				x.CreateIndex = 0
 77204  			} else {
 77205  				yyv19 := &x.CreateIndex
 77206  				yym20 := z.DecBinary()
 77207  				_ = yym20
 77208  				if false {
 77209  				} else {
 77210  					*((*uint64)(yyv19)) = uint64(r.DecodeUint(64))
 77211  				}
 77212  			}
 77213  		case "ModifyIndex":
 77214  			if r.TryDecodeAsNil() {
 77215  				x.ModifyIndex = 0
 77216  			} else {
 77217  				yyv21 := &x.ModifyIndex
 77218  				yym22 := z.DecBinary()
 77219  				_ = yym22
 77220  				if false {
 77221  				} else {
 77222  					*((*uint64)(yyv21)) = uint64(r.DecodeUint(64))
 77223  				}
 77224  			}
 77225  		default:
 77226  			z.DecStructFieldNotFound(-1, yys3)
 77227  		} // end switch yys3
 77228  	} // end for yyj3
 77229  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 77230  }
 77231  
 77232  func (x *ACLTokenListStub) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 77233  	var h codecSelfer100
 77234  	z, r := codec1978.GenHelperDecoder(d)
 77235  	_, _, _ = h, z, r
 77236  	var yyj23 int
 77237  	var yyb23 bool
 77238  	var yyhl23 bool = l >= 0
 77239  	yyj23++
 77240  	if yyhl23 {
 77241  		yyb23 = yyj23 > l
 77242  	} else {
 77243  		yyb23 = r.CheckBreak()
 77244  	}
 77245  	if yyb23 {
 77246  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77247  		return
 77248  	}
 77249  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77250  	if r.TryDecodeAsNil() {
 77251  		x.AccessorID = ""
 77252  	} else {
 77253  		yyv24 := &x.AccessorID
 77254  		yym25 := z.DecBinary()
 77255  		_ = yym25
 77256  		if false {
 77257  		} else {
 77258  			*((*string)(yyv24)) = r.DecodeString()
 77259  		}
 77260  	}
 77261  	yyj23++
 77262  	if yyhl23 {
 77263  		yyb23 = yyj23 > l
 77264  	} else {
 77265  		yyb23 = r.CheckBreak()
 77266  	}
 77267  	if yyb23 {
 77268  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77269  		return
 77270  	}
 77271  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77272  	if r.TryDecodeAsNil() {
 77273  		x.Name = ""
 77274  	} else {
 77275  		yyv26 := &x.Name
 77276  		yym27 := z.DecBinary()
 77277  		_ = yym27
 77278  		if false {
 77279  		} else {
 77280  			*((*string)(yyv26)) = r.DecodeString()
 77281  		}
 77282  	}
 77283  	yyj23++
 77284  	if yyhl23 {
 77285  		yyb23 = yyj23 > l
 77286  	} else {
 77287  		yyb23 = r.CheckBreak()
 77288  	}
 77289  	if yyb23 {
 77290  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77291  		return
 77292  	}
 77293  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77294  	if r.TryDecodeAsNil() {
 77295  		x.Type = ""
 77296  	} else {
 77297  		yyv28 := &x.Type
 77298  		yym29 := z.DecBinary()
 77299  		_ = yym29
 77300  		if false {
 77301  		} else {
 77302  			*((*string)(yyv28)) = r.DecodeString()
 77303  		}
 77304  	}
 77305  	yyj23++
 77306  	if yyhl23 {
 77307  		yyb23 = yyj23 > l
 77308  	} else {
 77309  		yyb23 = r.CheckBreak()
 77310  	}
 77311  	if yyb23 {
 77312  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77313  		return
 77314  	}
 77315  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77316  	if r.TryDecodeAsNil() {
 77317  		x.Policies = nil
 77318  	} else {
 77319  		yyv30 := &x.Policies
 77320  		yym31 := z.DecBinary()
 77321  		_ = yym31
 77322  		if false {
 77323  		} else {
 77324  			z.F.DecSliceStringX(yyv30, false, d)
 77325  		}
 77326  	}
 77327  	yyj23++
 77328  	if yyhl23 {
 77329  		yyb23 = yyj23 > l
 77330  	} else {
 77331  		yyb23 = r.CheckBreak()
 77332  	}
 77333  	if yyb23 {
 77334  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77335  		return
 77336  	}
 77337  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77338  	if r.TryDecodeAsNil() {
 77339  		x.Global = false
 77340  	} else {
 77341  		yyv32 := &x.Global
 77342  		yym33 := z.DecBinary()
 77343  		_ = yym33
 77344  		if false {
 77345  		} else {
 77346  			*((*bool)(yyv32)) = r.DecodeBool()
 77347  		}
 77348  	}
 77349  	yyj23++
 77350  	if yyhl23 {
 77351  		yyb23 = yyj23 > l
 77352  	} else {
 77353  		yyb23 = r.CheckBreak()
 77354  	}
 77355  	if yyb23 {
 77356  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77357  		return
 77358  	}
 77359  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77360  	if r.TryDecodeAsNil() {
 77361  		x.Hash = nil
 77362  	} else {
 77363  		yyv34 := &x.Hash
 77364  		yym35 := z.DecBinary()
 77365  		_ = yym35
 77366  		if false {
 77367  		} else {
 77368  			*yyv34 = r.DecodeBytes(*(*[]byte)(yyv34), false, false)
 77369  		}
 77370  	}
 77371  	yyj23++
 77372  	if yyhl23 {
 77373  		yyb23 = yyj23 > l
 77374  	} else {
 77375  		yyb23 = r.CheckBreak()
 77376  	}
 77377  	if yyb23 {
 77378  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77379  		return
 77380  	}
 77381  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77382  	if r.TryDecodeAsNil() {
 77383  		x.CreateTime = time.Time{}
 77384  	} else {
 77385  		yyv36 := &x.CreateTime
 77386  		yym37 := z.DecBinary()
 77387  		_ = yym37
 77388  		if false {
 77389  		} else if yym38 := z.TimeRtidIfBinc(); yym38 != 0 {
 77390  			r.DecodeBuiltin(yym38, yyv36)
 77391  		} else if z.HasExtensions() && z.DecExt(yyv36) {
 77392  		} else if yym37 {
 77393  			z.DecBinaryUnmarshal(yyv36)
 77394  		} else if !yym37 && z.IsJSONHandle() {
 77395  			z.DecJSONUnmarshal(yyv36)
 77396  		} else {
 77397  			z.DecFallback(yyv36, false)
 77398  		}
 77399  	}
 77400  	yyj23++
 77401  	if yyhl23 {
 77402  		yyb23 = yyj23 > l
 77403  	} else {
 77404  		yyb23 = r.CheckBreak()
 77405  	}
 77406  	if yyb23 {
 77407  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77408  		return
 77409  	}
 77410  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77411  	if r.TryDecodeAsNil() {
 77412  		x.CreateIndex = 0
 77413  	} else {
 77414  		yyv39 := &x.CreateIndex
 77415  		yym40 := z.DecBinary()
 77416  		_ = yym40
 77417  		if false {
 77418  		} else {
 77419  			*((*uint64)(yyv39)) = uint64(r.DecodeUint(64))
 77420  		}
 77421  	}
 77422  	yyj23++
 77423  	if yyhl23 {
 77424  		yyb23 = yyj23 > l
 77425  	} else {
 77426  		yyb23 = r.CheckBreak()
 77427  	}
 77428  	if yyb23 {
 77429  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77430  		return
 77431  	}
 77432  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77433  	if r.TryDecodeAsNil() {
 77434  		x.ModifyIndex = 0
 77435  	} else {
 77436  		yyv41 := &x.ModifyIndex
 77437  		yym42 := z.DecBinary()
 77438  		_ = yym42
 77439  		if false {
 77440  		} else {
 77441  			*((*uint64)(yyv41)) = uint64(r.DecodeUint(64))
 77442  		}
 77443  	}
 77444  	for {
 77445  		yyj23++
 77446  		if yyhl23 {
 77447  			yyb23 = yyj23 > l
 77448  		} else {
 77449  			yyb23 = r.CheckBreak()
 77450  		}
 77451  		if yyb23 {
 77452  			break
 77453  		}
 77454  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77455  		z.DecStructFieldNotFound(yyj23-1, "")
 77456  	}
 77457  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77458  }
 77459  
 77460  func (x *ACLTokenListRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 77461  	var h codecSelfer100
 77462  	z, r := codec1978.GenHelperEncoder(e)
 77463  	_, _, _ = h, z, r
 77464  	if x == nil {
 77465  		r.EncodeNil()
 77466  	} else {
 77467  		yym1 := z.EncBinary()
 77468  		_ = yym1
 77469  		if false {
 77470  		} else if z.HasExtensions() && z.EncExt(x) {
 77471  		} else {
 77472  			yysep2 := !z.EncBinary()
 77473  			yy2arr2 := z.EncBasicHandle().StructToArray
 77474  			var yyq2 [9]bool
 77475  			_, _, _ = yysep2, yyq2, yy2arr2
 77476  			const yyr2 bool = false
 77477  			var yynn2 int
 77478  			if yyr2 || yy2arr2 {
 77479  				r.EncodeArrayStart(9)
 77480  			} else {
 77481  				yynn2 = 9
 77482  				for _, b := range yyq2 {
 77483  					if b {
 77484  						yynn2++
 77485  					}
 77486  				}
 77487  				r.EncodeMapStart(yynn2)
 77488  				yynn2 = 0
 77489  			}
 77490  			if yyr2 || yy2arr2 {
 77491  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 77492  				yym4 := z.EncBinary()
 77493  				_ = yym4
 77494  				if false {
 77495  				} else {
 77496  					r.EncodeBool(bool(x.GlobalOnly))
 77497  				}
 77498  			} else {
 77499  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 77500  				r.EncodeString(codecSelferC_UTF8100, string("GlobalOnly"))
 77501  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 77502  				yym5 := z.EncBinary()
 77503  				_ = yym5
 77504  				if false {
 77505  				} else {
 77506  					r.EncodeBool(bool(x.GlobalOnly))
 77507  				}
 77508  			}
 77509  			if yyr2 || yy2arr2 {
 77510  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 77511  				yym7 := z.EncBinary()
 77512  				_ = yym7
 77513  				if false {
 77514  				} else {
 77515  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 77516  				}
 77517  			} else {
 77518  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 77519  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 77520  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 77521  				yym8 := z.EncBinary()
 77522  				_ = yym8
 77523  				if false {
 77524  				} else {
 77525  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 77526  				}
 77527  			}
 77528  			if yyr2 || yy2arr2 {
 77529  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 77530  				yym10 := z.EncBinary()
 77531  				_ = yym10
 77532  				if false {
 77533  				} else {
 77534  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 77535  				}
 77536  			} else {
 77537  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 77538  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 77539  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 77540  				yym11 := z.EncBinary()
 77541  				_ = yym11
 77542  				if false {
 77543  				} else {
 77544  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 77545  				}
 77546  			}
 77547  			if yyr2 || yy2arr2 {
 77548  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 77549  				yym13 := z.EncBinary()
 77550  				_ = yym13
 77551  				if false {
 77552  				} else {
 77553  					r.EncodeUint(uint64(x.MinQueryIndex))
 77554  				}
 77555  			} else {
 77556  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 77557  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 77558  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 77559  				yym14 := z.EncBinary()
 77560  				_ = yym14
 77561  				if false {
 77562  				} else {
 77563  					r.EncodeUint(uint64(x.MinQueryIndex))
 77564  				}
 77565  			}
 77566  			if yyr2 || yy2arr2 {
 77567  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 77568  				yym16 := z.EncBinary()
 77569  				_ = yym16
 77570  				if false {
 77571  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 77572  				} else {
 77573  					r.EncodeInt(int64(x.MaxQueryTime))
 77574  				}
 77575  			} else {
 77576  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 77577  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 77578  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 77579  				yym17 := z.EncBinary()
 77580  				_ = yym17
 77581  				if false {
 77582  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 77583  				} else {
 77584  					r.EncodeInt(int64(x.MaxQueryTime))
 77585  				}
 77586  			}
 77587  			if yyr2 || yy2arr2 {
 77588  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 77589  				yym19 := z.EncBinary()
 77590  				_ = yym19
 77591  				if false {
 77592  				} else {
 77593  					r.EncodeBool(bool(x.AllowStale))
 77594  				}
 77595  			} else {
 77596  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 77597  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 77598  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 77599  				yym20 := z.EncBinary()
 77600  				_ = yym20
 77601  				if false {
 77602  				} else {
 77603  					r.EncodeBool(bool(x.AllowStale))
 77604  				}
 77605  			}
 77606  			if yyr2 || yy2arr2 {
 77607  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 77608  				yym22 := z.EncBinary()
 77609  				_ = yym22
 77610  				if false {
 77611  				} else {
 77612  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 77613  				}
 77614  			} else {
 77615  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 77616  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 77617  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 77618  				yym23 := z.EncBinary()
 77619  				_ = yym23
 77620  				if false {
 77621  				} else {
 77622  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 77623  				}
 77624  			}
 77625  			if yyr2 || yy2arr2 {
 77626  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 77627  				yym25 := z.EncBinary()
 77628  				_ = yym25
 77629  				if false {
 77630  				} else {
 77631  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 77632  				}
 77633  			} else {
 77634  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 77635  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 77636  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 77637  				yym26 := z.EncBinary()
 77638  				_ = yym26
 77639  				if false {
 77640  				} else {
 77641  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 77642  				}
 77643  			}
 77644  			if yyr2 || yy2arr2 {
 77645  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 77646  				yym28 := z.EncBinary()
 77647  				_ = yym28
 77648  				if false {
 77649  				} else {
 77650  					r.EncodeBool(bool(x.Forwarded))
 77651  				}
 77652  			} else {
 77653  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 77654  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 77655  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 77656  				yym29 := z.EncBinary()
 77657  				_ = yym29
 77658  				if false {
 77659  				} else {
 77660  					r.EncodeBool(bool(x.Forwarded))
 77661  				}
 77662  			}
 77663  			if yyr2 || yy2arr2 {
 77664  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 77665  			} else {
 77666  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 77667  			}
 77668  		}
 77669  	}
 77670  }
 77671  
 77672  func (x *ACLTokenListRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 77673  	var h codecSelfer100
 77674  	z, r := codec1978.GenHelperDecoder(d)
 77675  	_, _, _ = h, z, r
 77676  	yym1 := z.DecBinary()
 77677  	_ = yym1
 77678  	if false {
 77679  	} else if z.HasExtensions() && z.DecExt(x) {
 77680  	} else {
 77681  		yyct2 := r.ContainerType()
 77682  		if yyct2 == codecSelferValueTypeMap100 {
 77683  			yyl2 := r.ReadMapStart()
 77684  			if yyl2 == 0 {
 77685  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 77686  			} else {
 77687  				x.codecDecodeSelfFromMap(yyl2, d)
 77688  			}
 77689  		} else if yyct2 == codecSelferValueTypeArray100 {
 77690  			yyl2 := r.ReadArrayStart()
 77691  			if yyl2 == 0 {
 77692  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77693  			} else {
 77694  				x.codecDecodeSelfFromArray(yyl2, d)
 77695  			}
 77696  		} else {
 77697  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 77698  		}
 77699  	}
 77700  }
 77701  
 77702  func (x *ACLTokenListRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 77703  	var h codecSelfer100
 77704  	z, r := codec1978.GenHelperDecoder(d)
 77705  	_, _, _ = h, z, r
 77706  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 77707  	_ = yys3Slc
 77708  	var yyhl3 bool = l >= 0
 77709  	for yyj3 := 0; ; yyj3++ {
 77710  		if yyhl3 {
 77711  			if yyj3 >= l {
 77712  				break
 77713  			}
 77714  		} else {
 77715  			if r.CheckBreak() {
 77716  				break
 77717  			}
 77718  		}
 77719  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 77720  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 77721  		yys3 := string(yys3Slc)
 77722  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 77723  		switch yys3 {
 77724  		case "GlobalOnly":
 77725  			if r.TryDecodeAsNil() {
 77726  				x.GlobalOnly = false
 77727  			} else {
 77728  				yyv4 := &x.GlobalOnly
 77729  				yym5 := z.DecBinary()
 77730  				_ = yym5
 77731  				if false {
 77732  				} else {
 77733  					*((*bool)(yyv4)) = r.DecodeBool()
 77734  				}
 77735  			}
 77736  		case "Region":
 77737  			if r.TryDecodeAsNil() {
 77738  				x.Region = ""
 77739  			} else {
 77740  				yyv6 := &x.Region
 77741  				yym7 := z.DecBinary()
 77742  				_ = yym7
 77743  				if false {
 77744  				} else {
 77745  					*((*string)(yyv6)) = r.DecodeString()
 77746  				}
 77747  			}
 77748  		case "Namespace":
 77749  			if r.TryDecodeAsNil() {
 77750  				x.Namespace = ""
 77751  			} else {
 77752  				yyv8 := &x.Namespace
 77753  				yym9 := z.DecBinary()
 77754  				_ = yym9
 77755  				if false {
 77756  				} else {
 77757  					*((*string)(yyv8)) = r.DecodeString()
 77758  				}
 77759  			}
 77760  		case "MinQueryIndex":
 77761  			if r.TryDecodeAsNil() {
 77762  				x.MinQueryIndex = 0
 77763  			} else {
 77764  				yyv10 := &x.MinQueryIndex
 77765  				yym11 := z.DecBinary()
 77766  				_ = yym11
 77767  				if false {
 77768  				} else {
 77769  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 77770  				}
 77771  			}
 77772  		case "MaxQueryTime":
 77773  			if r.TryDecodeAsNil() {
 77774  				x.MaxQueryTime = 0
 77775  			} else {
 77776  				yyv12 := &x.MaxQueryTime
 77777  				yym13 := z.DecBinary()
 77778  				_ = yym13
 77779  				if false {
 77780  				} else if z.HasExtensions() && z.DecExt(yyv12) {
 77781  				} else {
 77782  					*((*int64)(yyv12)) = int64(r.DecodeInt(64))
 77783  				}
 77784  			}
 77785  		case "AllowStale":
 77786  			if r.TryDecodeAsNil() {
 77787  				x.AllowStale = false
 77788  			} else {
 77789  				yyv14 := &x.AllowStale
 77790  				yym15 := z.DecBinary()
 77791  				_ = yym15
 77792  				if false {
 77793  				} else {
 77794  					*((*bool)(yyv14)) = r.DecodeBool()
 77795  				}
 77796  			}
 77797  		case "Prefix":
 77798  			if r.TryDecodeAsNil() {
 77799  				x.Prefix = ""
 77800  			} else {
 77801  				yyv16 := &x.Prefix
 77802  				yym17 := z.DecBinary()
 77803  				_ = yym17
 77804  				if false {
 77805  				} else {
 77806  					*((*string)(yyv16)) = r.DecodeString()
 77807  				}
 77808  			}
 77809  		case "AuthToken":
 77810  			if r.TryDecodeAsNil() {
 77811  				x.AuthToken = ""
 77812  			} else {
 77813  				yyv18 := &x.AuthToken
 77814  				yym19 := z.DecBinary()
 77815  				_ = yym19
 77816  				if false {
 77817  				} else {
 77818  					*((*string)(yyv18)) = r.DecodeString()
 77819  				}
 77820  			}
 77821  		case "Forwarded":
 77822  			if r.TryDecodeAsNil() {
 77823  				x.Forwarded = false
 77824  			} else {
 77825  				yyv20 := &x.Forwarded
 77826  				yym21 := z.DecBinary()
 77827  				_ = yym21
 77828  				if false {
 77829  				} else {
 77830  					*((*bool)(yyv20)) = r.DecodeBool()
 77831  				}
 77832  			}
 77833  		default:
 77834  			z.DecStructFieldNotFound(-1, yys3)
 77835  		} // end switch yys3
 77836  	} // end for yyj3
 77837  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 77838  }
 77839  
 77840  func (x *ACLTokenListRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 77841  	var h codecSelfer100
 77842  	z, r := codec1978.GenHelperDecoder(d)
 77843  	_, _, _ = h, z, r
 77844  	var yyj22 int
 77845  	var yyb22 bool
 77846  	var yyhl22 bool = l >= 0
 77847  	yyj22++
 77848  	if yyhl22 {
 77849  		yyb22 = yyj22 > l
 77850  	} else {
 77851  		yyb22 = r.CheckBreak()
 77852  	}
 77853  	if yyb22 {
 77854  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77855  		return
 77856  	}
 77857  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77858  	if r.TryDecodeAsNil() {
 77859  		x.GlobalOnly = false
 77860  	} else {
 77861  		yyv23 := &x.GlobalOnly
 77862  		yym24 := z.DecBinary()
 77863  		_ = yym24
 77864  		if false {
 77865  		} else {
 77866  			*((*bool)(yyv23)) = r.DecodeBool()
 77867  		}
 77868  	}
 77869  	yyj22++
 77870  	if yyhl22 {
 77871  		yyb22 = yyj22 > l
 77872  	} else {
 77873  		yyb22 = r.CheckBreak()
 77874  	}
 77875  	if yyb22 {
 77876  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77877  		return
 77878  	}
 77879  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77880  	if r.TryDecodeAsNil() {
 77881  		x.Region = ""
 77882  	} else {
 77883  		yyv25 := &x.Region
 77884  		yym26 := z.DecBinary()
 77885  		_ = yym26
 77886  		if false {
 77887  		} else {
 77888  			*((*string)(yyv25)) = r.DecodeString()
 77889  		}
 77890  	}
 77891  	yyj22++
 77892  	if yyhl22 {
 77893  		yyb22 = yyj22 > l
 77894  	} else {
 77895  		yyb22 = r.CheckBreak()
 77896  	}
 77897  	if yyb22 {
 77898  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77899  		return
 77900  	}
 77901  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77902  	if r.TryDecodeAsNil() {
 77903  		x.Namespace = ""
 77904  	} else {
 77905  		yyv27 := &x.Namespace
 77906  		yym28 := z.DecBinary()
 77907  		_ = yym28
 77908  		if false {
 77909  		} else {
 77910  			*((*string)(yyv27)) = r.DecodeString()
 77911  		}
 77912  	}
 77913  	yyj22++
 77914  	if yyhl22 {
 77915  		yyb22 = yyj22 > l
 77916  	} else {
 77917  		yyb22 = r.CheckBreak()
 77918  	}
 77919  	if yyb22 {
 77920  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77921  		return
 77922  	}
 77923  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77924  	if r.TryDecodeAsNil() {
 77925  		x.MinQueryIndex = 0
 77926  	} else {
 77927  		yyv29 := &x.MinQueryIndex
 77928  		yym30 := z.DecBinary()
 77929  		_ = yym30
 77930  		if false {
 77931  		} else {
 77932  			*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
 77933  		}
 77934  	}
 77935  	yyj22++
 77936  	if yyhl22 {
 77937  		yyb22 = yyj22 > l
 77938  	} else {
 77939  		yyb22 = r.CheckBreak()
 77940  	}
 77941  	if yyb22 {
 77942  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77943  		return
 77944  	}
 77945  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77946  	if r.TryDecodeAsNil() {
 77947  		x.MaxQueryTime = 0
 77948  	} else {
 77949  		yyv31 := &x.MaxQueryTime
 77950  		yym32 := z.DecBinary()
 77951  		_ = yym32
 77952  		if false {
 77953  		} else if z.HasExtensions() && z.DecExt(yyv31) {
 77954  		} else {
 77955  			*((*int64)(yyv31)) = int64(r.DecodeInt(64))
 77956  		}
 77957  	}
 77958  	yyj22++
 77959  	if yyhl22 {
 77960  		yyb22 = yyj22 > l
 77961  	} else {
 77962  		yyb22 = r.CheckBreak()
 77963  	}
 77964  	if yyb22 {
 77965  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77966  		return
 77967  	}
 77968  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77969  	if r.TryDecodeAsNil() {
 77970  		x.AllowStale = false
 77971  	} else {
 77972  		yyv33 := &x.AllowStale
 77973  		yym34 := z.DecBinary()
 77974  		_ = yym34
 77975  		if false {
 77976  		} else {
 77977  			*((*bool)(yyv33)) = r.DecodeBool()
 77978  		}
 77979  	}
 77980  	yyj22++
 77981  	if yyhl22 {
 77982  		yyb22 = yyj22 > l
 77983  	} else {
 77984  		yyb22 = r.CheckBreak()
 77985  	}
 77986  	if yyb22 {
 77987  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 77988  		return
 77989  	}
 77990  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 77991  	if r.TryDecodeAsNil() {
 77992  		x.Prefix = ""
 77993  	} else {
 77994  		yyv35 := &x.Prefix
 77995  		yym36 := z.DecBinary()
 77996  		_ = yym36
 77997  		if false {
 77998  		} else {
 77999  			*((*string)(yyv35)) = r.DecodeString()
 78000  		}
 78001  	}
 78002  	yyj22++
 78003  	if yyhl22 {
 78004  		yyb22 = yyj22 > l
 78005  	} else {
 78006  		yyb22 = r.CheckBreak()
 78007  	}
 78008  	if yyb22 {
 78009  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 78010  		return
 78011  	}
 78012  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 78013  	if r.TryDecodeAsNil() {
 78014  		x.AuthToken = ""
 78015  	} else {
 78016  		yyv37 := &x.AuthToken
 78017  		yym38 := z.DecBinary()
 78018  		_ = yym38
 78019  		if false {
 78020  		} else {
 78021  			*((*string)(yyv37)) = r.DecodeString()
 78022  		}
 78023  	}
 78024  	yyj22++
 78025  	if yyhl22 {
 78026  		yyb22 = yyj22 > l
 78027  	} else {
 78028  		yyb22 = r.CheckBreak()
 78029  	}
 78030  	if yyb22 {
 78031  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 78032  		return
 78033  	}
 78034  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 78035  	if r.TryDecodeAsNil() {
 78036  		x.Forwarded = false
 78037  	} else {
 78038  		yyv39 := &x.Forwarded
 78039  		yym40 := z.DecBinary()
 78040  		_ = yym40
 78041  		if false {
 78042  		} else {
 78043  			*((*bool)(yyv39)) = r.DecodeBool()
 78044  		}
 78045  	}
 78046  	for {
 78047  		yyj22++
 78048  		if yyhl22 {
 78049  			yyb22 = yyj22 > l
 78050  		} else {
 78051  			yyb22 = r.CheckBreak()
 78052  		}
 78053  		if yyb22 {
 78054  			break
 78055  		}
 78056  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 78057  		z.DecStructFieldNotFound(yyj22-1, "")
 78058  	}
 78059  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 78060  }
 78061  
 78062  func (x *ACLTokenSpecificRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 78063  	var h codecSelfer100
 78064  	z, r := codec1978.GenHelperEncoder(e)
 78065  	_, _, _ = h, z, r
 78066  	if x == nil {
 78067  		r.EncodeNil()
 78068  	} else {
 78069  		yym1 := z.EncBinary()
 78070  		_ = yym1
 78071  		if false {
 78072  		} else if z.HasExtensions() && z.EncExt(x) {
 78073  		} else {
 78074  			yysep2 := !z.EncBinary()
 78075  			yy2arr2 := z.EncBasicHandle().StructToArray
 78076  			var yyq2 [9]bool
 78077  			_, _, _ = yysep2, yyq2, yy2arr2
 78078  			const yyr2 bool = false
 78079  			var yynn2 int
 78080  			if yyr2 || yy2arr2 {
 78081  				r.EncodeArrayStart(9)
 78082  			} else {
 78083  				yynn2 = 9
 78084  				for _, b := range yyq2 {
 78085  					if b {
 78086  						yynn2++
 78087  					}
 78088  				}
 78089  				r.EncodeMapStart(yynn2)
 78090  				yynn2 = 0
 78091  			}
 78092  			if yyr2 || yy2arr2 {
 78093  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78094  				yym4 := z.EncBinary()
 78095  				_ = yym4
 78096  				if false {
 78097  				} else {
 78098  					r.EncodeString(codecSelferC_UTF8100, string(x.AccessorID))
 78099  				}
 78100  			} else {
 78101  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78102  				r.EncodeString(codecSelferC_UTF8100, string("AccessorID"))
 78103  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78104  				yym5 := z.EncBinary()
 78105  				_ = yym5
 78106  				if false {
 78107  				} else {
 78108  					r.EncodeString(codecSelferC_UTF8100, string(x.AccessorID))
 78109  				}
 78110  			}
 78111  			if yyr2 || yy2arr2 {
 78112  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78113  				yym7 := z.EncBinary()
 78114  				_ = yym7
 78115  				if false {
 78116  				} else {
 78117  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 78118  				}
 78119  			} else {
 78120  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78121  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 78122  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78123  				yym8 := z.EncBinary()
 78124  				_ = yym8
 78125  				if false {
 78126  				} else {
 78127  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 78128  				}
 78129  			}
 78130  			if yyr2 || yy2arr2 {
 78131  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78132  				yym10 := z.EncBinary()
 78133  				_ = yym10
 78134  				if false {
 78135  				} else {
 78136  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 78137  				}
 78138  			} else {
 78139  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78140  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 78141  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78142  				yym11 := z.EncBinary()
 78143  				_ = yym11
 78144  				if false {
 78145  				} else {
 78146  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 78147  				}
 78148  			}
 78149  			if yyr2 || yy2arr2 {
 78150  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78151  				yym13 := z.EncBinary()
 78152  				_ = yym13
 78153  				if false {
 78154  				} else {
 78155  					r.EncodeUint(uint64(x.MinQueryIndex))
 78156  				}
 78157  			} else {
 78158  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78159  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 78160  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78161  				yym14 := z.EncBinary()
 78162  				_ = yym14
 78163  				if false {
 78164  				} else {
 78165  					r.EncodeUint(uint64(x.MinQueryIndex))
 78166  				}
 78167  			}
 78168  			if yyr2 || yy2arr2 {
 78169  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78170  				yym16 := z.EncBinary()
 78171  				_ = yym16
 78172  				if false {
 78173  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 78174  				} else {
 78175  					r.EncodeInt(int64(x.MaxQueryTime))
 78176  				}
 78177  			} else {
 78178  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78179  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 78180  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78181  				yym17 := z.EncBinary()
 78182  				_ = yym17
 78183  				if false {
 78184  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 78185  				} else {
 78186  					r.EncodeInt(int64(x.MaxQueryTime))
 78187  				}
 78188  			}
 78189  			if yyr2 || yy2arr2 {
 78190  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78191  				yym19 := z.EncBinary()
 78192  				_ = yym19
 78193  				if false {
 78194  				} else {
 78195  					r.EncodeBool(bool(x.AllowStale))
 78196  				}
 78197  			} else {
 78198  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78199  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 78200  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78201  				yym20 := z.EncBinary()
 78202  				_ = yym20
 78203  				if false {
 78204  				} else {
 78205  					r.EncodeBool(bool(x.AllowStale))
 78206  				}
 78207  			}
 78208  			if yyr2 || yy2arr2 {
 78209  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78210  				yym22 := z.EncBinary()
 78211  				_ = yym22
 78212  				if false {
 78213  				} else {
 78214  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 78215  				}
 78216  			} else {
 78217  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78218  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 78219  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78220  				yym23 := z.EncBinary()
 78221  				_ = yym23
 78222  				if false {
 78223  				} else {
 78224  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 78225  				}
 78226  			}
 78227  			if yyr2 || yy2arr2 {
 78228  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78229  				yym25 := z.EncBinary()
 78230  				_ = yym25
 78231  				if false {
 78232  				} else {
 78233  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 78234  				}
 78235  			} else {
 78236  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78237  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 78238  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78239  				yym26 := z.EncBinary()
 78240  				_ = yym26
 78241  				if false {
 78242  				} else {
 78243  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 78244  				}
 78245  			}
 78246  			if yyr2 || yy2arr2 {
 78247  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78248  				yym28 := z.EncBinary()
 78249  				_ = yym28
 78250  				if false {
 78251  				} else {
 78252  					r.EncodeBool(bool(x.Forwarded))
 78253  				}
 78254  			} else {
 78255  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78256  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 78257  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78258  				yym29 := z.EncBinary()
 78259  				_ = yym29
 78260  				if false {
 78261  				} else {
 78262  					r.EncodeBool(bool(x.Forwarded))
 78263  				}
 78264  			}
 78265  			if yyr2 || yy2arr2 {
 78266  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 78267  			} else {
 78268  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 78269  			}
 78270  		}
 78271  	}
 78272  }
 78273  
 78274  func (x *ACLTokenSpecificRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 78275  	var h codecSelfer100
 78276  	z, r := codec1978.GenHelperDecoder(d)
 78277  	_, _, _ = h, z, r
 78278  	yym1 := z.DecBinary()
 78279  	_ = yym1
 78280  	if false {
 78281  	} else if z.HasExtensions() && z.DecExt(x) {
 78282  	} else {
 78283  		yyct2 := r.ContainerType()
 78284  		if yyct2 == codecSelferValueTypeMap100 {
 78285  			yyl2 := r.ReadMapStart()
 78286  			if yyl2 == 0 {
 78287  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 78288  			} else {
 78289  				x.codecDecodeSelfFromMap(yyl2, d)
 78290  			}
 78291  		} else if yyct2 == codecSelferValueTypeArray100 {
 78292  			yyl2 := r.ReadArrayStart()
 78293  			if yyl2 == 0 {
 78294  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 78295  			} else {
 78296  				x.codecDecodeSelfFromArray(yyl2, d)
 78297  			}
 78298  		} else {
 78299  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 78300  		}
 78301  	}
 78302  }
 78303  
 78304  func (x *ACLTokenSpecificRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 78305  	var h codecSelfer100
 78306  	z, r := codec1978.GenHelperDecoder(d)
 78307  	_, _, _ = h, z, r
 78308  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 78309  	_ = yys3Slc
 78310  	var yyhl3 bool = l >= 0
 78311  	for yyj3 := 0; ; yyj3++ {
 78312  		if yyhl3 {
 78313  			if yyj3 >= l {
 78314  				break
 78315  			}
 78316  		} else {
 78317  			if r.CheckBreak() {
 78318  				break
 78319  			}
 78320  		}
 78321  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 78322  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 78323  		yys3 := string(yys3Slc)
 78324  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 78325  		switch yys3 {
 78326  		case "AccessorID":
 78327  			if r.TryDecodeAsNil() {
 78328  				x.AccessorID = ""
 78329  			} else {
 78330  				yyv4 := &x.AccessorID
 78331  				yym5 := z.DecBinary()
 78332  				_ = yym5
 78333  				if false {
 78334  				} else {
 78335  					*((*string)(yyv4)) = r.DecodeString()
 78336  				}
 78337  			}
 78338  		case "Region":
 78339  			if r.TryDecodeAsNil() {
 78340  				x.Region = ""
 78341  			} else {
 78342  				yyv6 := &x.Region
 78343  				yym7 := z.DecBinary()
 78344  				_ = yym7
 78345  				if false {
 78346  				} else {
 78347  					*((*string)(yyv6)) = r.DecodeString()
 78348  				}
 78349  			}
 78350  		case "Namespace":
 78351  			if r.TryDecodeAsNil() {
 78352  				x.Namespace = ""
 78353  			} else {
 78354  				yyv8 := &x.Namespace
 78355  				yym9 := z.DecBinary()
 78356  				_ = yym9
 78357  				if false {
 78358  				} else {
 78359  					*((*string)(yyv8)) = r.DecodeString()
 78360  				}
 78361  			}
 78362  		case "MinQueryIndex":
 78363  			if r.TryDecodeAsNil() {
 78364  				x.MinQueryIndex = 0
 78365  			} else {
 78366  				yyv10 := &x.MinQueryIndex
 78367  				yym11 := z.DecBinary()
 78368  				_ = yym11
 78369  				if false {
 78370  				} else {
 78371  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 78372  				}
 78373  			}
 78374  		case "MaxQueryTime":
 78375  			if r.TryDecodeAsNil() {
 78376  				x.MaxQueryTime = 0
 78377  			} else {
 78378  				yyv12 := &x.MaxQueryTime
 78379  				yym13 := z.DecBinary()
 78380  				_ = yym13
 78381  				if false {
 78382  				} else if z.HasExtensions() && z.DecExt(yyv12) {
 78383  				} else {
 78384  					*((*int64)(yyv12)) = int64(r.DecodeInt(64))
 78385  				}
 78386  			}
 78387  		case "AllowStale":
 78388  			if r.TryDecodeAsNil() {
 78389  				x.AllowStale = false
 78390  			} else {
 78391  				yyv14 := &x.AllowStale
 78392  				yym15 := z.DecBinary()
 78393  				_ = yym15
 78394  				if false {
 78395  				} else {
 78396  					*((*bool)(yyv14)) = r.DecodeBool()
 78397  				}
 78398  			}
 78399  		case "Prefix":
 78400  			if r.TryDecodeAsNil() {
 78401  				x.Prefix = ""
 78402  			} else {
 78403  				yyv16 := &x.Prefix
 78404  				yym17 := z.DecBinary()
 78405  				_ = yym17
 78406  				if false {
 78407  				} else {
 78408  					*((*string)(yyv16)) = r.DecodeString()
 78409  				}
 78410  			}
 78411  		case "AuthToken":
 78412  			if r.TryDecodeAsNil() {
 78413  				x.AuthToken = ""
 78414  			} else {
 78415  				yyv18 := &x.AuthToken
 78416  				yym19 := z.DecBinary()
 78417  				_ = yym19
 78418  				if false {
 78419  				} else {
 78420  					*((*string)(yyv18)) = r.DecodeString()
 78421  				}
 78422  			}
 78423  		case "Forwarded":
 78424  			if r.TryDecodeAsNil() {
 78425  				x.Forwarded = false
 78426  			} else {
 78427  				yyv20 := &x.Forwarded
 78428  				yym21 := z.DecBinary()
 78429  				_ = yym21
 78430  				if false {
 78431  				} else {
 78432  					*((*bool)(yyv20)) = r.DecodeBool()
 78433  				}
 78434  			}
 78435  		default:
 78436  			z.DecStructFieldNotFound(-1, yys3)
 78437  		} // end switch yys3
 78438  	} // end for yyj3
 78439  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 78440  }
 78441  
 78442  func (x *ACLTokenSpecificRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 78443  	var h codecSelfer100
 78444  	z, r := codec1978.GenHelperDecoder(d)
 78445  	_, _, _ = h, z, r
 78446  	var yyj22 int
 78447  	var yyb22 bool
 78448  	var yyhl22 bool = l >= 0
 78449  	yyj22++
 78450  	if yyhl22 {
 78451  		yyb22 = yyj22 > l
 78452  	} else {
 78453  		yyb22 = r.CheckBreak()
 78454  	}
 78455  	if yyb22 {
 78456  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 78457  		return
 78458  	}
 78459  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 78460  	if r.TryDecodeAsNil() {
 78461  		x.AccessorID = ""
 78462  	} else {
 78463  		yyv23 := &x.AccessorID
 78464  		yym24 := z.DecBinary()
 78465  		_ = yym24
 78466  		if false {
 78467  		} else {
 78468  			*((*string)(yyv23)) = r.DecodeString()
 78469  		}
 78470  	}
 78471  	yyj22++
 78472  	if yyhl22 {
 78473  		yyb22 = yyj22 > l
 78474  	} else {
 78475  		yyb22 = r.CheckBreak()
 78476  	}
 78477  	if yyb22 {
 78478  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 78479  		return
 78480  	}
 78481  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 78482  	if r.TryDecodeAsNil() {
 78483  		x.Region = ""
 78484  	} else {
 78485  		yyv25 := &x.Region
 78486  		yym26 := z.DecBinary()
 78487  		_ = yym26
 78488  		if false {
 78489  		} else {
 78490  			*((*string)(yyv25)) = r.DecodeString()
 78491  		}
 78492  	}
 78493  	yyj22++
 78494  	if yyhl22 {
 78495  		yyb22 = yyj22 > l
 78496  	} else {
 78497  		yyb22 = r.CheckBreak()
 78498  	}
 78499  	if yyb22 {
 78500  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 78501  		return
 78502  	}
 78503  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 78504  	if r.TryDecodeAsNil() {
 78505  		x.Namespace = ""
 78506  	} else {
 78507  		yyv27 := &x.Namespace
 78508  		yym28 := z.DecBinary()
 78509  		_ = yym28
 78510  		if false {
 78511  		} else {
 78512  			*((*string)(yyv27)) = r.DecodeString()
 78513  		}
 78514  	}
 78515  	yyj22++
 78516  	if yyhl22 {
 78517  		yyb22 = yyj22 > l
 78518  	} else {
 78519  		yyb22 = r.CheckBreak()
 78520  	}
 78521  	if yyb22 {
 78522  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 78523  		return
 78524  	}
 78525  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 78526  	if r.TryDecodeAsNil() {
 78527  		x.MinQueryIndex = 0
 78528  	} else {
 78529  		yyv29 := &x.MinQueryIndex
 78530  		yym30 := z.DecBinary()
 78531  		_ = yym30
 78532  		if false {
 78533  		} else {
 78534  			*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
 78535  		}
 78536  	}
 78537  	yyj22++
 78538  	if yyhl22 {
 78539  		yyb22 = yyj22 > l
 78540  	} else {
 78541  		yyb22 = r.CheckBreak()
 78542  	}
 78543  	if yyb22 {
 78544  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 78545  		return
 78546  	}
 78547  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 78548  	if r.TryDecodeAsNil() {
 78549  		x.MaxQueryTime = 0
 78550  	} else {
 78551  		yyv31 := &x.MaxQueryTime
 78552  		yym32 := z.DecBinary()
 78553  		_ = yym32
 78554  		if false {
 78555  		} else if z.HasExtensions() && z.DecExt(yyv31) {
 78556  		} else {
 78557  			*((*int64)(yyv31)) = int64(r.DecodeInt(64))
 78558  		}
 78559  	}
 78560  	yyj22++
 78561  	if yyhl22 {
 78562  		yyb22 = yyj22 > l
 78563  	} else {
 78564  		yyb22 = r.CheckBreak()
 78565  	}
 78566  	if yyb22 {
 78567  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 78568  		return
 78569  	}
 78570  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 78571  	if r.TryDecodeAsNil() {
 78572  		x.AllowStale = false
 78573  	} else {
 78574  		yyv33 := &x.AllowStale
 78575  		yym34 := z.DecBinary()
 78576  		_ = yym34
 78577  		if false {
 78578  		} else {
 78579  			*((*bool)(yyv33)) = r.DecodeBool()
 78580  		}
 78581  	}
 78582  	yyj22++
 78583  	if yyhl22 {
 78584  		yyb22 = yyj22 > l
 78585  	} else {
 78586  		yyb22 = r.CheckBreak()
 78587  	}
 78588  	if yyb22 {
 78589  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 78590  		return
 78591  	}
 78592  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 78593  	if r.TryDecodeAsNil() {
 78594  		x.Prefix = ""
 78595  	} else {
 78596  		yyv35 := &x.Prefix
 78597  		yym36 := z.DecBinary()
 78598  		_ = yym36
 78599  		if false {
 78600  		} else {
 78601  			*((*string)(yyv35)) = r.DecodeString()
 78602  		}
 78603  	}
 78604  	yyj22++
 78605  	if yyhl22 {
 78606  		yyb22 = yyj22 > l
 78607  	} else {
 78608  		yyb22 = r.CheckBreak()
 78609  	}
 78610  	if yyb22 {
 78611  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 78612  		return
 78613  	}
 78614  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 78615  	if r.TryDecodeAsNil() {
 78616  		x.AuthToken = ""
 78617  	} else {
 78618  		yyv37 := &x.AuthToken
 78619  		yym38 := z.DecBinary()
 78620  		_ = yym38
 78621  		if false {
 78622  		} else {
 78623  			*((*string)(yyv37)) = r.DecodeString()
 78624  		}
 78625  	}
 78626  	yyj22++
 78627  	if yyhl22 {
 78628  		yyb22 = yyj22 > l
 78629  	} else {
 78630  		yyb22 = r.CheckBreak()
 78631  	}
 78632  	if yyb22 {
 78633  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 78634  		return
 78635  	}
 78636  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 78637  	if r.TryDecodeAsNil() {
 78638  		x.Forwarded = false
 78639  	} else {
 78640  		yyv39 := &x.Forwarded
 78641  		yym40 := z.DecBinary()
 78642  		_ = yym40
 78643  		if false {
 78644  		} else {
 78645  			*((*bool)(yyv39)) = r.DecodeBool()
 78646  		}
 78647  	}
 78648  	for {
 78649  		yyj22++
 78650  		if yyhl22 {
 78651  			yyb22 = yyj22 > l
 78652  		} else {
 78653  			yyb22 = r.CheckBreak()
 78654  		}
 78655  		if yyb22 {
 78656  			break
 78657  		}
 78658  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 78659  		z.DecStructFieldNotFound(yyj22-1, "")
 78660  	}
 78661  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 78662  }
 78663  
 78664  func (x *ACLTokenSetRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 78665  	var h codecSelfer100
 78666  	z, r := codec1978.GenHelperEncoder(e)
 78667  	_, _, _ = h, z, r
 78668  	if x == nil {
 78669  		r.EncodeNil()
 78670  	} else {
 78671  		yym1 := z.EncBinary()
 78672  		_ = yym1
 78673  		if false {
 78674  		} else if z.HasExtensions() && z.EncExt(x) {
 78675  		} else {
 78676  			yysep2 := !z.EncBinary()
 78677  			yy2arr2 := z.EncBasicHandle().StructToArray
 78678  			var yyq2 [9]bool
 78679  			_, _, _ = yysep2, yyq2, yy2arr2
 78680  			const yyr2 bool = false
 78681  			var yynn2 int
 78682  			if yyr2 || yy2arr2 {
 78683  				r.EncodeArrayStart(9)
 78684  			} else {
 78685  				yynn2 = 9
 78686  				for _, b := range yyq2 {
 78687  					if b {
 78688  						yynn2++
 78689  					}
 78690  				}
 78691  				r.EncodeMapStart(yynn2)
 78692  				yynn2 = 0
 78693  			}
 78694  			if yyr2 || yy2arr2 {
 78695  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78696  				if x.AccessorIDS == nil {
 78697  					r.EncodeNil()
 78698  				} else {
 78699  					yym4 := z.EncBinary()
 78700  					_ = yym4
 78701  					if false {
 78702  					} else {
 78703  						z.F.EncSliceStringV(x.AccessorIDS, false, e)
 78704  					}
 78705  				}
 78706  			} else {
 78707  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78708  				r.EncodeString(codecSelferC_UTF8100, string("AccessorIDS"))
 78709  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78710  				if x.AccessorIDS == nil {
 78711  					r.EncodeNil()
 78712  				} else {
 78713  					yym5 := z.EncBinary()
 78714  					_ = yym5
 78715  					if false {
 78716  					} else {
 78717  						z.F.EncSliceStringV(x.AccessorIDS, false, e)
 78718  					}
 78719  				}
 78720  			}
 78721  			if yyr2 || yy2arr2 {
 78722  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78723  				yym7 := z.EncBinary()
 78724  				_ = yym7
 78725  				if false {
 78726  				} else {
 78727  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 78728  				}
 78729  			} else {
 78730  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78731  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 78732  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78733  				yym8 := z.EncBinary()
 78734  				_ = yym8
 78735  				if false {
 78736  				} else {
 78737  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 78738  				}
 78739  			}
 78740  			if yyr2 || yy2arr2 {
 78741  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78742  				yym10 := z.EncBinary()
 78743  				_ = yym10
 78744  				if false {
 78745  				} else {
 78746  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 78747  				}
 78748  			} else {
 78749  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78750  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 78751  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78752  				yym11 := z.EncBinary()
 78753  				_ = yym11
 78754  				if false {
 78755  				} else {
 78756  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 78757  				}
 78758  			}
 78759  			if yyr2 || yy2arr2 {
 78760  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78761  				yym13 := z.EncBinary()
 78762  				_ = yym13
 78763  				if false {
 78764  				} else {
 78765  					r.EncodeUint(uint64(x.MinQueryIndex))
 78766  				}
 78767  			} else {
 78768  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78769  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 78770  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78771  				yym14 := z.EncBinary()
 78772  				_ = yym14
 78773  				if false {
 78774  				} else {
 78775  					r.EncodeUint(uint64(x.MinQueryIndex))
 78776  				}
 78777  			}
 78778  			if yyr2 || yy2arr2 {
 78779  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78780  				yym16 := z.EncBinary()
 78781  				_ = yym16
 78782  				if false {
 78783  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 78784  				} else {
 78785  					r.EncodeInt(int64(x.MaxQueryTime))
 78786  				}
 78787  			} else {
 78788  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78789  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 78790  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78791  				yym17 := z.EncBinary()
 78792  				_ = yym17
 78793  				if false {
 78794  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 78795  				} else {
 78796  					r.EncodeInt(int64(x.MaxQueryTime))
 78797  				}
 78798  			}
 78799  			if yyr2 || yy2arr2 {
 78800  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78801  				yym19 := z.EncBinary()
 78802  				_ = yym19
 78803  				if false {
 78804  				} else {
 78805  					r.EncodeBool(bool(x.AllowStale))
 78806  				}
 78807  			} else {
 78808  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78809  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 78810  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78811  				yym20 := z.EncBinary()
 78812  				_ = yym20
 78813  				if false {
 78814  				} else {
 78815  					r.EncodeBool(bool(x.AllowStale))
 78816  				}
 78817  			}
 78818  			if yyr2 || yy2arr2 {
 78819  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78820  				yym22 := z.EncBinary()
 78821  				_ = yym22
 78822  				if false {
 78823  				} else {
 78824  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 78825  				}
 78826  			} else {
 78827  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78828  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 78829  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78830  				yym23 := z.EncBinary()
 78831  				_ = yym23
 78832  				if false {
 78833  				} else {
 78834  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 78835  				}
 78836  			}
 78837  			if yyr2 || yy2arr2 {
 78838  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78839  				yym25 := z.EncBinary()
 78840  				_ = yym25
 78841  				if false {
 78842  				} else {
 78843  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 78844  				}
 78845  			} else {
 78846  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78847  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 78848  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78849  				yym26 := z.EncBinary()
 78850  				_ = yym26
 78851  				if false {
 78852  				} else {
 78853  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 78854  				}
 78855  			}
 78856  			if yyr2 || yy2arr2 {
 78857  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 78858  				yym28 := z.EncBinary()
 78859  				_ = yym28
 78860  				if false {
 78861  				} else {
 78862  					r.EncodeBool(bool(x.Forwarded))
 78863  				}
 78864  			} else {
 78865  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 78866  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 78867  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 78868  				yym29 := z.EncBinary()
 78869  				_ = yym29
 78870  				if false {
 78871  				} else {
 78872  					r.EncodeBool(bool(x.Forwarded))
 78873  				}
 78874  			}
 78875  			if yyr2 || yy2arr2 {
 78876  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 78877  			} else {
 78878  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 78879  			}
 78880  		}
 78881  	}
 78882  }
 78883  
 78884  func (x *ACLTokenSetRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 78885  	var h codecSelfer100
 78886  	z, r := codec1978.GenHelperDecoder(d)
 78887  	_, _, _ = h, z, r
 78888  	yym1 := z.DecBinary()
 78889  	_ = yym1
 78890  	if false {
 78891  	} else if z.HasExtensions() && z.DecExt(x) {
 78892  	} else {
 78893  		yyct2 := r.ContainerType()
 78894  		if yyct2 == codecSelferValueTypeMap100 {
 78895  			yyl2 := r.ReadMapStart()
 78896  			if yyl2 == 0 {
 78897  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 78898  			} else {
 78899  				x.codecDecodeSelfFromMap(yyl2, d)
 78900  			}
 78901  		} else if yyct2 == codecSelferValueTypeArray100 {
 78902  			yyl2 := r.ReadArrayStart()
 78903  			if yyl2 == 0 {
 78904  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 78905  			} else {
 78906  				x.codecDecodeSelfFromArray(yyl2, d)
 78907  			}
 78908  		} else {
 78909  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 78910  		}
 78911  	}
 78912  }
 78913  
 78914  func (x *ACLTokenSetRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 78915  	var h codecSelfer100
 78916  	z, r := codec1978.GenHelperDecoder(d)
 78917  	_, _, _ = h, z, r
 78918  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 78919  	_ = yys3Slc
 78920  	var yyhl3 bool = l >= 0
 78921  	for yyj3 := 0; ; yyj3++ {
 78922  		if yyhl3 {
 78923  			if yyj3 >= l {
 78924  				break
 78925  			}
 78926  		} else {
 78927  			if r.CheckBreak() {
 78928  				break
 78929  			}
 78930  		}
 78931  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 78932  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 78933  		yys3 := string(yys3Slc)
 78934  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 78935  		switch yys3 {
 78936  		case "AccessorIDS":
 78937  			if r.TryDecodeAsNil() {
 78938  				x.AccessorIDS = nil
 78939  			} else {
 78940  				yyv4 := &x.AccessorIDS
 78941  				yym5 := z.DecBinary()
 78942  				_ = yym5
 78943  				if false {
 78944  				} else {
 78945  					z.F.DecSliceStringX(yyv4, false, d)
 78946  				}
 78947  			}
 78948  		case "Region":
 78949  			if r.TryDecodeAsNil() {
 78950  				x.Region = ""
 78951  			} else {
 78952  				yyv6 := &x.Region
 78953  				yym7 := z.DecBinary()
 78954  				_ = yym7
 78955  				if false {
 78956  				} else {
 78957  					*((*string)(yyv6)) = r.DecodeString()
 78958  				}
 78959  			}
 78960  		case "Namespace":
 78961  			if r.TryDecodeAsNil() {
 78962  				x.Namespace = ""
 78963  			} else {
 78964  				yyv8 := &x.Namespace
 78965  				yym9 := z.DecBinary()
 78966  				_ = yym9
 78967  				if false {
 78968  				} else {
 78969  					*((*string)(yyv8)) = r.DecodeString()
 78970  				}
 78971  			}
 78972  		case "MinQueryIndex":
 78973  			if r.TryDecodeAsNil() {
 78974  				x.MinQueryIndex = 0
 78975  			} else {
 78976  				yyv10 := &x.MinQueryIndex
 78977  				yym11 := z.DecBinary()
 78978  				_ = yym11
 78979  				if false {
 78980  				} else {
 78981  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 78982  				}
 78983  			}
 78984  		case "MaxQueryTime":
 78985  			if r.TryDecodeAsNil() {
 78986  				x.MaxQueryTime = 0
 78987  			} else {
 78988  				yyv12 := &x.MaxQueryTime
 78989  				yym13 := z.DecBinary()
 78990  				_ = yym13
 78991  				if false {
 78992  				} else if z.HasExtensions() && z.DecExt(yyv12) {
 78993  				} else {
 78994  					*((*int64)(yyv12)) = int64(r.DecodeInt(64))
 78995  				}
 78996  			}
 78997  		case "AllowStale":
 78998  			if r.TryDecodeAsNil() {
 78999  				x.AllowStale = false
 79000  			} else {
 79001  				yyv14 := &x.AllowStale
 79002  				yym15 := z.DecBinary()
 79003  				_ = yym15
 79004  				if false {
 79005  				} else {
 79006  					*((*bool)(yyv14)) = r.DecodeBool()
 79007  				}
 79008  			}
 79009  		case "Prefix":
 79010  			if r.TryDecodeAsNil() {
 79011  				x.Prefix = ""
 79012  			} else {
 79013  				yyv16 := &x.Prefix
 79014  				yym17 := z.DecBinary()
 79015  				_ = yym17
 79016  				if false {
 79017  				} else {
 79018  					*((*string)(yyv16)) = r.DecodeString()
 79019  				}
 79020  			}
 79021  		case "AuthToken":
 79022  			if r.TryDecodeAsNil() {
 79023  				x.AuthToken = ""
 79024  			} else {
 79025  				yyv18 := &x.AuthToken
 79026  				yym19 := z.DecBinary()
 79027  				_ = yym19
 79028  				if false {
 79029  				} else {
 79030  					*((*string)(yyv18)) = r.DecodeString()
 79031  				}
 79032  			}
 79033  		case "Forwarded":
 79034  			if r.TryDecodeAsNil() {
 79035  				x.Forwarded = false
 79036  			} else {
 79037  				yyv20 := &x.Forwarded
 79038  				yym21 := z.DecBinary()
 79039  				_ = yym21
 79040  				if false {
 79041  				} else {
 79042  					*((*bool)(yyv20)) = r.DecodeBool()
 79043  				}
 79044  			}
 79045  		default:
 79046  			z.DecStructFieldNotFound(-1, yys3)
 79047  		} // end switch yys3
 79048  	} // end for yyj3
 79049  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 79050  }
 79051  
 79052  func (x *ACLTokenSetRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 79053  	var h codecSelfer100
 79054  	z, r := codec1978.GenHelperDecoder(d)
 79055  	_, _, _ = h, z, r
 79056  	var yyj22 int
 79057  	var yyb22 bool
 79058  	var yyhl22 bool = l >= 0
 79059  	yyj22++
 79060  	if yyhl22 {
 79061  		yyb22 = yyj22 > l
 79062  	} else {
 79063  		yyb22 = r.CheckBreak()
 79064  	}
 79065  	if yyb22 {
 79066  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79067  		return
 79068  	}
 79069  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79070  	if r.TryDecodeAsNil() {
 79071  		x.AccessorIDS = nil
 79072  	} else {
 79073  		yyv23 := &x.AccessorIDS
 79074  		yym24 := z.DecBinary()
 79075  		_ = yym24
 79076  		if false {
 79077  		} else {
 79078  			z.F.DecSliceStringX(yyv23, false, d)
 79079  		}
 79080  	}
 79081  	yyj22++
 79082  	if yyhl22 {
 79083  		yyb22 = yyj22 > l
 79084  	} else {
 79085  		yyb22 = r.CheckBreak()
 79086  	}
 79087  	if yyb22 {
 79088  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79089  		return
 79090  	}
 79091  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79092  	if r.TryDecodeAsNil() {
 79093  		x.Region = ""
 79094  	} else {
 79095  		yyv25 := &x.Region
 79096  		yym26 := z.DecBinary()
 79097  		_ = yym26
 79098  		if false {
 79099  		} else {
 79100  			*((*string)(yyv25)) = r.DecodeString()
 79101  		}
 79102  	}
 79103  	yyj22++
 79104  	if yyhl22 {
 79105  		yyb22 = yyj22 > l
 79106  	} else {
 79107  		yyb22 = r.CheckBreak()
 79108  	}
 79109  	if yyb22 {
 79110  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79111  		return
 79112  	}
 79113  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79114  	if r.TryDecodeAsNil() {
 79115  		x.Namespace = ""
 79116  	} else {
 79117  		yyv27 := &x.Namespace
 79118  		yym28 := z.DecBinary()
 79119  		_ = yym28
 79120  		if false {
 79121  		} else {
 79122  			*((*string)(yyv27)) = r.DecodeString()
 79123  		}
 79124  	}
 79125  	yyj22++
 79126  	if yyhl22 {
 79127  		yyb22 = yyj22 > l
 79128  	} else {
 79129  		yyb22 = r.CheckBreak()
 79130  	}
 79131  	if yyb22 {
 79132  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79133  		return
 79134  	}
 79135  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79136  	if r.TryDecodeAsNil() {
 79137  		x.MinQueryIndex = 0
 79138  	} else {
 79139  		yyv29 := &x.MinQueryIndex
 79140  		yym30 := z.DecBinary()
 79141  		_ = yym30
 79142  		if false {
 79143  		} else {
 79144  			*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
 79145  		}
 79146  	}
 79147  	yyj22++
 79148  	if yyhl22 {
 79149  		yyb22 = yyj22 > l
 79150  	} else {
 79151  		yyb22 = r.CheckBreak()
 79152  	}
 79153  	if yyb22 {
 79154  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79155  		return
 79156  	}
 79157  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79158  	if r.TryDecodeAsNil() {
 79159  		x.MaxQueryTime = 0
 79160  	} else {
 79161  		yyv31 := &x.MaxQueryTime
 79162  		yym32 := z.DecBinary()
 79163  		_ = yym32
 79164  		if false {
 79165  		} else if z.HasExtensions() && z.DecExt(yyv31) {
 79166  		} else {
 79167  			*((*int64)(yyv31)) = int64(r.DecodeInt(64))
 79168  		}
 79169  	}
 79170  	yyj22++
 79171  	if yyhl22 {
 79172  		yyb22 = yyj22 > l
 79173  	} else {
 79174  		yyb22 = r.CheckBreak()
 79175  	}
 79176  	if yyb22 {
 79177  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79178  		return
 79179  	}
 79180  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79181  	if r.TryDecodeAsNil() {
 79182  		x.AllowStale = false
 79183  	} else {
 79184  		yyv33 := &x.AllowStale
 79185  		yym34 := z.DecBinary()
 79186  		_ = yym34
 79187  		if false {
 79188  		} else {
 79189  			*((*bool)(yyv33)) = r.DecodeBool()
 79190  		}
 79191  	}
 79192  	yyj22++
 79193  	if yyhl22 {
 79194  		yyb22 = yyj22 > l
 79195  	} else {
 79196  		yyb22 = r.CheckBreak()
 79197  	}
 79198  	if yyb22 {
 79199  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79200  		return
 79201  	}
 79202  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79203  	if r.TryDecodeAsNil() {
 79204  		x.Prefix = ""
 79205  	} else {
 79206  		yyv35 := &x.Prefix
 79207  		yym36 := z.DecBinary()
 79208  		_ = yym36
 79209  		if false {
 79210  		} else {
 79211  			*((*string)(yyv35)) = r.DecodeString()
 79212  		}
 79213  	}
 79214  	yyj22++
 79215  	if yyhl22 {
 79216  		yyb22 = yyj22 > l
 79217  	} else {
 79218  		yyb22 = r.CheckBreak()
 79219  	}
 79220  	if yyb22 {
 79221  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79222  		return
 79223  	}
 79224  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79225  	if r.TryDecodeAsNil() {
 79226  		x.AuthToken = ""
 79227  	} else {
 79228  		yyv37 := &x.AuthToken
 79229  		yym38 := z.DecBinary()
 79230  		_ = yym38
 79231  		if false {
 79232  		} else {
 79233  			*((*string)(yyv37)) = r.DecodeString()
 79234  		}
 79235  	}
 79236  	yyj22++
 79237  	if yyhl22 {
 79238  		yyb22 = yyj22 > l
 79239  	} else {
 79240  		yyb22 = r.CheckBreak()
 79241  	}
 79242  	if yyb22 {
 79243  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79244  		return
 79245  	}
 79246  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79247  	if r.TryDecodeAsNil() {
 79248  		x.Forwarded = false
 79249  	} else {
 79250  		yyv39 := &x.Forwarded
 79251  		yym40 := z.DecBinary()
 79252  		_ = yym40
 79253  		if false {
 79254  		} else {
 79255  			*((*bool)(yyv39)) = r.DecodeBool()
 79256  		}
 79257  	}
 79258  	for {
 79259  		yyj22++
 79260  		if yyhl22 {
 79261  			yyb22 = yyj22 > l
 79262  		} else {
 79263  			yyb22 = r.CheckBreak()
 79264  		}
 79265  		if yyb22 {
 79266  			break
 79267  		}
 79268  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79269  		z.DecStructFieldNotFound(yyj22-1, "")
 79270  	}
 79271  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79272  }
 79273  
 79274  func (x *ACLTokenListResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 79275  	var h codecSelfer100
 79276  	z, r := codec1978.GenHelperEncoder(e)
 79277  	_, _, _ = h, z, r
 79278  	if x == nil {
 79279  		r.EncodeNil()
 79280  	} else {
 79281  		yym1 := z.EncBinary()
 79282  		_ = yym1
 79283  		if false {
 79284  		} else if z.HasExtensions() && z.EncExt(x) {
 79285  		} else {
 79286  			yysep2 := !z.EncBinary()
 79287  			yy2arr2 := z.EncBasicHandle().StructToArray
 79288  			var yyq2 [4]bool
 79289  			_, _, _ = yysep2, yyq2, yy2arr2
 79290  			const yyr2 bool = false
 79291  			var yynn2 int
 79292  			if yyr2 || yy2arr2 {
 79293  				r.EncodeArrayStart(4)
 79294  			} else {
 79295  				yynn2 = 4
 79296  				for _, b := range yyq2 {
 79297  					if b {
 79298  						yynn2++
 79299  					}
 79300  				}
 79301  				r.EncodeMapStart(yynn2)
 79302  				yynn2 = 0
 79303  			}
 79304  			if yyr2 || yy2arr2 {
 79305  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 79306  				if x.Tokens == nil {
 79307  					r.EncodeNil()
 79308  				} else {
 79309  					yym4 := z.EncBinary()
 79310  					_ = yym4
 79311  					if false {
 79312  					} else {
 79313  						h.encSlicePtrtoACLTokenListStub(([]*ACLTokenListStub)(x.Tokens), e)
 79314  					}
 79315  				}
 79316  			} else {
 79317  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 79318  				r.EncodeString(codecSelferC_UTF8100, string("Tokens"))
 79319  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 79320  				if x.Tokens == nil {
 79321  					r.EncodeNil()
 79322  				} else {
 79323  					yym5 := z.EncBinary()
 79324  					_ = yym5
 79325  					if false {
 79326  					} else {
 79327  						h.encSlicePtrtoACLTokenListStub(([]*ACLTokenListStub)(x.Tokens), e)
 79328  					}
 79329  				}
 79330  			}
 79331  			if yyr2 || yy2arr2 {
 79332  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 79333  				yym7 := z.EncBinary()
 79334  				_ = yym7
 79335  				if false {
 79336  				} else {
 79337  					r.EncodeUint(uint64(x.Index))
 79338  				}
 79339  			} else {
 79340  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 79341  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 79342  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 79343  				yym8 := z.EncBinary()
 79344  				_ = yym8
 79345  				if false {
 79346  				} else {
 79347  					r.EncodeUint(uint64(x.Index))
 79348  				}
 79349  			}
 79350  			if yyr2 || yy2arr2 {
 79351  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 79352  				yym10 := z.EncBinary()
 79353  				_ = yym10
 79354  				if false {
 79355  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 79356  				} else {
 79357  					r.EncodeInt(int64(x.LastContact))
 79358  				}
 79359  			} else {
 79360  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 79361  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 79362  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 79363  				yym11 := z.EncBinary()
 79364  				_ = yym11
 79365  				if false {
 79366  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 79367  				} else {
 79368  					r.EncodeInt(int64(x.LastContact))
 79369  				}
 79370  			}
 79371  			if yyr2 || yy2arr2 {
 79372  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 79373  				yym13 := z.EncBinary()
 79374  				_ = yym13
 79375  				if false {
 79376  				} else {
 79377  					r.EncodeBool(bool(x.KnownLeader))
 79378  				}
 79379  			} else {
 79380  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 79381  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 79382  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 79383  				yym14 := z.EncBinary()
 79384  				_ = yym14
 79385  				if false {
 79386  				} else {
 79387  					r.EncodeBool(bool(x.KnownLeader))
 79388  				}
 79389  			}
 79390  			if yyr2 || yy2arr2 {
 79391  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 79392  			} else {
 79393  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 79394  			}
 79395  		}
 79396  	}
 79397  }
 79398  
 79399  func (x *ACLTokenListResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 79400  	var h codecSelfer100
 79401  	z, r := codec1978.GenHelperDecoder(d)
 79402  	_, _, _ = h, z, r
 79403  	yym1 := z.DecBinary()
 79404  	_ = yym1
 79405  	if false {
 79406  	} else if z.HasExtensions() && z.DecExt(x) {
 79407  	} else {
 79408  		yyct2 := r.ContainerType()
 79409  		if yyct2 == codecSelferValueTypeMap100 {
 79410  			yyl2 := r.ReadMapStart()
 79411  			if yyl2 == 0 {
 79412  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 79413  			} else {
 79414  				x.codecDecodeSelfFromMap(yyl2, d)
 79415  			}
 79416  		} else if yyct2 == codecSelferValueTypeArray100 {
 79417  			yyl2 := r.ReadArrayStart()
 79418  			if yyl2 == 0 {
 79419  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79420  			} else {
 79421  				x.codecDecodeSelfFromArray(yyl2, d)
 79422  			}
 79423  		} else {
 79424  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 79425  		}
 79426  	}
 79427  }
 79428  
 79429  func (x *ACLTokenListResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 79430  	var h codecSelfer100
 79431  	z, r := codec1978.GenHelperDecoder(d)
 79432  	_, _, _ = h, z, r
 79433  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 79434  	_ = yys3Slc
 79435  	var yyhl3 bool = l >= 0
 79436  	for yyj3 := 0; ; yyj3++ {
 79437  		if yyhl3 {
 79438  			if yyj3 >= l {
 79439  				break
 79440  			}
 79441  		} else {
 79442  			if r.CheckBreak() {
 79443  				break
 79444  			}
 79445  		}
 79446  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 79447  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 79448  		yys3 := string(yys3Slc)
 79449  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 79450  		switch yys3 {
 79451  		case "Tokens":
 79452  			if r.TryDecodeAsNil() {
 79453  				x.Tokens = nil
 79454  			} else {
 79455  				yyv4 := &x.Tokens
 79456  				yym5 := z.DecBinary()
 79457  				_ = yym5
 79458  				if false {
 79459  				} else {
 79460  					h.decSlicePtrtoACLTokenListStub((*[]*ACLTokenListStub)(yyv4), d)
 79461  				}
 79462  			}
 79463  		case "Index":
 79464  			if r.TryDecodeAsNil() {
 79465  				x.Index = 0
 79466  			} else {
 79467  				yyv6 := &x.Index
 79468  				yym7 := z.DecBinary()
 79469  				_ = yym7
 79470  				if false {
 79471  				} else {
 79472  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 79473  				}
 79474  			}
 79475  		case "LastContact":
 79476  			if r.TryDecodeAsNil() {
 79477  				x.LastContact = 0
 79478  			} else {
 79479  				yyv8 := &x.LastContact
 79480  				yym9 := z.DecBinary()
 79481  				_ = yym9
 79482  				if false {
 79483  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 79484  				} else {
 79485  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 79486  				}
 79487  			}
 79488  		case "KnownLeader":
 79489  			if r.TryDecodeAsNil() {
 79490  				x.KnownLeader = false
 79491  			} else {
 79492  				yyv10 := &x.KnownLeader
 79493  				yym11 := z.DecBinary()
 79494  				_ = yym11
 79495  				if false {
 79496  				} else {
 79497  					*((*bool)(yyv10)) = r.DecodeBool()
 79498  				}
 79499  			}
 79500  		default:
 79501  			z.DecStructFieldNotFound(-1, yys3)
 79502  		} // end switch yys3
 79503  	} // end for yyj3
 79504  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 79505  }
 79506  
 79507  func (x *ACLTokenListResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 79508  	var h codecSelfer100
 79509  	z, r := codec1978.GenHelperDecoder(d)
 79510  	_, _, _ = h, z, r
 79511  	var yyj12 int
 79512  	var yyb12 bool
 79513  	var yyhl12 bool = l >= 0
 79514  	yyj12++
 79515  	if yyhl12 {
 79516  		yyb12 = yyj12 > l
 79517  	} else {
 79518  		yyb12 = r.CheckBreak()
 79519  	}
 79520  	if yyb12 {
 79521  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79522  		return
 79523  	}
 79524  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79525  	if r.TryDecodeAsNil() {
 79526  		x.Tokens = nil
 79527  	} else {
 79528  		yyv13 := &x.Tokens
 79529  		yym14 := z.DecBinary()
 79530  		_ = yym14
 79531  		if false {
 79532  		} else {
 79533  			h.decSlicePtrtoACLTokenListStub((*[]*ACLTokenListStub)(yyv13), d)
 79534  		}
 79535  	}
 79536  	yyj12++
 79537  	if yyhl12 {
 79538  		yyb12 = yyj12 > l
 79539  	} else {
 79540  		yyb12 = r.CheckBreak()
 79541  	}
 79542  	if yyb12 {
 79543  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79544  		return
 79545  	}
 79546  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79547  	if r.TryDecodeAsNil() {
 79548  		x.Index = 0
 79549  	} else {
 79550  		yyv15 := &x.Index
 79551  		yym16 := z.DecBinary()
 79552  		_ = yym16
 79553  		if false {
 79554  		} else {
 79555  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 79556  		}
 79557  	}
 79558  	yyj12++
 79559  	if yyhl12 {
 79560  		yyb12 = yyj12 > l
 79561  	} else {
 79562  		yyb12 = r.CheckBreak()
 79563  	}
 79564  	if yyb12 {
 79565  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79566  		return
 79567  	}
 79568  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79569  	if r.TryDecodeAsNil() {
 79570  		x.LastContact = 0
 79571  	} else {
 79572  		yyv17 := &x.LastContact
 79573  		yym18 := z.DecBinary()
 79574  		_ = yym18
 79575  		if false {
 79576  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 79577  		} else {
 79578  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 79579  		}
 79580  	}
 79581  	yyj12++
 79582  	if yyhl12 {
 79583  		yyb12 = yyj12 > l
 79584  	} else {
 79585  		yyb12 = r.CheckBreak()
 79586  	}
 79587  	if yyb12 {
 79588  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79589  		return
 79590  	}
 79591  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79592  	if r.TryDecodeAsNil() {
 79593  		x.KnownLeader = false
 79594  	} else {
 79595  		yyv19 := &x.KnownLeader
 79596  		yym20 := z.DecBinary()
 79597  		_ = yym20
 79598  		if false {
 79599  		} else {
 79600  			*((*bool)(yyv19)) = r.DecodeBool()
 79601  		}
 79602  	}
 79603  	for {
 79604  		yyj12++
 79605  		if yyhl12 {
 79606  			yyb12 = yyj12 > l
 79607  		} else {
 79608  			yyb12 = r.CheckBreak()
 79609  		}
 79610  		if yyb12 {
 79611  			break
 79612  		}
 79613  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79614  		z.DecStructFieldNotFound(yyj12-1, "")
 79615  	}
 79616  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79617  }
 79618  
 79619  func (x *SingleACLTokenResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 79620  	var h codecSelfer100
 79621  	z, r := codec1978.GenHelperEncoder(e)
 79622  	_, _, _ = h, z, r
 79623  	if x == nil {
 79624  		r.EncodeNil()
 79625  	} else {
 79626  		yym1 := z.EncBinary()
 79627  		_ = yym1
 79628  		if false {
 79629  		} else if z.HasExtensions() && z.EncExt(x) {
 79630  		} else {
 79631  			yysep2 := !z.EncBinary()
 79632  			yy2arr2 := z.EncBasicHandle().StructToArray
 79633  			var yyq2 [4]bool
 79634  			_, _, _ = yysep2, yyq2, yy2arr2
 79635  			const yyr2 bool = false
 79636  			var yynn2 int
 79637  			if yyr2 || yy2arr2 {
 79638  				r.EncodeArrayStart(4)
 79639  			} else {
 79640  				yynn2 = 4
 79641  				for _, b := range yyq2 {
 79642  					if b {
 79643  						yynn2++
 79644  					}
 79645  				}
 79646  				r.EncodeMapStart(yynn2)
 79647  				yynn2 = 0
 79648  			}
 79649  			if yyr2 || yy2arr2 {
 79650  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 79651  				if x.Token == nil {
 79652  					r.EncodeNil()
 79653  				} else {
 79654  					x.Token.CodecEncodeSelf(e)
 79655  				}
 79656  			} else {
 79657  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 79658  				r.EncodeString(codecSelferC_UTF8100, string("Token"))
 79659  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 79660  				if x.Token == nil {
 79661  					r.EncodeNil()
 79662  				} else {
 79663  					x.Token.CodecEncodeSelf(e)
 79664  				}
 79665  			}
 79666  			if yyr2 || yy2arr2 {
 79667  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 79668  				yym7 := z.EncBinary()
 79669  				_ = yym7
 79670  				if false {
 79671  				} else {
 79672  					r.EncodeUint(uint64(x.Index))
 79673  				}
 79674  			} else {
 79675  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 79676  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 79677  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 79678  				yym8 := z.EncBinary()
 79679  				_ = yym8
 79680  				if false {
 79681  				} else {
 79682  					r.EncodeUint(uint64(x.Index))
 79683  				}
 79684  			}
 79685  			if yyr2 || yy2arr2 {
 79686  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 79687  				yym10 := z.EncBinary()
 79688  				_ = yym10
 79689  				if false {
 79690  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 79691  				} else {
 79692  					r.EncodeInt(int64(x.LastContact))
 79693  				}
 79694  			} else {
 79695  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 79696  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 79697  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 79698  				yym11 := z.EncBinary()
 79699  				_ = yym11
 79700  				if false {
 79701  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 79702  				} else {
 79703  					r.EncodeInt(int64(x.LastContact))
 79704  				}
 79705  			}
 79706  			if yyr2 || yy2arr2 {
 79707  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 79708  				yym13 := z.EncBinary()
 79709  				_ = yym13
 79710  				if false {
 79711  				} else {
 79712  					r.EncodeBool(bool(x.KnownLeader))
 79713  				}
 79714  			} else {
 79715  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 79716  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 79717  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 79718  				yym14 := z.EncBinary()
 79719  				_ = yym14
 79720  				if false {
 79721  				} else {
 79722  					r.EncodeBool(bool(x.KnownLeader))
 79723  				}
 79724  			}
 79725  			if yyr2 || yy2arr2 {
 79726  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 79727  			} else {
 79728  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 79729  			}
 79730  		}
 79731  	}
 79732  }
 79733  
 79734  func (x *SingleACLTokenResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 79735  	var h codecSelfer100
 79736  	z, r := codec1978.GenHelperDecoder(d)
 79737  	_, _, _ = h, z, r
 79738  	yym1 := z.DecBinary()
 79739  	_ = yym1
 79740  	if false {
 79741  	} else if z.HasExtensions() && z.DecExt(x) {
 79742  	} else {
 79743  		yyct2 := r.ContainerType()
 79744  		if yyct2 == codecSelferValueTypeMap100 {
 79745  			yyl2 := r.ReadMapStart()
 79746  			if yyl2 == 0 {
 79747  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 79748  			} else {
 79749  				x.codecDecodeSelfFromMap(yyl2, d)
 79750  			}
 79751  		} else if yyct2 == codecSelferValueTypeArray100 {
 79752  			yyl2 := r.ReadArrayStart()
 79753  			if yyl2 == 0 {
 79754  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79755  			} else {
 79756  				x.codecDecodeSelfFromArray(yyl2, d)
 79757  			}
 79758  		} else {
 79759  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 79760  		}
 79761  	}
 79762  }
 79763  
 79764  func (x *SingleACLTokenResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 79765  	var h codecSelfer100
 79766  	z, r := codec1978.GenHelperDecoder(d)
 79767  	_, _, _ = h, z, r
 79768  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 79769  	_ = yys3Slc
 79770  	var yyhl3 bool = l >= 0
 79771  	for yyj3 := 0; ; yyj3++ {
 79772  		if yyhl3 {
 79773  			if yyj3 >= l {
 79774  				break
 79775  			}
 79776  		} else {
 79777  			if r.CheckBreak() {
 79778  				break
 79779  			}
 79780  		}
 79781  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 79782  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 79783  		yys3 := string(yys3Slc)
 79784  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 79785  		switch yys3 {
 79786  		case "Token":
 79787  			if r.TryDecodeAsNil() {
 79788  				if x.Token != nil {
 79789  					x.Token = nil
 79790  				}
 79791  			} else {
 79792  				if x.Token == nil {
 79793  					x.Token = new(ACLToken)
 79794  				}
 79795  				x.Token.CodecDecodeSelf(d)
 79796  			}
 79797  		case "Index":
 79798  			if r.TryDecodeAsNil() {
 79799  				x.Index = 0
 79800  			} else {
 79801  				yyv5 := &x.Index
 79802  				yym6 := z.DecBinary()
 79803  				_ = yym6
 79804  				if false {
 79805  				} else {
 79806  					*((*uint64)(yyv5)) = uint64(r.DecodeUint(64))
 79807  				}
 79808  			}
 79809  		case "LastContact":
 79810  			if r.TryDecodeAsNil() {
 79811  				x.LastContact = 0
 79812  			} else {
 79813  				yyv7 := &x.LastContact
 79814  				yym8 := z.DecBinary()
 79815  				_ = yym8
 79816  				if false {
 79817  				} else if z.HasExtensions() && z.DecExt(yyv7) {
 79818  				} else {
 79819  					*((*int64)(yyv7)) = int64(r.DecodeInt(64))
 79820  				}
 79821  			}
 79822  		case "KnownLeader":
 79823  			if r.TryDecodeAsNil() {
 79824  				x.KnownLeader = false
 79825  			} else {
 79826  				yyv9 := &x.KnownLeader
 79827  				yym10 := z.DecBinary()
 79828  				_ = yym10
 79829  				if false {
 79830  				} else {
 79831  					*((*bool)(yyv9)) = r.DecodeBool()
 79832  				}
 79833  			}
 79834  		default:
 79835  			z.DecStructFieldNotFound(-1, yys3)
 79836  		} // end switch yys3
 79837  	} // end for yyj3
 79838  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 79839  }
 79840  
 79841  func (x *SingleACLTokenResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 79842  	var h codecSelfer100
 79843  	z, r := codec1978.GenHelperDecoder(d)
 79844  	_, _, _ = h, z, r
 79845  	var yyj11 int
 79846  	var yyb11 bool
 79847  	var yyhl11 bool = l >= 0
 79848  	yyj11++
 79849  	if yyhl11 {
 79850  		yyb11 = yyj11 > l
 79851  	} else {
 79852  		yyb11 = r.CheckBreak()
 79853  	}
 79854  	if yyb11 {
 79855  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79856  		return
 79857  	}
 79858  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79859  	if r.TryDecodeAsNil() {
 79860  		if x.Token != nil {
 79861  			x.Token = nil
 79862  		}
 79863  	} else {
 79864  		if x.Token == nil {
 79865  			x.Token = new(ACLToken)
 79866  		}
 79867  		x.Token.CodecDecodeSelf(d)
 79868  	}
 79869  	yyj11++
 79870  	if yyhl11 {
 79871  		yyb11 = yyj11 > l
 79872  	} else {
 79873  		yyb11 = r.CheckBreak()
 79874  	}
 79875  	if yyb11 {
 79876  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79877  		return
 79878  	}
 79879  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79880  	if r.TryDecodeAsNil() {
 79881  		x.Index = 0
 79882  	} else {
 79883  		yyv13 := &x.Index
 79884  		yym14 := z.DecBinary()
 79885  		_ = yym14
 79886  		if false {
 79887  		} else {
 79888  			*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 79889  		}
 79890  	}
 79891  	yyj11++
 79892  	if yyhl11 {
 79893  		yyb11 = yyj11 > l
 79894  	} else {
 79895  		yyb11 = r.CheckBreak()
 79896  	}
 79897  	if yyb11 {
 79898  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79899  		return
 79900  	}
 79901  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79902  	if r.TryDecodeAsNil() {
 79903  		x.LastContact = 0
 79904  	} else {
 79905  		yyv15 := &x.LastContact
 79906  		yym16 := z.DecBinary()
 79907  		_ = yym16
 79908  		if false {
 79909  		} else if z.HasExtensions() && z.DecExt(yyv15) {
 79910  		} else {
 79911  			*((*int64)(yyv15)) = int64(r.DecodeInt(64))
 79912  		}
 79913  	}
 79914  	yyj11++
 79915  	if yyhl11 {
 79916  		yyb11 = yyj11 > l
 79917  	} else {
 79918  		yyb11 = r.CheckBreak()
 79919  	}
 79920  	if yyb11 {
 79921  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79922  		return
 79923  	}
 79924  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79925  	if r.TryDecodeAsNil() {
 79926  		x.KnownLeader = false
 79927  	} else {
 79928  		yyv17 := &x.KnownLeader
 79929  		yym18 := z.DecBinary()
 79930  		_ = yym18
 79931  		if false {
 79932  		} else {
 79933  			*((*bool)(yyv17)) = r.DecodeBool()
 79934  		}
 79935  	}
 79936  	for {
 79937  		yyj11++
 79938  		if yyhl11 {
 79939  			yyb11 = yyj11 > l
 79940  		} else {
 79941  			yyb11 = r.CheckBreak()
 79942  		}
 79943  		if yyb11 {
 79944  			break
 79945  		}
 79946  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 79947  		z.DecStructFieldNotFound(yyj11-1, "")
 79948  	}
 79949  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 79950  }
 79951  
 79952  func (x *ACLTokenSetResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 79953  	var h codecSelfer100
 79954  	z, r := codec1978.GenHelperEncoder(e)
 79955  	_, _, _ = h, z, r
 79956  	if x == nil {
 79957  		r.EncodeNil()
 79958  	} else {
 79959  		yym1 := z.EncBinary()
 79960  		_ = yym1
 79961  		if false {
 79962  		} else if z.HasExtensions() && z.EncExt(x) {
 79963  		} else {
 79964  			yysep2 := !z.EncBinary()
 79965  			yy2arr2 := z.EncBasicHandle().StructToArray
 79966  			var yyq2 [4]bool
 79967  			_, _, _ = yysep2, yyq2, yy2arr2
 79968  			const yyr2 bool = false
 79969  			var yynn2 int
 79970  			if yyr2 || yy2arr2 {
 79971  				r.EncodeArrayStart(4)
 79972  			} else {
 79973  				yynn2 = 4
 79974  				for _, b := range yyq2 {
 79975  					if b {
 79976  						yynn2++
 79977  					}
 79978  				}
 79979  				r.EncodeMapStart(yynn2)
 79980  				yynn2 = 0
 79981  			}
 79982  			if yyr2 || yy2arr2 {
 79983  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 79984  				if x.Tokens == nil {
 79985  					r.EncodeNil()
 79986  				} else {
 79987  					yym4 := z.EncBinary()
 79988  					_ = yym4
 79989  					if false {
 79990  					} else {
 79991  						h.encMapstringPtrtoACLToken((map[string]*ACLToken)(x.Tokens), e)
 79992  					}
 79993  				}
 79994  			} else {
 79995  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 79996  				r.EncodeString(codecSelferC_UTF8100, string("Tokens"))
 79997  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 79998  				if x.Tokens == nil {
 79999  					r.EncodeNil()
 80000  				} else {
 80001  					yym5 := z.EncBinary()
 80002  					_ = yym5
 80003  					if false {
 80004  					} else {
 80005  						h.encMapstringPtrtoACLToken((map[string]*ACLToken)(x.Tokens), e)
 80006  					}
 80007  				}
 80008  			}
 80009  			if yyr2 || yy2arr2 {
 80010  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80011  				yym7 := z.EncBinary()
 80012  				_ = yym7
 80013  				if false {
 80014  				} else {
 80015  					r.EncodeUint(uint64(x.Index))
 80016  				}
 80017  			} else {
 80018  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80019  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 80020  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80021  				yym8 := z.EncBinary()
 80022  				_ = yym8
 80023  				if false {
 80024  				} else {
 80025  					r.EncodeUint(uint64(x.Index))
 80026  				}
 80027  			}
 80028  			if yyr2 || yy2arr2 {
 80029  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80030  				yym10 := z.EncBinary()
 80031  				_ = yym10
 80032  				if false {
 80033  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 80034  				} else {
 80035  					r.EncodeInt(int64(x.LastContact))
 80036  				}
 80037  			} else {
 80038  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80039  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 80040  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80041  				yym11 := z.EncBinary()
 80042  				_ = yym11
 80043  				if false {
 80044  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 80045  				} else {
 80046  					r.EncodeInt(int64(x.LastContact))
 80047  				}
 80048  			}
 80049  			if yyr2 || yy2arr2 {
 80050  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80051  				yym13 := z.EncBinary()
 80052  				_ = yym13
 80053  				if false {
 80054  				} else {
 80055  					r.EncodeBool(bool(x.KnownLeader))
 80056  				}
 80057  			} else {
 80058  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80059  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 80060  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80061  				yym14 := z.EncBinary()
 80062  				_ = yym14
 80063  				if false {
 80064  				} else {
 80065  					r.EncodeBool(bool(x.KnownLeader))
 80066  				}
 80067  			}
 80068  			if yyr2 || yy2arr2 {
 80069  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 80070  			} else {
 80071  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 80072  			}
 80073  		}
 80074  	}
 80075  }
 80076  
 80077  func (x *ACLTokenSetResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 80078  	var h codecSelfer100
 80079  	z, r := codec1978.GenHelperDecoder(d)
 80080  	_, _, _ = h, z, r
 80081  	yym1 := z.DecBinary()
 80082  	_ = yym1
 80083  	if false {
 80084  	} else if z.HasExtensions() && z.DecExt(x) {
 80085  	} else {
 80086  		yyct2 := r.ContainerType()
 80087  		if yyct2 == codecSelferValueTypeMap100 {
 80088  			yyl2 := r.ReadMapStart()
 80089  			if yyl2 == 0 {
 80090  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 80091  			} else {
 80092  				x.codecDecodeSelfFromMap(yyl2, d)
 80093  			}
 80094  		} else if yyct2 == codecSelferValueTypeArray100 {
 80095  			yyl2 := r.ReadArrayStart()
 80096  			if yyl2 == 0 {
 80097  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80098  			} else {
 80099  				x.codecDecodeSelfFromArray(yyl2, d)
 80100  			}
 80101  		} else {
 80102  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 80103  		}
 80104  	}
 80105  }
 80106  
 80107  func (x *ACLTokenSetResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 80108  	var h codecSelfer100
 80109  	z, r := codec1978.GenHelperDecoder(d)
 80110  	_, _, _ = h, z, r
 80111  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 80112  	_ = yys3Slc
 80113  	var yyhl3 bool = l >= 0
 80114  	for yyj3 := 0; ; yyj3++ {
 80115  		if yyhl3 {
 80116  			if yyj3 >= l {
 80117  				break
 80118  			}
 80119  		} else {
 80120  			if r.CheckBreak() {
 80121  				break
 80122  			}
 80123  		}
 80124  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 80125  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 80126  		yys3 := string(yys3Slc)
 80127  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 80128  		switch yys3 {
 80129  		case "Tokens":
 80130  			if r.TryDecodeAsNil() {
 80131  				x.Tokens = nil
 80132  			} else {
 80133  				yyv4 := &x.Tokens
 80134  				yym5 := z.DecBinary()
 80135  				_ = yym5
 80136  				if false {
 80137  				} else {
 80138  					h.decMapstringPtrtoACLToken((*map[string]*ACLToken)(yyv4), d)
 80139  				}
 80140  			}
 80141  		case "Index":
 80142  			if r.TryDecodeAsNil() {
 80143  				x.Index = 0
 80144  			} else {
 80145  				yyv6 := &x.Index
 80146  				yym7 := z.DecBinary()
 80147  				_ = yym7
 80148  				if false {
 80149  				} else {
 80150  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 80151  				}
 80152  			}
 80153  		case "LastContact":
 80154  			if r.TryDecodeAsNil() {
 80155  				x.LastContact = 0
 80156  			} else {
 80157  				yyv8 := &x.LastContact
 80158  				yym9 := z.DecBinary()
 80159  				_ = yym9
 80160  				if false {
 80161  				} else if z.HasExtensions() && z.DecExt(yyv8) {
 80162  				} else {
 80163  					*((*int64)(yyv8)) = int64(r.DecodeInt(64))
 80164  				}
 80165  			}
 80166  		case "KnownLeader":
 80167  			if r.TryDecodeAsNil() {
 80168  				x.KnownLeader = false
 80169  			} else {
 80170  				yyv10 := &x.KnownLeader
 80171  				yym11 := z.DecBinary()
 80172  				_ = yym11
 80173  				if false {
 80174  				} else {
 80175  					*((*bool)(yyv10)) = r.DecodeBool()
 80176  				}
 80177  			}
 80178  		default:
 80179  			z.DecStructFieldNotFound(-1, yys3)
 80180  		} // end switch yys3
 80181  	} // end for yyj3
 80182  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 80183  }
 80184  
 80185  func (x *ACLTokenSetResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 80186  	var h codecSelfer100
 80187  	z, r := codec1978.GenHelperDecoder(d)
 80188  	_, _, _ = h, z, r
 80189  	var yyj12 int
 80190  	var yyb12 bool
 80191  	var yyhl12 bool = l >= 0
 80192  	yyj12++
 80193  	if yyhl12 {
 80194  		yyb12 = yyj12 > l
 80195  	} else {
 80196  		yyb12 = r.CheckBreak()
 80197  	}
 80198  	if yyb12 {
 80199  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80200  		return
 80201  	}
 80202  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 80203  	if r.TryDecodeAsNil() {
 80204  		x.Tokens = nil
 80205  	} else {
 80206  		yyv13 := &x.Tokens
 80207  		yym14 := z.DecBinary()
 80208  		_ = yym14
 80209  		if false {
 80210  		} else {
 80211  			h.decMapstringPtrtoACLToken((*map[string]*ACLToken)(yyv13), d)
 80212  		}
 80213  	}
 80214  	yyj12++
 80215  	if yyhl12 {
 80216  		yyb12 = yyj12 > l
 80217  	} else {
 80218  		yyb12 = r.CheckBreak()
 80219  	}
 80220  	if yyb12 {
 80221  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80222  		return
 80223  	}
 80224  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 80225  	if r.TryDecodeAsNil() {
 80226  		x.Index = 0
 80227  	} else {
 80228  		yyv15 := &x.Index
 80229  		yym16 := z.DecBinary()
 80230  		_ = yym16
 80231  		if false {
 80232  		} else {
 80233  			*((*uint64)(yyv15)) = uint64(r.DecodeUint(64))
 80234  		}
 80235  	}
 80236  	yyj12++
 80237  	if yyhl12 {
 80238  		yyb12 = yyj12 > l
 80239  	} else {
 80240  		yyb12 = r.CheckBreak()
 80241  	}
 80242  	if yyb12 {
 80243  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80244  		return
 80245  	}
 80246  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 80247  	if r.TryDecodeAsNil() {
 80248  		x.LastContact = 0
 80249  	} else {
 80250  		yyv17 := &x.LastContact
 80251  		yym18 := z.DecBinary()
 80252  		_ = yym18
 80253  		if false {
 80254  		} else if z.HasExtensions() && z.DecExt(yyv17) {
 80255  		} else {
 80256  			*((*int64)(yyv17)) = int64(r.DecodeInt(64))
 80257  		}
 80258  	}
 80259  	yyj12++
 80260  	if yyhl12 {
 80261  		yyb12 = yyj12 > l
 80262  	} else {
 80263  		yyb12 = r.CheckBreak()
 80264  	}
 80265  	if yyb12 {
 80266  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80267  		return
 80268  	}
 80269  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 80270  	if r.TryDecodeAsNil() {
 80271  		x.KnownLeader = false
 80272  	} else {
 80273  		yyv19 := &x.KnownLeader
 80274  		yym20 := z.DecBinary()
 80275  		_ = yym20
 80276  		if false {
 80277  		} else {
 80278  			*((*bool)(yyv19)) = r.DecodeBool()
 80279  		}
 80280  	}
 80281  	for {
 80282  		yyj12++
 80283  		if yyhl12 {
 80284  			yyb12 = yyj12 > l
 80285  		} else {
 80286  			yyb12 = r.CheckBreak()
 80287  		}
 80288  		if yyb12 {
 80289  			break
 80290  		}
 80291  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 80292  		z.DecStructFieldNotFound(yyj12-1, "")
 80293  	}
 80294  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80295  }
 80296  
 80297  func (x *ResolveACLTokenRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 80298  	var h codecSelfer100
 80299  	z, r := codec1978.GenHelperEncoder(e)
 80300  	_, _, _ = h, z, r
 80301  	if x == nil {
 80302  		r.EncodeNil()
 80303  	} else {
 80304  		yym1 := z.EncBinary()
 80305  		_ = yym1
 80306  		if false {
 80307  		} else if z.HasExtensions() && z.EncExt(x) {
 80308  		} else {
 80309  			yysep2 := !z.EncBinary()
 80310  			yy2arr2 := z.EncBasicHandle().StructToArray
 80311  			var yyq2 [9]bool
 80312  			_, _, _ = yysep2, yyq2, yy2arr2
 80313  			const yyr2 bool = false
 80314  			var yynn2 int
 80315  			if yyr2 || yy2arr2 {
 80316  				r.EncodeArrayStart(9)
 80317  			} else {
 80318  				yynn2 = 9
 80319  				for _, b := range yyq2 {
 80320  					if b {
 80321  						yynn2++
 80322  					}
 80323  				}
 80324  				r.EncodeMapStart(yynn2)
 80325  				yynn2 = 0
 80326  			}
 80327  			if yyr2 || yy2arr2 {
 80328  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80329  				yym4 := z.EncBinary()
 80330  				_ = yym4
 80331  				if false {
 80332  				} else {
 80333  					r.EncodeString(codecSelferC_UTF8100, string(x.SecretID))
 80334  				}
 80335  			} else {
 80336  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80337  				r.EncodeString(codecSelferC_UTF8100, string("SecretID"))
 80338  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80339  				yym5 := z.EncBinary()
 80340  				_ = yym5
 80341  				if false {
 80342  				} else {
 80343  					r.EncodeString(codecSelferC_UTF8100, string(x.SecretID))
 80344  				}
 80345  			}
 80346  			if yyr2 || yy2arr2 {
 80347  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80348  				yym7 := z.EncBinary()
 80349  				_ = yym7
 80350  				if false {
 80351  				} else {
 80352  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 80353  				}
 80354  			} else {
 80355  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80356  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 80357  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80358  				yym8 := z.EncBinary()
 80359  				_ = yym8
 80360  				if false {
 80361  				} else {
 80362  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 80363  				}
 80364  			}
 80365  			if yyr2 || yy2arr2 {
 80366  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80367  				yym10 := z.EncBinary()
 80368  				_ = yym10
 80369  				if false {
 80370  				} else {
 80371  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 80372  				}
 80373  			} else {
 80374  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80375  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 80376  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80377  				yym11 := z.EncBinary()
 80378  				_ = yym11
 80379  				if false {
 80380  				} else {
 80381  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 80382  				}
 80383  			}
 80384  			if yyr2 || yy2arr2 {
 80385  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80386  				yym13 := z.EncBinary()
 80387  				_ = yym13
 80388  				if false {
 80389  				} else {
 80390  					r.EncodeUint(uint64(x.MinQueryIndex))
 80391  				}
 80392  			} else {
 80393  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80394  				r.EncodeString(codecSelferC_UTF8100, string("MinQueryIndex"))
 80395  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80396  				yym14 := z.EncBinary()
 80397  				_ = yym14
 80398  				if false {
 80399  				} else {
 80400  					r.EncodeUint(uint64(x.MinQueryIndex))
 80401  				}
 80402  			}
 80403  			if yyr2 || yy2arr2 {
 80404  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80405  				yym16 := z.EncBinary()
 80406  				_ = yym16
 80407  				if false {
 80408  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 80409  				} else {
 80410  					r.EncodeInt(int64(x.MaxQueryTime))
 80411  				}
 80412  			} else {
 80413  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80414  				r.EncodeString(codecSelferC_UTF8100, string("MaxQueryTime"))
 80415  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80416  				yym17 := z.EncBinary()
 80417  				_ = yym17
 80418  				if false {
 80419  				} else if z.HasExtensions() && z.EncExt(x.MaxQueryTime) {
 80420  				} else {
 80421  					r.EncodeInt(int64(x.MaxQueryTime))
 80422  				}
 80423  			}
 80424  			if yyr2 || yy2arr2 {
 80425  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80426  				yym19 := z.EncBinary()
 80427  				_ = yym19
 80428  				if false {
 80429  				} else {
 80430  					r.EncodeBool(bool(x.AllowStale))
 80431  				}
 80432  			} else {
 80433  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80434  				r.EncodeString(codecSelferC_UTF8100, string("AllowStale"))
 80435  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80436  				yym20 := z.EncBinary()
 80437  				_ = yym20
 80438  				if false {
 80439  				} else {
 80440  					r.EncodeBool(bool(x.AllowStale))
 80441  				}
 80442  			}
 80443  			if yyr2 || yy2arr2 {
 80444  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80445  				yym22 := z.EncBinary()
 80446  				_ = yym22
 80447  				if false {
 80448  				} else {
 80449  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 80450  				}
 80451  			} else {
 80452  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80453  				r.EncodeString(codecSelferC_UTF8100, string("Prefix"))
 80454  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80455  				yym23 := z.EncBinary()
 80456  				_ = yym23
 80457  				if false {
 80458  				} else {
 80459  					r.EncodeString(codecSelferC_UTF8100, string(x.Prefix))
 80460  				}
 80461  			}
 80462  			if yyr2 || yy2arr2 {
 80463  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80464  				yym25 := z.EncBinary()
 80465  				_ = yym25
 80466  				if false {
 80467  				} else {
 80468  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 80469  				}
 80470  			} else {
 80471  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80472  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 80473  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80474  				yym26 := z.EncBinary()
 80475  				_ = yym26
 80476  				if false {
 80477  				} else {
 80478  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 80479  				}
 80480  			}
 80481  			if yyr2 || yy2arr2 {
 80482  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80483  				yym28 := z.EncBinary()
 80484  				_ = yym28
 80485  				if false {
 80486  				} else {
 80487  					r.EncodeBool(bool(x.Forwarded))
 80488  				}
 80489  			} else {
 80490  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80491  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 80492  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80493  				yym29 := z.EncBinary()
 80494  				_ = yym29
 80495  				if false {
 80496  				} else {
 80497  					r.EncodeBool(bool(x.Forwarded))
 80498  				}
 80499  			}
 80500  			if yyr2 || yy2arr2 {
 80501  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 80502  			} else {
 80503  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 80504  			}
 80505  		}
 80506  	}
 80507  }
 80508  
 80509  func (x *ResolveACLTokenRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 80510  	var h codecSelfer100
 80511  	z, r := codec1978.GenHelperDecoder(d)
 80512  	_, _, _ = h, z, r
 80513  	yym1 := z.DecBinary()
 80514  	_ = yym1
 80515  	if false {
 80516  	} else if z.HasExtensions() && z.DecExt(x) {
 80517  	} else {
 80518  		yyct2 := r.ContainerType()
 80519  		if yyct2 == codecSelferValueTypeMap100 {
 80520  			yyl2 := r.ReadMapStart()
 80521  			if yyl2 == 0 {
 80522  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 80523  			} else {
 80524  				x.codecDecodeSelfFromMap(yyl2, d)
 80525  			}
 80526  		} else if yyct2 == codecSelferValueTypeArray100 {
 80527  			yyl2 := r.ReadArrayStart()
 80528  			if yyl2 == 0 {
 80529  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80530  			} else {
 80531  				x.codecDecodeSelfFromArray(yyl2, d)
 80532  			}
 80533  		} else {
 80534  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 80535  		}
 80536  	}
 80537  }
 80538  
 80539  func (x *ResolveACLTokenRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 80540  	var h codecSelfer100
 80541  	z, r := codec1978.GenHelperDecoder(d)
 80542  	_, _, _ = h, z, r
 80543  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 80544  	_ = yys3Slc
 80545  	var yyhl3 bool = l >= 0
 80546  	for yyj3 := 0; ; yyj3++ {
 80547  		if yyhl3 {
 80548  			if yyj3 >= l {
 80549  				break
 80550  			}
 80551  		} else {
 80552  			if r.CheckBreak() {
 80553  				break
 80554  			}
 80555  		}
 80556  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 80557  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 80558  		yys3 := string(yys3Slc)
 80559  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 80560  		switch yys3 {
 80561  		case "SecretID":
 80562  			if r.TryDecodeAsNil() {
 80563  				x.SecretID = ""
 80564  			} else {
 80565  				yyv4 := &x.SecretID
 80566  				yym5 := z.DecBinary()
 80567  				_ = yym5
 80568  				if false {
 80569  				} else {
 80570  					*((*string)(yyv4)) = r.DecodeString()
 80571  				}
 80572  			}
 80573  		case "Region":
 80574  			if r.TryDecodeAsNil() {
 80575  				x.Region = ""
 80576  			} else {
 80577  				yyv6 := &x.Region
 80578  				yym7 := z.DecBinary()
 80579  				_ = yym7
 80580  				if false {
 80581  				} else {
 80582  					*((*string)(yyv6)) = r.DecodeString()
 80583  				}
 80584  			}
 80585  		case "Namespace":
 80586  			if r.TryDecodeAsNil() {
 80587  				x.Namespace = ""
 80588  			} else {
 80589  				yyv8 := &x.Namespace
 80590  				yym9 := z.DecBinary()
 80591  				_ = yym9
 80592  				if false {
 80593  				} else {
 80594  					*((*string)(yyv8)) = r.DecodeString()
 80595  				}
 80596  			}
 80597  		case "MinQueryIndex":
 80598  			if r.TryDecodeAsNil() {
 80599  				x.MinQueryIndex = 0
 80600  			} else {
 80601  				yyv10 := &x.MinQueryIndex
 80602  				yym11 := z.DecBinary()
 80603  				_ = yym11
 80604  				if false {
 80605  				} else {
 80606  					*((*uint64)(yyv10)) = uint64(r.DecodeUint(64))
 80607  				}
 80608  			}
 80609  		case "MaxQueryTime":
 80610  			if r.TryDecodeAsNil() {
 80611  				x.MaxQueryTime = 0
 80612  			} else {
 80613  				yyv12 := &x.MaxQueryTime
 80614  				yym13 := z.DecBinary()
 80615  				_ = yym13
 80616  				if false {
 80617  				} else if z.HasExtensions() && z.DecExt(yyv12) {
 80618  				} else {
 80619  					*((*int64)(yyv12)) = int64(r.DecodeInt(64))
 80620  				}
 80621  			}
 80622  		case "AllowStale":
 80623  			if r.TryDecodeAsNil() {
 80624  				x.AllowStale = false
 80625  			} else {
 80626  				yyv14 := &x.AllowStale
 80627  				yym15 := z.DecBinary()
 80628  				_ = yym15
 80629  				if false {
 80630  				} else {
 80631  					*((*bool)(yyv14)) = r.DecodeBool()
 80632  				}
 80633  			}
 80634  		case "Prefix":
 80635  			if r.TryDecodeAsNil() {
 80636  				x.Prefix = ""
 80637  			} else {
 80638  				yyv16 := &x.Prefix
 80639  				yym17 := z.DecBinary()
 80640  				_ = yym17
 80641  				if false {
 80642  				} else {
 80643  					*((*string)(yyv16)) = r.DecodeString()
 80644  				}
 80645  			}
 80646  		case "AuthToken":
 80647  			if r.TryDecodeAsNil() {
 80648  				x.AuthToken = ""
 80649  			} else {
 80650  				yyv18 := &x.AuthToken
 80651  				yym19 := z.DecBinary()
 80652  				_ = yym19
 80653  				if false {
 80654  				} else {
 80655  					*((*string)(yyv18)) = r.DecodeString()
 80656  				}
 80657  			}
 80658  		case "Forwarded":
 80659  			if r.TryDecodeAsNil() {
 80660  				x.Forwarded = false
 80661  			} else {
 80662  				yyv20 := &x.Forwarded
 80663  				yym21 := z.DecBinary()
 80664  				_ = yym21
 80665  				if false {
 80666  				} else {
 80667  					*((*bool)(yyv20)) = r.DecodeBool()
 80668  				}
 80669  			}
 80670  		default:
 80671  			z.DecStructFieldNotFound(-1, yys3)
 80672  		} // end switch yys3
 80673  	} // end for yyj3
 80674  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 80675  }
 80676  
 80677  func (x *ResolveACLTokenRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 80678  	var h codecSelfer100
 80679  	z, r := codec1978.GenHelperDecoder(d)
 80680  	_, _, _ = h, z, r
 80681  	var yyj22 int
 80682  	var yyb22 bool
 80683  	var yyhl22 bool = l >= 0
 80684  	yyj22++
 80685  	if yyhl22 {
 80686  		yyb22 = yyj22 > l
 80687  	} else {
 80688  		yyb22 = r.CheckBreak()
 80689  	}
 80690  	if yyb22 {
 80691  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80692  		return
 80693  	}
 80694  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 80695  	if r.TryDecodeAsNil() {
 80696  		x.SecretID = ""
 80697  	} else {
 80698  		yyv23 := &x.SecretID
 80699  		yym24 := z.DecBinary()
 80700  		_ = yym24
 80701  		if false {
 80702  		} else {
 80703  			*((*string)(yyv23)) = r.DecodeString()
 80704  		}
 80705  	}
 80706  	yyj22++
 80707  	if yyhl22 {
 80708  		yyb22 = yyj22 > l
 80709  	} else {
 80710  		yyb22 = r.CheckBreak()
 80711  	}
 80712  	if yyb22 {
 80713  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80714  		return
 80715  	}
 80716  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 80717  	if r.TryDecodeAsNil() {
 80718  		x.Region = ""
 80719  	} else {
 80720  		yyv25 := &x.Region
 80721  		yym26 := z.DecBinary()
 80722  		_ = yym26
 80723  		if false {
 80724  		} else {
 80725  			*((*string)(yyv25)) = r.DecodeString()
 80726  		}
 80727  	}
 80728  	yyj22++
 80729  	if yyhl22 {
 80730  		yyb22 = yyj22 > l
 80731  	} else {
 80732  		yyb22 = r.CheckBreak()
 80733  	}
 80734  	if yyb22 {
 80735  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80736  		return
 80737  	}
 80738  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 80739  	if r.TryDecodeAsNil() {
 80740  		x.Namespace = ""
 80741  	} else {
 80742  		yyv27 := &x.Namespace
 80743  		yym28 := z.DecBinary()
 80744  		_ = yym28
 80745  		if false {
 80746  		} else {
 80747  			*((*string)(yyv27)) = r.DecodeString()
 80748  		}
 80749  	}
 80750  	yyj22++
 80751  	if yyhl22 {
 80752  		yyb22 = yyj22 > l
 80753  	} else {
 80754  		yyb22 = r.CheckBreak()
 80755  	}
 80756  	if yyb22 {
 80757  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80758  		return
 80759  	}
 80760  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 80761  	if r.TryDecodeAsNil() {
 80762  		x.MinQueryIndex = 0
 80763  	} else {
 80764  		yyv29 := &x.MinQueryIndex
 80765  		yym30 := z.DecBinary()
 80766  		_ = yym30
 80767  		if false {
 80768  		} else {
 80769  			*((*uint64)(yyv29)) = uint64(r.DecodeUint(64))
 80770  		}
 80771  	}
 80772  	yyj22++
 80773  	if yyhl22 {
 80774  		yyb22 = yyj22 > l
 80775  	} else {
 80776  		yyb22 = r.CheckBreak()
 80777  	}
 80778  	if yyb22 {
 80779  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80780  		return
 80781  	}
 80782  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 80783  	if r.TryDecodeAsNil() {
 80784  		x.MaxQueryTime = 0
 80785  	} else {
 80786  		yyv31 := &x.MaxQueryTime
 80787  		yym32 := z.DecBinary()
 80788  		_ = yym32
 80789  		if false {
 80790  		} else if z.HasExtensions() && z.DecExt(yyv31) {
 80791  		} else {
 80792  			*((*int64)(yyv31)) = int64(r.DecodeInt(64))
 80793  		}
 80794  	}
 80795  	yyj22++
 80796  	if yyhl22 {
 80797  		yyb22 = yyj22 > l
 80798  	} else {
 80799  		yyb22 = r.CheckBreak()
 80800  	}
 80801  	if yyb22 {
 80802  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80803  		return
 80804  	}
 80805  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 80806  	if r.TryDecodeAsNil() {
 80807  		x.AllowStale = false
 80808  	} else {
 80809  		yyv33 := &x.AllowStale
 80810  		yym34 := z.DecBinary()
 80811  		_ = yym34
 80812  		if false {
 80813  		} else {
 80814  			*((*bool)(yyv33)) = r.DecodeBool()
 80815  		}
 80816  	}
 80817  	yyj22++
 80818  	if yyhl22 {
 80819  		yyb22 = yyj22 > l
 80820  	} else {
 80821  		yyb22 = r.CheckBreak()
 80822  	}
 80823  	if yyb22 {
 80824  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80825  		return
 80826  	}
 80827  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 80828  	if r.TryDecodeAsNil() {
 80829  		x.Prefix = ""
 80830  	} else {
 80831  		yyv35 := &x.Prefix
 80832  		yym36 := z.DecBinary()
 80833  		_ = yym36
 80834  		if false {
 80835  		} else {
 80836  			*((*string)(yyv35)) = r.DecodeString()
 80837  		}
 80838  	}
 80839  	yyj22++
 80840  	if yyhl22 {
 80841  		yyb22 = yyj22 > l
 80842  	} else {
 80843  		yyb22 = r.CheckBreak()
 80844  	}
 80845  	if yyb22 {
 80846  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80847  		return
 80848  	}
 80849  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 80850  	if r.TryDecodeAsNil() {
 80851  		x.AuthToken = ""
 80852  	} else {
 80853  		yyv37 := &x.AuthToken
 80854  		yym38 := z.DecBinary()
 80855  		_ = yym38
 80856  		if false {
 80857  		} else {
 80858  			*((*string)(yyv37)) = r.DecodeString()
 80859  		}
 80860  	}
 80861  	yyj22++
 80862  	if yyhl22 {
 80863  		yyb22 = yyj22 > l
 80864  	} else {
 80865  		yyb22 = r.CheckBreak()
 80866  	}
 80867  	if yyb22 {
 80868  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80869  		return
 80870  	}
 80871  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 80872  	if r.TryDecodeAsNil() {
 80873  		x.Forwarded = false
 80874  	} else {
 80875  		yyv39 := &x.Forwarded
 80876  		yym40 := z.DecBinary()
 80877  		_ = yym40
 80878  		if false {
 80879  		} else {
 80880  			*((*bool)(yyv39)) = r.DecodeBool()
 80881  		}
 80882  	}
 80883  	for {
 80884  		yyj22++
 80885  		if yyhl22 {
 80886  			yyb22 = yyj22 > l
 80887  		} else {
 80888  			yyb22 = r.CheckBreak()
 80889  		}
 80890  		if yyb22 {
 80891  			break
 80892  		}
 80893  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 80894  		z.DecStructFieldNotFound(yyj22-1, "")
 80895  	}
 80896  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 80897  }
 80898  
 80899  func (x *ResolveACLTokenResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 80900  	var h codecSelfer100
 80901  	z, r := codec1978.GenHelperEncoder(e)
 80902  	_, _, _ = h, z, r
 80903  	if x == nil {
 80904  		r.EncodeNil()
 80905  	} else {
 80906  		yym1 := z.EncBinary()
 80907  		_ = yym1
 80908  		if false {
 80909  		} else if z.HasExtensions() && z.EncExt(x) {
 80910  		} else {
 80911  			yysep2 := !z.EncBinary()
 80912  			yy2arr2 := z.EncBasicHandle().StructToArray
 80913  			var yyq2 [4]bool
 80914  			_, _, _ = yysep2, yyq2, yy2arr2
 80915  			const yyr2 bool = false
 80916  			var yynn2 int
 80917  			if yyr2 || yy2arr2 {
 80918  				r.EncodeArrayStart(4)
 80919  			} else {
 80920  				yynn2 = 4
 80921  				for _, b := range yyq2 {
 80922  					if b {
 80923  						yynn2++
 80924  					}
 80925  				}
 80926  				r.EncodeMapStart(yynn2)
 80927  				yynn2 = 0
 80928  			}
 80929  			if yyr2 || yy2arr2 {
 80930  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80931  				if x.Token == nil {
 80932  					r.EncodeNil()
 80933  				} else {
 80934  					x.Token.CodecEncodeSelf(e)
 80935  				}
 80936  			} else {
 80937  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80938  				r.EncodeString(codecSelferC_UTF8100, string("Token"))
 80939  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80940  				if x.Token == nil {
 80941  					r.EncodeNil()
 80942  				} else {
 80943  					x.Token.CodecEncodeSelf(e)
 80944  				}
 80945  			}
 80946  			if yyr2 || yy2arr2 {
 80947  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80948  				yym7 := z.EncBinary()
 80949  				_ = yym7
 80950  				if false {
 80951  				} else {
 80952  					r.EncodeUint(uint64(x.Index))
 80953  				}
 80954  			} else {
 80955  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80956  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 80957  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80958  				yym8 := z.EncBinary()
 80959  				_ = yym8
 80960  				if false {
 80961  				} else {
 80962  					r.EncodeUint(uint64(x.Index))
 80963  				}
 80964  			}
 80965  			if yyr2 || yy2arr2 {
 80966  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80967  				yym10 := z.EncBinary()
 80968  				_ = yym10
 80969  				if false {
 80970  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 80971  				} else {
 80972  					r.EncodeInt(int64(x.LastContact))
 80973  				}
 80974  			} else {
 80975  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80976  				r.EncodeString(codecSelferC_UTF8100, string("LastContact"))
 80977  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80978  				yym11 := z.EncBinary()
 80979  				_ = yym11
 80980  				if false {
 80981  				} else if z.HasExtensions() && z.EncExt(x.LastContact) {
 80982  				} else {
 80983  					r.EncodeInt(int64(x.LastContact))
 80984  				}
 80985  			}
 80986  			if yyr2 || yy2arr2 {
 80987  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 80988  				yym13 := z.EncBinary()
 80989  				_ = yym13
 80990  				if false {
 80991  				} else {
 80992  					r.EncodeBool(bool(x.KnownLeader))
 80993  				}
 80994  			} else {
 80995  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 80996  				r.EncodeString(codecSelferC_UTF8100, string("KnownLeader"))
 80997  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 80998  				yym14 := z.EncBinary()
 80999  				_ = yym14
 81000  				if false {
 81001  				} else {
 81002  					r.EncodeBool(bool(x.KnownLeader))
 81003  				}
 81004  			}
 81005  			if yyr2 || yy2arr2 {
 81006  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 81007  			} else {
 81008  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 81009  			}
 81010  		}
 81011  	}
 81012  }
 81013  
 81014  func (x *ResolveACLTokenResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 81015  	var h codecSelfer100
 81016  	z, r := codec1978.GenHelperDecoder(d)
 81017  	_, _, _ = h, z, r
 81018  	yym1 := z.DecBinary()
 81019  	_ = yym1
 81020  	if false {
 81021  	} else if z.HasExtensions() && z.DecExt(x) {
 81022  	} else {
 81023  		yyct2 := r.ContainerType()
 81024  		if yyct2 == codecSelferValueTypeMap100 {
 81025  			yyl2 := r.ReadMapStart()
 81026  			if yyl2 == 0 {
 81027  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 81028  			} else {
 81029  				x.codecDecodeSelfFromMap(yyl2, d)
 81030  			}
 81031  		} else if yyct2 == codecSelferValueTypeArray100 {
 81032  			yyl2 := r.ReadArrayStart()
 81033  			if yyl2 == 0 {
 81034  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81035  			} else {
 81036  				x.codecDecodeSelfFromArray(yyl2, d)
 81037  			}
 81038  		} else {
 81039  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 81040  		}
 81041  	}
 81042  }
 81043  
 81044  func (x *ResolveACLTokenResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 81045  	var h codecSelfer100
 81046  	z, r := codec1978.GenHelperDecoder(d)
 81047  	_, _, _ = h, z, r
 81048  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 81049  	_ = yys3Slc
 81050  	var yyhl3 bool = l >= 0
 81051  	for yyj3 := 0; ; yyj3++ {
 81052  		if yyhl3 {
 81053  			if yyj3 >= l {
 81054  				break
 81055  			}
 81056  		} else {
 81057  			if r.CheckBreak() {
 81058  				break
 81059  			}
 81060  		}
 81061  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 81062  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 81063  		yys3 := string(yys3Slc)
 81064  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 81065  		switch yys3 {
 81066  		case "Token":
 81067  			if r.TryDecodeAsNil() {
 81068  				if x.Token != nil {
 81069  					x.Token = nil
 81070  				}
 81071  			} else {
 81072  				if x.Token == nil {
 81073  					x.Token = new(ACLToken)
 81074  				}
 81075  				x.Token.CodecDecodeSelf(d)
 81076  			}
 81077  		case "Index":
 81078  			if r.TryDecodeAsNil() {
 81079  				x.Index = 0
 81080  			} else {
 81081  				yyv5 := &x.Index
 81082  				yym6 := z.DecBinary()
 81083  				_ = yym6
 81084  				if false {
 81085  				} else {
 81086  					*((*uint64)(yyv5)) = uint64(r.DecodeUint(64))
 81087  				}
 81088  			}
 81089  		case "LastContact":
 81090  			if r.TryDecodeAsNil() {
 81091  				x.LastContact = 0
 81092  			} else {
 81093  				yyv7 := &x.LastContact
 81094  				yym8 := z.DecBinary()
 81095  				_ = yym8
 81096  				if false {
 81097  				} else if z.HasExtensions() && z.DecExt(yyv7) {
 81098  				} else {
 81099  					*((*int64)(yyv7)) = int64(r.DecodeInt(64))
 81100  				}
 81101  			}
 81102  		case "KnownLeader":
 81103  			if r.TryDecodeAsNil() {
 81104  				x.KnownLeader = false
 81105  			} else {
 81106  				yyv9 := &x.KnownLeader
 81107  				yym10 := z.DecBinary()
 81108  				_ = yym10
 81109  				if false {
 81110  				} else {
 81111  					*((*bool)(yyv9)) = r.DecodeBool()
 81112  				}
 81113  			}
 81114  		default:
 81115  			z.DecStructFieldNotFound(-1, yys3)
 81116  		} // end switch yys3
 81117  	} // end for yyj3
 81118  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 81119  }
 81120  
 81121  func (x *ResolveACLTokenResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 81122  	var h codecSelfer100
 81123  	z, r := codec1978.GenHelperDecoder(d)
 81124  	_, _, _ = h, z, r
 81125  	var yyj11 int
 81126  	var yyb11 bool
 81127  	var yyhl11 bool = l >= 0
 81128  	yyj11++
 81129  	if yyhl11 {
 81130  		yyb11 = yyj11 > l
 81131  	} else {
 81132  		yyb11 = r.CheckBreak()
 81133  	}
 81134  	if yyb11 {
 81135  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81136  		return
 81137  	}
 81138  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 81139  	if r.TryDecodeAsNil() {
 81140  		if x.Token != nil {
 81141  			x.Token = nil
 81142  		}
 81143  	} else {
 81144  		if x.Token == nil {
 81145  			x.Token = new(ACLToken)
 81146  		}
 81147  		x.Token.CodecDecodeSelf(d)
 81148  	}
 81149  	yyj11++
 81150  	if yyhl11 {
 81151  		yyb11 = yyj11 > l
 81152  	} else {
 81153  		yyb11 = r.CheckBreak()
 81154  	}
 81155  	if yyb11 {
 81156  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81157  		return
 81158  	}
 81159  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 81160  	if r.TryDecodeAsNil() {
 81161  		x.Index = 0
 81162  	} else {
 81163  		yyv13 := &x.Index
 81164  		yym14 := z.DecBinary()
 81165  		_ = yym14
 81166  		if false {
 81167  		} else {
 81168  			*((*uint64)(yyv13)) = uint64(r.DecodeUint(64))
 81169  		}
 81170  	}
 81171  	yyj11++
 81172  	if yyhl11 {
 81173  		yyb11 = yyj11 > l
 81174  	} else {
 81175  		yyb11 = r.CheckBreak()
 81176  	}
 81177  	if yyb11 {
 81178  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81179  		return
 81180  	}
 81181  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 81182  	if r.TryDecodeAsNil() {
 81183  		x.LastContact = 0
 81184  	} else {
 81185  		yyv15 := &x.LastContact
 81186  		yym16 := z.DecBinary()
 81187  		_ = yym16
 81188  		if false {
 81189  		} else if z.HasExtensions() && z.DecExt(yyv15) {
 81190  		} else {
 81191  			*((*int64)(yyv15)) = int64(r.DecodeInt(64))
 81192  		}
 81193  	}
 81194  	yyj11++
 81195  	if yyhl11 {
 81196  		yyb11 = yyj11 > l
 81197  	} else {
 81198  		yyb11 = r.CheckBreak()
 81199  	}
 81200  	if yyb11 {
 81201  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81202  		return
 81203  	}
 81204  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 81205  	if r.TryDecodeAsNil() {
 81206  		x.KnownLeader = false
 81207  	} else {
 81208  		yyv17 := &x.KnownLeader
 81209  		yym18 := z.DecBinary()
 81210  		_ = yym18
 81211  		if false {
 81212  		} else {
 81213  			*((*bool)(yyv17)) = r.DecodeBool()
 81214  		}
 81215  	}
 81216  	for {
 81217  		yyj11++
 81218  		if yyhl11 {
 81219  			yyb11 = yyj11 > l
 81220  		} else {
 81221  			yyb11 = r.CheckBreak()
 81222  		}
 81223  		if yyb11 {
 81224  			break
 81225  		}
 81226  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 81227  		z.DecStructFieldNotFound(yyj11-1, "")
 81228  	}
 81229  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81230  }
 81231  
 81232  func (x *ACLTokenDeleteRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 81233  	var h codecSelfer100
 81234  	z, r := codec1978.GenHelperEncoder(e)
 81235  	_, _, _ = h, z, r
 81236  	if x == nil {
 81237  		r.EncodeNil()
 81238  	} else {
 81239  		yym1 := z.EncBinary()
 81240  		_ = yym1
 81241  		if false {
 81242  		} else if z.HasExtensions() && z.EncExt(x) {
 81243  		} else {
 81244  			yysep2 := !z.EncBinary()
 81245  			yy2arr2 := z.EncBasicHandle().StructToArray
 81246  			var yyq2 [5]bool
 81247  			_, _, _ = yysep2, yyq2, yy2arr2
 81248  			const yyr2 bool = false
 81249  			var yynn2 int
 81250  			if yyr2 || yy2arr2 {
 81251  				r.EncodeArrayStart(5)
 81252  			} else {
 81253  				yynn2 = 5
 81254  				for _, b := range yyq2 {
 81255  					if b {
 81256  						yynn2++
 81257  					}
 81258  				}
 81259  				r.EncodeMapStart(yynn2)
 81260  				yynn2 = 0
 81261  			}
 81262  			if yyr2 || yy2arr2 {
 81263  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 81264  				if x.AccessorIDs == nil {
 81265  					r.EncodeNil()
 81266  				} else {
 81267  					yym4 := z.EncBinary()
 81268  					_ = yym4
 81269  					if false {
 81270  					} else {
 81271  						z.F.EncSliceStringV(x.AccessorIDs, false, e)
 81272  					}
 81273  				}
 81274  			} else {
 81275  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 81276  				r.EncodeString(codecSelferC_UTF8100, string("AccessorIDs"))
 81277  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 81278  				if x.AccessorIDs == nil {
 81279  					r.EncodeNil()
 81280  				} else {
 81281  					yym5 := z.EncBinary()
 81282  					_ = yym5
 81283  					if false {
 81284  					} else {
 81285  						z.F.EncSliceStringV(x.AccessorIDs, false, e)
 81286  					}
 81287  				}
 81288  			}
 81289  			if yyr2 || yy2arr2 {
 81290  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 81291  				yym7 := z.EncBinary()
 81292  				_ = yym7
 81293  				if false {
 81294  				} else {
 81295  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 81296  				}
 81297  			} else {
 81298  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 81299  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 81300  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 81301  				yym8 := z.EncBinary()
 81302  				_ = yym8
 81303  				if false {
 81304  				} else {
 81305  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 81306  				}
 81307  			}
 81308  			if yyr2 || yy2arr2 {
 81309  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 81310  				yym10 := z.EncBinary()
 81311  				_ = yym10
 81312  				if false {
 81313  				} else {
 81314  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 81315  				}
 81316  			} else {
 81317  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 81318  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 81319  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 81320  				yym11 := z.EncBinary()
 81321  				_ = yym11
 81322  				if false {
 81323  				} else {
 81324  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 81325  				}
 81326  			}
 81327  			if yyr2 || yy2arr2 {
 81328  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 81329  				yym13 := z.EncBinary()
 81330  				_ = yym13
 81331  				if false {
 81332  				} else {
 81333  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 81334  				}
 81335  			} else {
 81336  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 81337  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 81338  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 81339  				yym14 := z.EncBinary()
 81340  				_ = yym14
 81341  				if false {
 81342  				} else {
 81343  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 81344  				}
 81345  			}
 81346  			if yyr2 || yy2arr2 {
 81347  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 81348  				yym16 := z.EncBinary()
 81349  				_ = yym16
 81350  				if false {
 81351  				} else {
 81352  					r.EncodeBool(bool(x.Forwarded))
 81353  				}
 81354  			} else {
 81355  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 81356  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 81357  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 81358  				yym17 := z.EncBinary()
 81359  				_ = yym17
 81360  				if false {
 81361  				} else {
 81362  					r.EncodeBool(bool(x.Forwarded))
 81363  				}
 81364  			}
 81365  			if yyr2 || yy2arr2 {
 81366  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 81367  			} else {
 81368  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 81369  			}
 81370  		}
 81371  	}
 81372  }
 81373  
 81374  func (x *ACLTokenDeleteRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 81375  	var h codecSelfer100
 81376  	z, r := codec1978.GenHelperDecoder(d)
 81377  	_, _, _ = h, z, r
 81378  	yym1 := z.DecBinary()
 81379  	_ = yym1
 81380  	if false {
 81381  	} else if z.HasExtensions() && z.DecExt(x) {
 81382  	} else {
 81383  		yyct2 := r.ContainerType()
 81384  		if yyct2 == codecSelferValueTypeMap100 {
 81385  			yyl2 := r.ReadMapStart()
 81386  			if yyl2 == 0 {
 81387  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 81388  			} else {
 81389  				x.codecDecodeSelfFromMap(yyl2, d)
 81390  			}
 81391  		} else if yyct2 == codecSelferValueTypeArray100 {
 81392  			yyl2 := r.ReadArrayStart()
 81393  			if yyl2 == 0 {
 81394  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81395  			} else {
 81396  				x.codecDecodeSelfFromArray(yyl2, d)
 81397  			}
 81398  		} else {
 81399  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 81400  		}
 81401  	}
 81402  }
 81403  
 81404  func (x *ACLTokenDeleteRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 81405  	var h codecSelfer100
 81406  	z, r := codec1978.GenHelperDecoder(d)
 81407  	_, _, _ = h, z, r
 81408  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 81409  	_ = yys3Slc
 81410  	var yyhl3 bool = l >= 0
 81411  	for yyj3 := 0; ; yyj3++ {
 81412  		if yyhl3 {
 81413  			if yyj3 >= l {
 81414  				break
 81415  			}
 81416  		} else {
 81417  			if r.CheckBreak() {
 81418  				break
 81419  			}
 81420  		}
 81421  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 81422  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 81423  		yys3 := string(yys3Slc)
 81424  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 81425  		switch yys3 {
 81426  		case "AccessorIDs":
 81427  			if r.TryDecodeAsNil() {
 81428  				x.AccessorIDs = nil
 81429  			} else {
 81430  				yyv4 := &x.AccessorIDs
 81431  				yym5 := z.DecBinary()
 81432  				_ = yym5
 81433  				if false {
 81434  				} else {
 81435  					z.F.DecSliceStringX(yyv4, false, d)
 81436  				}
 81437  			}
 81438  		case "Region":
 81439  			if r.TryDecodeAsNil() {
 81440  				x.Region = ""
 81441  			} else {
 81442  				yyv6 := &x.Region
 81443  				yym7 := z.DecBinary()
 81444  				_ = yym7
 81445  				if false {
 81446  				} else {
 81447  					*((*string)(yyv6)) = r.DecodeString()
 81448  				}
 81449  			}
 81450  		case "Namespace":
 81451  			if r.TryDecodeAsNil() {
 81452  				x.Namespace = ""
 81453  			} else {
 81454  				yyv8 := &x.Namespace
 81455  				yym9 := z.DecBinary()
 81456  				_ = yym9
 81457  				if false {
 81458  				} else {
 81459  					*((*string)(yyv8)) = r.DecodeString()
 81460  				}
 81461  			}
 81462  		case "AuthToken":
 81463  			if r.TryDecodeAsNil() {
 81464  				x.AuthToken = ""
 81465  			} else {
 81466  				yyv10 := &x.AuthToken
 81467  				yym11 := z.DecBinary()
 81468  				_ = yym11
 81469  				if false {
 81470  				} else {
 81471  					*((*string)(yyv10)) = r.DecodeString()
 81472  				}
 81473  			}
 81474  		case "Forwarded":
 81475  			if r.TryDecodeAsNil() {
 81476  				x.Forwarded = false
 81477  			} else {
 81478  				yyv12 := &x.Forwarded
 81479  				yym13 := z.DecBinary()
 81480  				_ = yym13
 81481  				if false {
 81482  				} else {
 81483  					*((*bool)(yyv12)) = r.DecodeBool()
 81484  				}
 81485  			}
 81486  		default:
 81487  			z.DecStructFieldNotFound(-1, yys3)
 81488  		} // end switch yys3
 81489  	} // end for yyj3
 81490  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 81491  }
 81492  
 81493  func (x *ACLTokenDeleteRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 81494  	var h codecSelfer100
 81495  	z, r := codec1978.GenHelperDecoder(d)
 81496  	_, _, _ = h, z, r
 81497  	var yyj14 int
 81498  	var yyb14 bool
 81499  	var yyhl14 bool = l >= 0
 81500  	yyj14++
 81501  	if yyhl14 {
 81502  		yyb14 = yyj14 > l
 81503  	} else {
 81504  		yyb14 = r.CheckBreak()
 81505  	}
 81506  	if yyb14 {
 81507  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81508  		return
 81509  	}
 81510  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 81511  	if r.TryDecodeAsNil() {
 81512  		x.AccessorIDs = nil
 81513  	} else {
 81514  		yyv15 := &x.AccessorIDs
 81515  		yym16 := z.DecBinary()
 81516  		_ = yym16
 81517  		if false {
 81518  		} else {
 81519  			z.F.DecSliceStringX(yyv15, false, d)
 81520  		}
 81521  	}
 81522  	yyj14++
 81523  	if yyhl14 {
 81524  		yyb14 = yyj14 > l
 81525  	} else {
 81526  		yyb14 = r.CheckBreak()
 81527  	}
 81528  	if yyb14 {
 81529  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81530  		return
 81531  	}
 81532  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 81533  	if r.TryDecodeAsNil() {
 81534  		x.Region = ""
 81535  	} else {
 81536  		yyv17 := &x.Region
 81537  		yym18 := z.DecBinary()
 81538  		_ = yym18
 81539  		if false {
 81540  		} else {
 81541  			*((*string)(yyv17)) = r.DecodeString()
 81542  		}
 81543  	}
 81544  	yyj14++
 81545  	if yyhl14 {
 81546  		yyb14 = yyj14 > l
 81547  	} else {
 81548  		yyb14 = r.CheckBreak()
 81549  	}
 81550  	if yyb14 {
 81551  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81552  		return
 81553  	}
 81554  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 81555  	if r.TryDecodeAsNil() {
 81556  		x.Namespace = ""
 81557  	} else {
 81558  		yyv19 := &x.Namespace
 81559  		yym20 := z.DecBinary()
 81560  		_ = yym20
 81561  		if false {
 81562  		} else {
 81563  			*((*string)(yyv19)) = r.DecodeString()
 81564  		}
 81565  	}
 81566  	yyj14++
 81567  	if yyhl14 {
 81568  		yyb14 = yyj14 > l
 81569  	} else {
 81570  		yyb14 = r.CheckBreak()
 81571  	}
 81572  	if yyb14 {
 81573  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81574  		return
 81575  	}
 81576  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 81577  	if r.TryDecodeAsNil() {
 81578  		x.AuthToken = ""
 81579  	} else {
 81580  		yyv21 := &x.AuthToken
 81581  		yym22 := z.DecBinary()
 81582  		_ = yym22
 81583  		if false {
 81584  		} else {
 81585  			*((*string)(yyv21)) = r.DecodeString()
 81586  		}
 81587  	}
 81588  	yyj14++
 81589  	if yyhl14 {
 81590  		yyb14 = yyj14 > l
 81591  	} else {
 81592  		yyb14 = r.CheckBreak()
 81593  	}
 81594  	if yyb14 {
 81595  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81596  		return
 81597  	}
 81598  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 81599  	if r.TryDecodeAsNil() {
 81600  		x.Forwarded = false
 81601  	} else {
 81602  		yyv23 := &x.Forwarded
 81603  		yym24 := z.DecBinary()
 81604  		_ = yym24
 81605  		if false {
 81606  		} else {
 81607  			*((*bool)(yyv23)) = r.DecodeBool()
 81608  		}
 81609  	}
 81610  	for {
 81611  		yyj14++
 81612  		if yyhl14 {
 81613  			yyb14 = yyj14 > l
 81614  		} else {
 81615  			yyb14 = r.CheckBreak()
 81616  		}
 81617  		if yyb14 {
 81618  			break
 81619  		}
 81620  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 81621  		z.DecStructFieldNotFound(yyj14-1, "")
 81622  	}
 81623  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81624  }
 81625  
 81626  func (x *ACLTokenBootstrapRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 81627  	var h codecSelfer100
 81628  	z, r := codec1978.GenHelperEncoder(e)
 81629  	_, _, _ = h, z, r
 81630  	if x == nil {
 81631  		r.EncodeNil()
 81632  	} else {
 81633  		yym1 := z.EncBinary()
 81634  		_ = yym1
 81635  		if false {
 81636  		} else if z.HasExtensions() && z.EncExt(x) {
 81637  		} else {
 81638  			yysep2 := !z.EncBinary()
 81639  			yy2arr2 := z.EncBasicHandle().StructToArray
 81640  			var yyq2 [6]bool
 81641  			_, _, _ = yysep2, yyq2, yy2arr2
 81642  			const yyr2 bool = false
 81643  			var yynn2 int
 81644  			if yyr2 || yy2arr2 {
 81645  				r.EncodeArrayStart(6)
 81646  			} else {
 81647  				yynn2 = 6
 81648  				for _, b := range yyq2 {
 81649  					if b {
 81650  						yynn2++
 81651  					}
 81652  				}
 81653  				r.EncodeMapStart(yynn2)
 81654  				yynn2 = 0
 81655  			}
 81656  			if yyr2 || yy2arr2 {
 81657  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 81658  				if x.Token == nil {
 81659  					r.EncodeNil()
 81660  				} else {
 81661  					x.Token.CodecEncodeSelf(e)
 81662  				}
 81663  			} else {
 81664  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 81665  				r.EncodeString(codecSelferC_UTF8100, string("Token"))
 81666  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 81667  				if x.Token == nil {
 81668  					r.EncodeNil()
 81669  				} else {
 81670  					x.Token.CodecEncodeSelf(e)
 81671  				}
 81672  			}
 81673  			if yyr2 || yy2arr2 {
 81674  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 81675  				yym7 := z.EncBinary()
 81676  				_ = yym7
 81677  				if false {
 81678  				} else {
 81679  					r.EncodeUint(uint64(x.ResetIndex))
 81680  				}
 81681  			} else {
 81682  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 81683  				r.EncodeString(codecSelferC_UTF8100, string("ResetIndex"))
 81684  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 81685  				yym8 := z.EncBinary()
 81686  				_ = yym8
 81687  				if false {
 81688  				} else {
 81689  					r.EncodeUint(uint64(x.ResetIndex))
 81690  				}
 81691  			}
 81692  			if yyr2 || yy2arr2 {
 81693  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 81694  				yym10 := z.EncBinary()
 81695  				_ = yym10
 81696  				if false {
 81697  				} else {
 81698  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 81699  				}
 81700  			} else {
 81701  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 81702  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 81703  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 81704  				yym11 := z.EncBinary()
 81705  				_ = yym11
 81706  				if false {
 81707  				} else {
 81708  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 81709  				}
 81710  			}
 81711  			if yyr2 || yy2arr2 {
 81712  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 81713  				yym13 := z.EncBinary()
 81714  				_ = yym13
 81715  				if false {
 81716  				} else {
 81717  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 81718  				}
 81719  			} else {
 81720  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 81721  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 81722  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 81723  				yym14 := z.EncBinary()
 81724  				_ = yym14
 81725  				if false {
 81726  				} else {
 81727  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 81728  				}
 81729  			}
 81730  			if yyr2 || yy2arr2 {
 81731  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 81732  				yym16 := z.EncBinary()
 81733  				_ = yym16
 81734  				if false {
 81735  				} else {
 81736  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 81737  				}
 81738  			} else {
 81739  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 81740  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 81741  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 81742  				yym17 := z.EncBinary()
 81743  				_ = yym17
 81744  				if false {
 81745  				} else {
 81746  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 81747  				}
 81748  			}
 81749  			if yyr2 || yy2arr2 {
 81750  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 81751  				yym19 := z.EncBinary()
 81752  				_ = yym19
 81753  				if false {
 81754  				} else {
 81755  					r.EncodeBool(bool(x.Forwarded))
 81756  				}
 81757  			} else {
 81758  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 81759  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 81760  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 81761  				yym20 := z.EncBinary()
 81762  				_ = yym20
 81763  				if false {
 81764  				} else {
 81765  					r.EncodeBool(bool(x.Forwarded))
 81766  				}
 81767  			}
 81768  			if yyr2 || yy2arr2 {
 81769  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 81770  			} else {
 81771  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 81772  			}
 81773  		}
 81774  	}
 81775  }
 81776  
 81777  func (x *ACLTokenBootstrapRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 81778  	var h codecSelfer100
 81779  	z, r := codec1978.GenHelperDecoder(d)
 81780  	_, _, _ = h, z, r
 81781  	yym1 := z.DecBinary()
 81782  	_ = yym1
 81783  	if false {
 81784  	} else if z.HasExtensions() && z.DecExt(x) {
 81785  	} else {
 81786  		yyct2 := r.ContainerType()
 81787  		if yyct2 == codecSelferValueTypeMap100 {
 81788  			yyl2 := r.ReadMapStart()
 81789  			if yyl2 == 0 {
 81790  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 81791  			} else {
 81792  				x.codecDecodeSelfFromMap(yyl2, d)
 81793  			}
 81794  		} else if yyct2 == codecSelferValueTypeArray100 {
 81795  			yyl2 := r.ReadArrayStart()
 81796  			if yyl2 == 0 {
 81797  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81798  			} else {
 81799  				x.codecDecodeSelfFromArray(yyl2, d)
 81800  			}
 81801  		} else {
 81802  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 81803  		}
 81804  	}
 81805  }
 81806  
 81807  func (x *ACLTokenBootstrapRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 81808  	var h codecSelfer100
 81809  	z, r := codec1978.GenHelperDecoder(d)
 81810  	_, _, _ = h, z, r
 81811  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 81812  	_ = yys3Slc
 81813  	var yyhl3 bool = l >= 0
 81814  	for yyj3 := 0; ; yyj3++ {
 81815  		if yyhl3 {
 81816  			if yyj3 >= l {
 81817  				break
 81818  			}
 81819  		} else {
 81820  			if r.CheckBreak() {
 81821  				break
 81822  			}
 81823  		}
 81824  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 81825  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 81826  		yys3 := string(yys3Slc)
 81827  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 81828  		switch yys3 {
 81829  		case "Token":
 81830  			if r.TryDecodeAsNil() {
 81831  				if x.Token != nil {
 81832  					x.Token = nil
 81833  				}
 81834  			} else {
 81835  				if x.Token == nil {
 81836  					x.Token = new(ACLToken)
 81837  				}
 81838  				x.Token.CodecDecodeSelf(d)
 81839  			}
 81840  		case "ResetIndex":
 81841  			if r.TryDecodeAsNil() {
 81842  				x.ResetIndex = 0
 81843  			} else {
 81844  				yyv5 := &x.ResetIndex
 81845  				yym6 := z.DecBinary()
 81846  				_ = yym6
 81847  				if false {
 81848  				} else {
 81849  					*((*uint64)(yyv5)) = uint64(r.DecodeUint(64))
 81850  				}
 81851  			}
 81852  		case "Region":
 81853  			if r.TryDecodeAsNil() {
 81854  				x.Region = ""
 81855  			} else {
 81856  				yyv7 := &x.Region
 81857  				yym8 := z.DecBinary()
 81858  				_ = yym8
 81859  				if false {
 81860  				} else {
 81861  					*((*string)(yyv7)) = r.DecodeString()
 81862  				}
 81863  			}
 81864  		case "Namespace":
 81865  			if r.TryDecodeAsNil() {
 81866  				x.Namespace = ""
 81867  			} else {
 81868  				yyv9 := &x.Namespace
 81869  				yym10 := z.DecBinary()
 81870  				_ = yym10
 81871  				if false {
 81872  				} else {
 81873  					*((*string)(yyv9)) = r.DecodeString()
 81874  				}
 81875  			}
 81876  		case "AuthToken":
 81877  			if r.TryDecodeAsNil() {
 81878  				x.AuthToken = ""
 81879  			} else {
 81880  				yyv11 := &x.AuthToken
 81881  				yym12 := z.DecBinary()
 81882  				_ = yym12
 81883  				if false {
 81884  				} else {
 81885  					*((*string)(yyv11)) = r.DecodeString()
 81886  				}
 81887  			}
 81888  		case "Forwarded":
 81889  			if r.TryDecodeAsNil() {
 81890  				x.Forwarded = false
 81891  			} else {
 81892  				yyv13 := &x.Forwarded
 81893  				yym14 := z.DecBinary()
 81894  				_ = yym14
 81895  				if false {
 81896  				} else {
 81897  					*((*bool)(yyv13)) = r.DecodeBool()
 81898  				}
 81899  			}
 81900  		default:
 81901  			z.DecStructFieldNotFound(-1, yys3)
 81902  		} // end switch yys3
 81903  	} // end for yyj3
 81904  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 81905  }
 81906  
 81907  func (x *ACLTokenBootstrapRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 81908  	var h codecSelfer100
 81909  	z, r := codec1978.GenHelperDecoder(d)
 81910  	_, _, _ = h, z, r
 81911  	var yyj15 int
 81912  	var yyb15 bool
 81913  	var yyhl15 bool = l >= 0
 81914  	yyj15++
 81915  	if yyhl15 {
 81916  		yyb15 = yyj15 > l
 81917  	} else {
 81918  		yyb15 = r.CheckBreak()
 81919  	}
 81920  	if yyb15 {
 81921  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81922  		return
 81923  	}
 81924  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 81925  	if r.TryDecodeAsNil() {
 81926  		if x.Token != nil {
 81927  			x.Token = nil
 81928  		}
 81929  	} else {
 81930  		if x.Token == nil {
 81931  			x.Token = new(ACLToken)
 81932  		}
 81933  		x.Token.CodecDecodeSelf(d)
 81934  	}
 81935  	yyj15++
 81936  	if yyhl15 {
 81937  		yyb15 = yyj15 > l
 81938  	} else {
 81939  		yyb15 = r.CheckBreak()
 81940  	}
 81941  	if yyb15 {
 81942  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81943  		return
 81944  	}
 81945  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 81946  	if r.TryDecodeAsNil() {
 81947  		x.ResetIndex = 0
 81948  	} else {
 81949  		yyv17 := &x.ResetIndex
 81950  		yym18 := z.DecBinary()
 81951  		_ = yym18
 81952  		if false {
 81953  		} else {
 81954  			*((*uint64)(yyv17)) = uint64(r.DecodeUint(64))
 81955  		}
 81956  	}
 81957  	yyj15++
 81958  	if yyhl15 {
 81959  		yyb15 = yyj15 > l
 81960  	} else {
 81961  		yyb15 = r.CheckBreak()
 81962  	}
 81963  	if yyb15 {
 81964  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81965  		return
 81966  	}
 81967  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 81968  	if r.TryDecodeAsNil() {
 81969  		x.Region = ""
 81970  	} else {
 81971  		yyv19 := &x.Region
 81972  		yym20 := z.DecBinary()
 81973  		_ = yym20
 81974  		if false {
 81975  		} else {
 81976  			*((*string)(yyv19)) = r.DecodeString()
 81977  		}
 81978  	}
 81979  	yyj15++
 81980  	if yyhl15 {
 81981  		yyb15 = yyj15 > l
 81982  	} else {
 81983  		yyb15 = r.CheckBreak()
 81984  	}
 81985  	if yyb15 {
 81986  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 81987  		return
 81988  	}
 81989  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 81990  	if r.TryDecodeAsNil() {
 81991  		x.Namespace = ""
 81992  	} else {
 81993  		yyv21 := &x.Namespace
 81994  		yym22 := z.DecBinary()
 81995  		_ = yym22
 81996  		if false {
 81997  		} else {
 81998  			*((*string)(yyv21)) = r.DecodeString()
 81999  		}
 82000  	}
 82001  	yyj15++
 82002  	if yyhl15 {
 82003  		yyb15 = yyj15 > l
 82004  	} else {
 82005  		yyb15 = r.CheckBreak()
 82006  	}
 82007  	if yyb15 {
 82008  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 82009  		return
 82010  	}
 82011  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 82012  	if r.TryDecodeAsNil() {
 82013  		x.AuthToken = ""
 82014  	} else {
 82015  		yyv23 := &x.AuthToken
 82016  		yym24 := z.DecBinary()
 82017  		_ = yym24
 82018  		if false {
 82019  		} else {
 82020  			*((*string)(yyv23)) = r.DecodeString()
 82021  		}
 82022  	}
 82023  	yyj15++
 82024  	if yyhl15 {
 82025  		yyb15 = yyj15 > l
 82026  	} else {
 82027  		yyb15 = r.CheckBreak()
 82028  	}
 82029  	if yyb15 {
 82030  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 82031  		return
 82032  	}
 82033  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 82034  	if r.TryDecodeAsNil() {
 82035  		x.Forwarded = false
 82036  	} else {
 82037  		yyv25 := &x.Forwarded
 82038  		yym26 := z.DecBinary()
 82039  		_ = yym26
 82040  		if false {
 82041  		} else {
 82042  			*((*bool)(yyv25)) = r.DecodeBool()
 82043  		}
 82044  	}
 82045  	for {
 82046  		yyj15++
 82047  		if yyhl15 {
 82048  			yyb15 = yyj15 > l
 82049  		} else {
 82050  			yyb15 = r.CheckBreak()
 82051  		}
 82052  		if yyb15 {
 82053  			break
 82054  		}
 82055  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 82056  		z.DecStructFieldNotFound(yyj15-1, "")
 82057  	}
 82058  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 82059  }
 82060  
 82061  func (x *ACLTokenUpsertRequest) CodecEncodeSelf(e *codec1978.Encoder) {
 82062  	var h codecSelfer100
 82063  	z, r := codec1978.GenHelperEncoder(e)
 82064  	_, _, _ = h, z, r
 82065  	if x == nil {
 82066  		r.EncodeNil()
 82067  	} else {
 82068  		yym1 := z.EncBinary()
 82069  		_ = yym1
 82070  		if false {
 82071  		} else if z.HasExtensions() && z.EncExt(x) {
 82072  		} else {
 82073  			yysep2 := !z.EncBinary()
 82074  			yy2arr2 := z.EncBasicHandle().StructToArray
 82075  			var yyq2 [5]bool
 82076  			_, _, _ = yysep2, yyq2, yy2arr2
 82077  			const yyr2 bool = false
 82078  			var yynn2 int
 82079  			if yyr2 || yy2arr2 {
 82080  				r.EncodeArrayStart(5)
 82081  			} else {
 82082  				yynn2 = 5
 82083  				for _, b := range yyq2 {
 82084  					if b {
 82085  						yynn2++
 82086  					}
 82087  				}
 82088  				r.EncodeMapStart(yynn2)
 82089  				yynn2 = 0
 82090  			}
 82091  			if yyr2 || yy2arr2 {
 82092  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 82093  				if x.Tokens == nil {
 82094  					r.EncodeNil()
 82095  				} else {
 82096  					yym4 := z.EncBinary()
 82097  					_ = yym4
 82098  					if false {
 82099  					} else {
 82100  						h.encSlicePtrtoACLToken(([]*ACLToken)(x.Tokens), e)
 82101  					}
 82102  				}
 82103  			} else {
 82104  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 82105  				r.EncodeString(codecSelferC_UTF8100, string("Tokens"))
 82106  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 82107  				if x.Tokens == nil {
 82108  					r.EncodeNil()
 82109  				} else {
 82110  					yym5 := z.EncBinary()
 82111  					_ = yym5
 82112  					if false {
 82113  					} else {
 82114  						h.encSlicePtrtoACLToken(([]*ACLToken)(x.Tokens), e)
 82115  					}
 82116  				}
 82117  			}
 82118  			if yyr2 || yy2arr2 {
 82119  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 82120  				yym7 := z.EncBinary()
 82121  				_ = yym7
 82122  				if false {
 82123  				} else {
 82124  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 82125  				}
 82126  			} else {
 82127  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 82128  				r.EncodeString(codecSelferC_UTF8100, string("Region"))
 82129  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 82130  				yym8 := z.EncBinary()
 82131  				_ = yym8
 82132  				if false {
 82133  				} else {
 82134  					r.EncodeString(codecSelferC_UTF8100, string(x.Region))
 82135  				}
 82136  			}
 82137  			if yyr2 || yy2arr2 {
 82138  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 82139  				yym10 := z.EncBinary()
 82140  				_ = yym10
 82141  				if false {
 82142  				} else {
 82143  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 82144  				}
 82145  			} else {
 82146  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 82147  				r.EncodeString(codecSelferC_UTF8100, string("Namespace"))
 82148  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 82149  				yym11 := z.EncBinary()
 82150  				_ = yym11
 82151  				if false {
 82152  				} else {
 82153  					r.EncodeString(codecSelferC_UTF8100, string(x.Namespace))
 82154  				}
 82155  			}
 82156  			if yyr2 || yy2arr2 {
 82157  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 82158  				yym13 := z.EncBinary()
 82159  				_ = yym13
 82160  				if false {
 82161  				} else {
 82162  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 82163  				}
 82164  			} else {
 82165  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 82166  				r.EncodeString(codecSelferC_UTF8100, string("AuthToken"))
 82167  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 82168  				yym14 := z.EncBinary()
 82169  				_ = yym14
 82170  				if false {
 82171  				} else {
 82172  					r.EncodeString(codecSelferC_UTF8100, string(x.AuthToken))
 82173  				}
 82174  			}
 82175  			if yyr2 || yy2arr2 {
 82176  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 82177  				yym16 := z.EncBinary()
 82178  				_ = yym16
 82179  				if false {
 82180  				} else {
 82181  					r.EncodeBool(bool(x.Forwarded))
 82182  				}
 82183  			} else {
 82184  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 82185  				r.EncodeString(codecSelferC_UTF8100, string("Forwarded"))
 82186  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 82187  				yym17 := z.EncBinary()
 82188  				_ = yym17
 82189  				if false {
 82190  				} else {
 82191  					r.EncodeBool(bool(x.Forwarded))
 82192  				}
 82193  			}
 82194  			if yyr2 || yy2arr2 {
 82195  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 82196  			} else {
 82197  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 82198  			}
 82199  		}
 82200  	}
 82201  }
 82202  
 82203  func (x *ACLTokenUpsertRequest) CodecDecodeSelf(d *codec1978.Decoder) {
 82204  	var h codecSelfer100
 82205  	z, r := codec1978.GenHelperDecoder(d)
 82206  	_, _, _ = h, z, r
 82207  	yym1 := z.DecBinary()
 82208  	_ = yym1
 82209  	if false {
 82210  	} else if z.HasExtensions() && z.DecExt(x) {
 82211  	} else {
 82212  		yyct2 := r.ContainerType()
 82213  		if yyct2 == codecSelferValueTypeMap100 {
 82214  			yyl2 := r.ReadMapStart()
 82215  			if yyl2 == 0 {
 82216  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 82217  			} else {
 82218  				x.codecDecodeSelfFromMap(yyl2, d)
 82219  			}
 82220  		} else if yyct2 == codecSelferValueTypeArray100 {
 82221  			yyl2 := r.ReadArrayStart()
 82222  			if yyl2 == 0 {
 82223  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 82224  			} else {
 82225  				x.codecDecodeSelfFromArray(yyl2, d)
 82226  			}
 82227  		} else {
 82228  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 82229  		}
 82230  	}
 82231  }
 82232  
 82233  func (x *ACLTokenUpsertRequest) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 82234  	var h codecSelfer100
 82235  	z, r := codec1978.GenHelperDecoder(d)
 82236  	_, _, _ = h, z, r
 82237  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 82238  	_ = yys3Slc
 82239  	var yyhl3 bool = l >= 0
 82240  	for yyj3 := 0; ; yyj3++ {
 82241  		if yyhl3 {
 82242  			if yyj3 >= l {
 82243  				break
 82244  			}
 82245  		} else {
 82246  			if r.CheckBreak() {
 82247  				break
 82248  			}
 82249  		}
 82250  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 82251  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 82252  		yys3 := string(yys3Slc)
 82253  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 82254  		switch yys3 {
 82255  		case "Tokens":
 82256  			if r.TryDecodeAsNil() {
 82257  				x.Tokens = nil
 82258  			} else {
 82259  				yyv4 := &x.Tokens
 82260  				yym5 := z.DecBinary()
 82261  				_ = yym5
 82262  				if false {
 82263  				} else {
 82264  					h.decSlicePtrtoACLToken((*[]*ACLToken)(yyv4), d)
 82265  				}
 82266  			}
 82267  		case "Region":
 82268  			if r.TryDecodeAsNil() {
 82269  				x.Region = ""
 82270  			} else {
 82271  				yyv6 := &x.Region
 82272  				yym7 := z.DecBinary()
 82273  				_ = yym7
 82274  				if false {
 82275  				} else {
 82276  					*((*string)(yyv6)) = r.DecodeString()
 82277  				}
 82278  			}
 82279  		case "Namespace":
 82280  			if r.TryDecodeAsNil() {
 82281  				x.Namespace = ""
 82282  			} else {
 82283  				yyv8 := &x.Namespace
 82284  				yym9 := z.DecBinary()
 82285  				_ = yym9
 82286  				if false {
 82287  				} else {
 82288  					*((*string)(yyv8)) = r.DecodeString()
 82289  				}
 82290  			}
 82291  		case "AuthToken":
 82292  			if r.TryDecodeAsNil() {
 82293  				x.AuthToken = ""
 82294  			} else {
 82295  				yyv10 := &x.AuthToken
 82296  				yym11 := z.DecBinary()
 82297  				_ = yym11
 82298  				if false {
 82299  				} else {
 82300  					*((*string)(yyv10)) = r.DecodeString()
 82301  				}
 82302  			}
 82303  		case "Forwarded":
 82304  			if r.TryDecodeAsNil() {
 82305  				x.Forwarded = false
 82306  			} else {
 82307  				yyv12 := &x.Forwarded
 82308  				yym13 := z.DecBinary()
 82309  				_ = yym13
 82310  				if false {
 82311  				} else {
 82312  					*((*bool)(yyv12)) = r.DecodeBool()
 82313  				}
 82314  			}
 82315  		default:
 82316  			z.DecStructFieldNotFound(-1, yys3)
 82317  		} // end switch yys3
 82318  	} // end for yyj3
 82319  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 82320  }
 82321  
 82322  func (x *ACLTokenUpsertRequest) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 82323  	var h codecSelfer100
 82324  	z, r := codec1978.GenHelperDecoder(d)
 82325  	_, _, _ = h, z, r
 82326  	var yyj14 int
 82327  	var yyb14 bool
 82328  	var yyhl14 bool = l >= 0
 82329  	yyj14++
 82330  	if yyhl14 {
 82331  		yyb14 = yyj14 > l
 82332  	} else {
 82333  		yyb14 = r.CheckBreak()
 82334  	}
 82335  	if yyb14 {
 82336  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 82337  		return
 82338  	}
 82339  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 82340  	if r.TryDecodeAsNil() {
 82341  		x.Tokens = nil
 82342  	} else {
 82343  		yyv15 := &x.Tokens
 82344  		yym16 := z.DecBinary()
 82345  		_ = yym16
 82346  		if false {
 82347  		} else {
 82348  			h.decSlicePtrtoACLToken((*[]*ACLToken)(yyv15), d)
 82349  		}
 82350  	}
 82351  	yyj14++
 82352  	if yyhl14 {
 82353  		yyb14 = yyj14 > l
 82354  	} else {
 82355  		yyb14 = r.CheckBreak()
 82356  	}
 82357  	if yyb14 {
 82358  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 82359  		return
 82360  	}
 82361  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 82362  	if r.TryDecodeAsNil() {
 82363  		x.Region = ""
 82364  	} else {
 82365  		yyv17 := &x.Region
 82366  		yym18 := z.DecBinary()
 82367  		_ = yym18
 82368  		if false {
 82369  		} else {
 82370  			*((*string)(yyv17)) = r.DecodeString()
 82371  		}
 82372  	}
 82373  	yyj14++
 82374  	if yyhl14 {
 82375  		yyb14 = yyj14 > l
 82376  	} else {
 82377  		yyb14 = r.CheckBreak()
 82378  	}
 82379  	if yyb14 {
 82380  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 82381  		return
 82382  	}
 82383  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 82384  	if r.TryDecodeAsNil() {
 82385  		x.Namespace = ""
 82386  	} else {
 82387  		yyv19 := &x.Namespace
 82388  		yym20 := z.DecBinary()
 82389  		_ = yym20
 82390  		if false {
 82391  		} else {
 82392  			*((*string)(yyv19)) = r.DecodeString()
 82393  		}
 82394  	}
 82395  	yyj14++
 82396  	if yyhl14 {
 82397  		yyb14 = yyj14 > l
 82398  	} else {
 82399  		yyb14 = r.CheckBreak()
 82400  	}
 82401  	if yyb14 {
 82402  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 82403  		return
 82404  	}
 82405  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 82406  	if r.TryDecodeAsNil() {
 82407  		x.AuthToken = ""
 82408  	} else {
 82409  		yyv21 := &x.AuthToken
 82410  		yym22 := z.DecBinary()
 82411  		_ = yym22
 82412  		if false {
 82413  		} else {
 82414  			*((*string)(yyv21)) = r.DecodeString()
 82415  		}
 82416  	}
 82417  	yyj14++
 82418  	if yyhl14 {
 82419  		yyb14 = yyj14 > l
 82420  	} else {
 82421  		yyb14 = r.CheckBreak()
 82422  	}
 82423  	if yyb14 {
 82424  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 82425  		return
 82426  	}
 82427  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 82428  	if r.TryDecodeAsNil() {
 82429  		x.Forwarded = false
 82430  	} else {
 82431  		yyv23 := &x.Forwarded
 82432  		yym24 := z.DecBinary()
 82433  		_ = yym24
 82434  		if false {
 82435  		} else {
 82436  			*((*bool)(yyv23)) = r.DecodeBool()
 82437  		}
 82438  	}
 82439  	for {
 82440  		yyj14++
 82441  		if yyhl14 {
 82442  			yyb14 = yyj14 > l
 82443  		} else {
 82444  			yyb14 = r.CheckBreak()
 82445  		}
 82446  		if yyb14 {
 82447  			break
 82448  		}
 82449  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 82450  		z.DecStructFieldNotFound(yyj14-1, "")
 82451  	}
 82452  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 82453  }
 82454  
 82455  func (x *ACLTokenUpsertResponse) CodecEncodeSelf(e *codec1978.Encoder) {
 82456  	var h codecSelfer100
 82457  	z, r := codec1978.GenHelperEncoder(e)
 82458  	_, _, _ = h, z, r
 82459  	if x == nil {
 82460  		r.EncodeNil()
 82461  	} else {
 82462  		yym1 := z.EncBinary()
 82463  		_ = yym1
 82464  		if false {
 82465  		} else if z.HasExtensions() && z.EncExt(x) {
 82466  		} else {
 82467  			yysep2 := !z.EncBinary()
 82468  			yy2arr2 := z.EncBasicHandle().StructToArray
 82469  			var yyq2 [2]bool
 82470  			_, _, _ = yysep2, yyq2, yy2arr2
 82471  			const yyr2 bool = false
 82472  			var yynn2 int
 82473  			if yyr2 || yy2arr2 {
 82474  				r.EncodeArrayStart(2)
 82475  			} else {
 82476  				yynn2 = 2
 82477  				for _, b := range yyq2 {
 82478  					if b {
 82479  						yynn2++
 82480  					}
 82481  				}
 82482  				r.EncodeMapStart(yynn2)
 82483  				yynn2 = 0
 82484  			}
 82485  			if yyr2 || yy2arr2 {
 82486  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 82487  				if x.Tokens == nil {
 82488  					r.EncodeNil()
 82489  				} else {
 82490  					yym4 := z.EncBinary()
 82491  					_ = yym4
 82492  					if false {
 82493  					} else {
 82494  						h.encSlicePtrtoACLToken(([]*ACLToken)(x.Tokens), e)
 82495  					}
 82496  				}
 82497  			} else {
 82498  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 82499  				r.EncodeString(codecSelferC_UTF8100, string("Tokens"))
 82500  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 82501  				if x.Tokens == nil {
 82502  					r.EncodeNil()
 82503  				} else {
 82504  					yym5 := z.EncBinary()
 82505  					_ = yym5
 82506  					if false {
 82507  					} else {
 82508  						h.encSlicePtrtoACLToken(([]*ACLToken)(x.Tokens), e)
 82509  					}
 82510  				}
 82511  			}
 82512  			if yyr2 || yy2arr2 {
 82513  				z.EncSendContainerState(codecSelfer_containerArrayElem100)
 82514  				yym7 := z.EncBinary()
 82515  				_ = yym7
 82516  				if false {
 82517  				} else {
 82518  					r.EncodeUint(uint64(x.Index))
 82519  				}
 82520  			} else {
 82521  				z.EncSendContainerState(codecSelfer_containerMapKey100)
 82522  				r.EncodeString(codecSelferC_UTF8100, string("Index"))
 82523  				z.EncSendContainerState(codecSelfer_containerMapValue100)
 82524  				yym8 := z.EncBinary()
 82525  				_ = yym8
 82526  				if false {
 82527  				} else {
 82528  					r.EncodeUint(uint64(x.Index))
 82529  				}
 82530  			}
 82531  			if yyr2 || yy2arr2 {
 82532  				z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 82533  			} else {
 82534  				z.EncSendContainerState(codecSelfer_containerMapEnd100)
 82535  			}
 82536  		}
 82537  	}
 82538  }
 82539  
 82540  func (x *ACLTokenUpsertResponse) CodecDecodeSelf(d *codec1978.Decoder) {
 82541  	var h codecSelfer100
 82542  	z, r := codec1978.GenHelperDecoder(d)
 82543  	_, _, _ = h, z, r
 82544  	yym1 := z.DecBinary()
 82545  	_ = yym1
 82546  	if false {
 82547  	} else if z.HasExtensions() && z.DecExt(x) {
 82548  	} else {
 82549  		yyct2 := r.ContainerType()
 82550  		if yyct2 == codecSelferValueTypeMap100 {
 82551  			yyl2 := r.ReadMapStart()
 82552  			if yyl2 == 0 {
 82553  				z.DecSendContainerState(codecSelfer_containerMapEnd100)
 82554  			} else {
 82555  				x.codecDecodeSelfFromMap(yyl2, d)
 82556  			}
 82557  		} else if yyct2 == codecSelferValueTypeArray100 {
 82558  			yyl2 := r.ReadArrayStart()
 82559  			if yyl2 == 0 {
 82560  				z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 82561  			} else {
 82562  				x.codecDecodeSelfFromArray(yyl2, d)
 82563  			}
 82564  		} else {
 82565  			panic(codecSelferOnlyMapOrArrayEncodeToStructErr100)
 82566  		}
 82567  	}
 82568  }
 82569  
 82570  func (x *ACLTokenUpsertResponse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
 82571  	var h codecSelfer100
 82572  	z, r := codec1978.GenHelperDecoder(d)
 82573  	_, _, _ = h, z, r
 82574  	var yys3Slc = z.DecScratchBuffer() // default slice to decode into
 82575  	_ = yys3Slc
 82576  	var yyhl3 bool = l >= 0
 82577  	for yyj3 := 0; ; yyj3++ {
 82578  		if yyhl3 {
 82579  			if yyj3 >= l {
 82580  				break
 82581  			}
 82582  		} else {
 82583  			if r.CheckBreak() {
 82584  				break
 82585  			}
 82586  		}
 82587  		z.DecSendContainerState(codecSelfer_containerMapKey100)
 82588  		yys3Slc = r.DecodeBytes(yys3Slc, true, true)
 82589  		yys3 := string(yys3Slc)
 82590  		z.DecSendContainerState(codecSelfer_containerMapValue100)
 82591  		switch yys3 {
 82592  		case "Tokens":
 82593  			if r.TryDecodeAsNil() {
 82594  				x.Tokens = nil
 82595  			} else {
 82596  				yyv4 := &x.Tokens
 82597  				yym5 := z.DecBinary()
 82598  				_ = yym5
 82599  				if false {
 82600  				} else {
 82601  					h.decSlicePtrtoACLToken((*[]*ACLToken)(yyv4), d)
 82602  				}
 82603  			}
 82604  		case "Index":
 82605  			if r.TryDecodeAsNil() {
 82606  				x.Index = 0
 82607  			} else {
 82608  				yyv6 := &x.Index
 82609  				yym7 := z.DecBinary()
 82610  				_ = yym7
 82611  				if false {
 82612  				} else {
 82613  					*((*uint64)(yyv6)) = uint64(r.DecodeUint(64))
 82614  				}
 82615  			}
 82616  		default:
 82617  			z.DecStructFieldNotFound(-1, yys3)
 82618  		} // end switch yys3
 82619  	} // end for yyj3
 82620  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 82621  }
 82622  
 82623  func (x *ACLTokenUpsertResponse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
 82624  	var h codecSelfer100
 82625  	z, r := codec1978.GenHelperDecoder(d)
 82626  	_, _, _ = h, z, r
 82627  	var yyj8 int
 82628  	var yyb8 bool
 82629  	var yyhl8 bool = l >= 0
 82630  	yyj8++
 82631  	if yyhl8 {
 82632  		yyb8 = yyj8 > l
 82633  	} else {
 82634  		yyb8 = r.CheckBreak()
 82635  	}
 82636  	if yyb8 {
 82637  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 82638  		return
 82639  	}
 82640  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 82641  	if r.TryDecodeAsNil() {
 82642  		x.Tokens = nil
 82643  	} else {
 82644  		yyv9 := &x.Tokens
 82645  		yym10 := z.DecBinary()
 82646  		_ = yym10
 82647  		if false {
 82648  		} else {
 82649  			h.decSlicePtrtoACLToken((*[]*ACLToken)(yyv9), d)
 82650  		}
 82651  	}
 82652  	yyj8++
 82653  	if yyhl8 {
 82654  		yyb8 = yyj8 > l
 82655  	} else {
 82656  		yyb8 = r.CheckBreak()
 82657  	}
 82658  	if yyb8 {
 82659  		z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 82660  		return
 82661  	}
 82662  	z.DecSendContainerState(codecSelfer_containerArrayElem100)
 82663  	if r.TryDecodeAsNil() {
 82664  		x.Index = 0
 82665  	} else {
 82666  		yyv11 := &x.Index
 82667  		yym12 := z.DecBinary()
 82668  		_ = yym12
 82669  		if false {
 82670  		} else {
 82671  			*((*uint64)(yyv11)) = uint64(r.DecodeUint(64))
 82672  		}
 82673  	}
 82674  	for {
 82675  		yyj8++
 82676  		if yyhl8 {
 82677  			yyb8 = yyj8 > l
 82678  		} else {
 82679  			yyb8 = r.CheckBreak()
 82680  		}
 82681  		if yyb8 {
 82682  			break
 82683  		}
 82684  		z.DecSendContainerState(codecSelfer_containerArrayElem100)
 82685  		z.DecStructFieldNotFound(yyj8-1, "")
 82686  	}
 82687  	z.DecSendContainerState(codecSelfer_containerArrayEnd100)
 82688  }
 82689  
 82690  func (x codecSelfer100) encMapstringPtrtoDrainUpdate(v map[string]*DrainUpdate, e *codec1978.Encoder) {
 82691  	var h codecSelfer100
 82692  	z, r := codec1978.GenHelperEncoder(e)
 82693  	_, _, _ = h, z, r
 82694  	r.EncodeMapStart(len(v))
 82695  	for yyk1, yyv1 := range v {
 82696  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 82697  		yym2 := z.EncBinary()
 82698  		_ = yym2
 82699  		if false {
 82700  		} else {
 82701  			r.EncodeString(codecSelferC_UTF8100, string(yyk1))
 82702  		}
 82703  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 82704  		if yyv1 == nil {
 82705  			r.EncodeNil()
 82706  		} else {
 82707  			yyv1.CodecEncodeSelf(e)
 82708  		}
 82709  	}
 82710  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 82711  }
 82712  
 82713  func (x codecSelfer100) decMapstringPtrtoDrainUpdate(v *map[string]*DrainUpdate, d *codec1978.Decoder) {
 82714  	var h codecSelfer100
 82715  	z, r := codec1978.GenHelperDecoder(d)
 82716  	_, _, _ = h, z, r
 82717  
 82718  	yyv1 := *v
 82719  	yyl1 := r.ReadMapStart()
 82720  	yybh1 := z.DecBasicHandle()
 82721  	if yyv1 == nil {
 82722  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 24)
 82723  		yyv1 = make(map[string]*DrainUpdate, yyrl1)
 82724  		*v = yyv1
 82725  	}
 82726  	var yymk1 string
 82727  	var yymv1 *DrainUpdate
 82728  	var yymg1, yyms1, yymok1 bool
 82729  	if yybh1.MapValueReset {
 82730  		yymg1 = true
 82731  	}
 82732  	if yyl1 > 0 {
 82733  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 82734  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 82735  			if r.TryDecodeAsNil() {
 82736  				yymk1 = ""
 82737  			} else {
 82738  				yyv2 := &yymk1
 82739  				yym3 := z.DecBinary()
 82740  				_ = yym3
 82741  				if false {
 82742  				} else {
 82743  					*((*string)(yyv2)) = r.DecodeString()
 82744  				}
 82745  			}
 82746  
 82747  			yyms1 = true
 82748  			if yymg1 {
 82749  				yymv1, yymok1 = yyv1[yymk1]
 82750  				if yymok1 {
 82751  					yyms1 = false
 82752  				}
 82753  			} else {
 82754  				yymv1 = nil
 82755  			}
 82756  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 82757  			if r.TryDecodeAsNil() {
 82758  				if yymv1 != nil {
 82759  					*yymv1 = DrainUpdate{}
 82760  				}
 82761  			} else {
 82762  				if yymv1 == nil {
 82763  					yymv1 = new(DrainUpdate)
 82764  				}
 82765  				yymv1.CodecDecodeSelf(d)
 82766  			}
 82767  
 82768  			if yyms1 && yyv1 != nil {
 82769  				yyv1[yymk1] = yymv1
 82770  			}
 82771  		}
 82772  	} else if yyl1 < 0 {
 82773  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 82774  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 82775  			if r.TryDecodeAsNil() {
 82776  				yymk1 = ""
 82777  			} else {
 82778  				yyv5 := &yymk1
 82779  				yym6 := z.DecBinary()
 82780  				_ = yym6
 82781  				if false {
 82782  				} else {
 82783  					*((*string)(yyv5)) = r.DecodeString()
 82784  				}
 82785  			}
 82786  
 82787  			yyms1 = true
 82788  			if yymg1 {
 82789  				yymv1, yymok1 = yyv1[yymk1]
 82790  				if yymok1 {
 82791  					yyms1 = false
 82792  				}
 82793  			} else {
 82794  				yymv1 = nil
 82795  			}
 82796  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 82797  			if r.TryDecodeAsNil() {
 82798  				if yymv1 != nil {
 82799  					*yymv1 = DrainUpdate{}
 82800  				}
 82801  			} else {
 82802  				if yymv1 == nil {
 82803  					yymv1 = new(DrainUpdate)
 82804  				}
 82805  				yymv1.CodecDecodeSelf(d)
 82806  			}
 82807  
 82808  			if yyms1 && yyv1 != nil {
 82809  				yyv1[yymk1] = yymv1
 82810  			}
 82811  		}
 82812  	} // else len==0: TODO: Should we clear map entries?
 82813  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 82814  }
 82815  
 82816  func (x codecSelfer100) encMapContextSlicestring(v map[Context][]string, e *codec1978.Encoder) {
 82817  	var h codecSelfer100
 82818  	z, r := codec1978.GenHelperEncoder(e)
 82819  	_, _, _ = h, z, r
 82820  	r.EncodeMapStart(len(v))
 82821  	for yyk1, yyv1 := range v {
 82822  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 82823  		yyk1.CodecEncodeSelf(e)
 82824  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 82825  		if yyv1 == nil {
 82826  			r.EncodeNil()
 82827  		} else {
 82828  			yym3 := z.EncBinary()
 82829  			_ = yym3
 82830  			if false {
 82831  			} else {
 82832  				z.F.EncSliceStringV(yyv1, false, e)
 82833  			}
 82834  		}
 82835  	}
 82836  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 82837  }
 82838  
 82839  func (x codecSelfer100) decMapContextSlicestring(v *map[Context][]string, d *codec1978.Decoder) {
 82840  	var h codecSelfer100
 82841  	z, r := codec1978.GenHelperDecoder(d)
 82842  	_, _, _ = h, z, r
 82843  
 82844  	yyv1 := *v
 82845  	yyl1 := r.ReadMapStart()
 82846  	yybh1 := z.DecBasicHandle()
 82847  	if yyv1 == nil {
 82848  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 40)
 82849  		yyv1 = make(map[Context][]string, yyrl1)
 82850  		*v = yyv1
 82851  	}
 82852  	var yymk1 Context
 82853  	var yymv1 []string
 82854  	var yymg1 bool
 82855  	if yybh1.MapValueReset {
 82856  		yymg1 = true
 82857  	}
 82858  	if yyl1 > 0 {
 82859  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 82860  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 82861  			if r.TryDecodeAsNil() {
 82862  				yymk1 = ""
 82863  			} else {
 82864  				yyv2 := &yymk1
 82865  				yyv2.CodecDecodeSelf(d)
 82866  			}
 82867  
 82868  			if yymg1 {
 82869  				yymv1 = yyv1[yymk1]
 82870  			} else {
 82871  				yymv1 = nil
 82872  			}
 82873  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 82874  			if r.TryDecodeAsNil() {
 82875  				yymv1 = nil
 82876  			} else {
 82877  				yyv3 := &yymv1
 82878  				yym4 := z.DecBinary()
 82879  				_ = yym4
 82880  				if false {
 82881  				} else {
 82882  					z.F.DecSliceStringX(yyv3, false, d)
 82883  				}
 82884  			}
 82885  
 82886  			if yyv1 != nil {
 82887  				yyv1[yymk1] = yymv1
 82888  			}
 82889  		}
 82890  	} else if yyl1 < 0 {
 82891  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 82892  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 82893  			if r.TryDecodeAsNil() {
 82894  				yymk1 = ""
 82895  			} else {
 82896  				yyv5 := &yymk1
 82897  				yyv5.CodecDecodeSelf(d)
 82898  			}
 82899  
 82900  			if yymg1 {
 82901  				yymv1 = yyv1[yymk1]
 82902  			} else {
 82903  				yymv1 = nil
 82904  			}
 82905  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 82906  			if r.TryDecodeAsNil() {
 82907  				yymv1 = nil
 82908  			} else {
 82909  				yyv6 := &yymv1
 82910  				yym7 := z.DecBinary()
 82911  				_ = yym7
 82912  				if false {
 82913  				} else {
 82914  					z.F.DecSliceStringX(yyv6, false, d)
 82915  				}
 82916  			}
 82917  
 82918  			if yyv1 != nil {
 82919  				yyv1[yymk1] = yymv1
 82920  			}
 82921  		}
 82922  	} // else len==0: TODO: Should we clear map entries?
 82923  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 82924  }
 82925  
 82926  func (x codecSelfer100) encSlicestring(v []string, e *codec1978.Encoder) {
 82927  	var h codecSelfer100
 82928  	z, r := codec1978.GenHelperEncoder(e)
 82929  	_, _, _ = h, z, r
 82930  	r.EncodeArrayStart(len(v))
 82931  	for _, yyv1 := range v {
 82932  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 82933  		yym2 := z.EncBinary()
 82934  		_ = yym2
 82935  		if false {
 82936  		} else {
 82937  			r.EncodeString(codecSelferC_UTF8100, string(yyv1))
 82938  		}
 82939  	}
 82940  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 82941  }
 82942  
 82943  func (x codecSelfer100) decSlicestring(v *[]string, d *codec1978.Decoder) {
 82944  	var h codecSelfer100
 82945  	z, r := codec1978.GenHelperDecoder(d)
 82946  	_, _, _ = h, z, r
 82947  
 82948  	yyv1 := *v
 82949  	yyh1, yyl1 := z.DecSliceHelperStart()
 82950  	var yyc1 bool
 82951  	_ = yyc1
 82952  	if yyl1 == 0 {
 82953  		if yyv1 == nil {
 82954  			yyv1 = []string{}
 82955  			yyc1 = true
 82956  		} else if len(yyv1) != 0 {
 82957  			yyv1 = yyv1[:0]
 82958  			yyc1 = true
 82959  		}
 82960  	} else if yyl1 > 0 {
 82961  		var yyrr1, yyrl1 int
 82962  		var yyrt1 bool
 82963  		_, _ = yyrl1, yyrt1
 82964  		yyrr1 = yyl1 // len(yyv1)
 82965  		if yyl1 > cap(yyv1) {
 82966  
 82967  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 16)
 82968  			if yyrt1 {
 82969  				if yyrl1 <= cap(yyv1) {
 82970  					yyv1 = yyv1[:yyrl1]
 82971  				} else {
 82972  					yyv1 = make([]string, yyrl1)
 82973  				}
 82974  			} else {
 82975  				yyv1 = make([]string, yyrl1)
 82976  			}
 82977  			yyc1 = true
 82978  			yyrr1 = len(yyv1)
 82979  		} else if yyl1 != len(yyv1) {
 82980  			yyv1 = yyv1[:yyl1]
 82981  			yyc1 = true
 82982  		}
 82983  		yyj1 := 0
 82984  		for ; yyj1 < yyrr1; yyj1++ {
 82985  			yyh1.ElemContainerState(yyj1)
 82986  			if r.TryDecodeAsNil() {
 82987  				yyv1[yyj1] = ""
 82988  			} else {
 82989  				yyv2 := &yyv1[yyj1]
 82990  				yym3 := z.DecBinary()
 82991  				_ = yym3
 82992  				if false {
 82993  				} else {
 82994  					*((*string)(yyv2)) = r.DecodeString()
 82995  				}
 82996  			}
 82997  
 82998  		}
 82999  		if yyrt1 {
 83000  			for ; yyj1 < yyl1; yyj1++ {
 83001  				yyv1 = append(yyv1, "")
 83002  				yyh1.ElemContainerState(yyj1)
 83003  				if r.TryDecodeAsNil() {
 83004  					yyv1[yyj1] = ""
 83005  				} else {
 83006  					yyv4 := &yyv1[yyj1]
 83007  					yym5 := z.DecBinary()
 83008  					_ = yym5
 83009  					if false {
 83010  					} else {
 83011  						*((*string)(yyv4)) = r.DecodeString()
 83012  					}
 83013  				}
 83014  
 83015  			}
 83016  		}
 83017  
 83018  	} else {
 83019  		yyj1 := 0
 83020  		for ; !r.CheckBreak(); yyj1++ {
 83021  
 83022  			if yyj1 >= len(yyv1) {
 83023  				yyv1 = append(yyv1, "") // var yyz1 string
 83024  				yyc1 = true
 83025  			}
 83026  			yyh1.ElemContainerState(yyj1)
 83027  			if yyj1 < len(yyv1) {
 83028  				if r.TryDecodeAsNil() {
 83029  					yyv1[yyj1] = ""
 83030  				} else {
 83031  					yyv6 := &yyv1[yyj1]
 83032  					yym7 := z.DecBinary()
 83033  					_ = yym7
 83034  					if false {
 83035  					} else {
 83036  						*((*string)(yyv6)) = r.DecodeString()
 83037  					}
 83038  				}
 83039  
 83040  			} else {
 83041  				z.DecSwallow()
 83042  			}
 83043  
 83044  		}
 83045  		if yyj1 < len(yyv1) {
 83046  			yyv1 = yyv1[:yyj1]
 83047  			yyc1 = true
 83048  		} else if yyj1 == 0 && yyv1 == nil {
 83049  			yyv1 = []string{}
 83050  			yyc1 = true
 83051  		}
 83052  	}
 83053  	yyh1.End()
 83054  	if yyc1 {
 83055  		*v = yyv1
 83056  	}
 83057  }
 83058  
 83059  func (x codecSelfer100) encMapContextbool(v map[Context]bool, e *codec1978.Encoder) {
 83060  	var h codecSelfer100
 83061  	z, r := codec1978.GenHelperEncoder(e)
 83062  	_, _, _ = h, z, r
 83063  	r.EncodeMapStart(len(v))
 83064  	for yyk1, yyv1 := range v {
 83065  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 83066  		yyk1.CodecEncodeSelf(e)
 83067  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 83068  		yym3 := z.EncBinary()
 83069  		_ = yym3
 83070  		if false {
 83071  		} else {
 83072  			r.EncodeBool(bool(yyv1))
 83073  		}
 83074  	}
 83075  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 83076  }
 83077  
 83078  func (x codecSelfer100) decMapContextbool(v *map[Context]bool, d *codec1978.Decoder) {
 83079  	var h codecSelfer100
 83080  	z, r := codec1978.GenHelperDecoder(d)
 83081  	_, _, _ = h, z, r
 83082  
 83083  	yyv1 := *v
 83084  	yyl1 := r.ReadMapStart()
 83085  	yybh1 := z.DecBasicHandle()
 83086  	if yyv1 == nil {
 83087  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 17)
 83088  		yyv1 = make(map[Context]bool, yyrl1)
 83089  		*v = yyv1
 83090  	}
 83091  	var yymk1 Context
 83092  	var yymv1 bool
 83093  	var yymg1 bool
 83094  	if yybh1.MapValueReset {
 83095  	}
 83096  	if yyl1 > 0 {
 83097  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 83098  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 83099  			if r.TryDecodeAsNil() {
 83100  				yymk1 = ""
 83101  			} else {
 83102  				yyv2 := &yymk1
 83103  				yyv2.CodecDecodeSelf(d)
 83104  			}
 83105  
 83106  			if yymg1 {
 83107  				yymv1 = yyv1[yymk1]
 83108  			}
 83109  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 83110  			if r.TryDecodeAsNil() {
 83111  				yymv1 = false
 83112  			} else {
 83113  				yyv3 := &yymv1
 83114  				yym4 := z.DecBinary()
 83115  				_ = yym4
 83116  				if false {
 83117  				} else {
 83118  					*((*bool)(yyv3)) = r.DecodeBool()
 83119  				}
 83120  			}
 83121  
 83122  			if yyv1 != nil {
 83123  				yyv1[yymk1] = yymv1
 83124  			}
 83125  		}
 83126  	} else if yyl1 < 0 {
 83127  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 83128  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 83129  			if r.TryDecodeAsNil() {
 83130  				yymk1 = ""
 83131  			} else {
 83132  				yyv5 := &yymk1
 83133  				yyv5.CodecDecodeSelf(d)
 83134  			}
 83135  
 83136  			if yymg1 {
 83137  				yymv1 = yyv1[yymk1]
 83138  			}
 83139  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 83140  			if r.TryDecodeAsNil() {
 83141  				yymv1 = false
 83142  			} else {
 83143  				yyv6 := &yymv1
 83144  				yym7 := z.DecBinary()
 83145  				_ = yym7
 83146  				if false {
 83147  				} else {
 83148  					*((*bool)(yyv6)) = r.DecodeBool()
 83149  				}
 83150  			}
 83151  
 83152  			if yyv1 != nil {
 83153  				yyv1[yymk1] = yymv1
 83154  			}
 83155  		}
 83156  	} // else len==0: TODO: Should we clear map entries?
 83157  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 83158  }
 83159  
 83160  func (x codecSelfer100) encMapNamespacedIDPtrtoJobDeregisterOptions(v map[NamespacedID]*JobDeregisterOptions, e *codec1978.Encoder) {
 83161  	var h codecSelfer100
 83162  	z, r := codec1978.GenHelperEncoder(e)
 83163  	_, _, _ = h, z, r
 83164  	r.EncodeMapStart(len(v))
 83165  	for yyk1, yyv1 := range v {
 83166  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 83167  		yy2 := &yyk1
 83168  		yy2.CodecEncodeSelf(e)
 83169  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 83170  		if yyv1 == nil {
 83171  			r.EncodeNil()
 83172  		} else {
 83173  			yyv1.CodecEncodeSelf(e)
 83174  		}
 83175  	}
 83176  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 83177  }
 83178  
 83179  func (x codecSelfer100) decMapNamespacedIDPtrtoJobDeregisterOptions(v *map[NamespacedID]*JobDeregisterOptions, d *codec1978.Decoder) {
 83180  	var h codecSelfer100
 83181  	z, r := codec1978.GenHelperDecoder(d)
 83182  	_, _, _ = h, z, r
 83183  
 83184  	yyv1 := *v
 83185  	yyl1 := r.ReadMapStart()
 83186  	yybh1 := z.DecBasicHandle()
 83187  	if yyv1 == nil {
 83188  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 40)
 83189  		yyv1 = make(map[NamespacedID]*JobDeregisterOptions, yyrl1)
 83190  		*v = yyv1
 83191  	}
 83192  	var yymk1 NamespacedID
 83193  	var yymv1 *JobDeregisterOptions
 83194  	var yymg1, yyms1, yymok1 bool
 83195  	if yybh1.MapValueReset {
 83196  		yymg1 = true
 83197  	}
 83198  	if yyl1 > 0 {
 83199  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 83200  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 83201  			if r.TryDecodeAsNil() {
 83202  				yymk1 = NamespacedID{}
 83203  			} else {
 83204  				yyv2 := &yymk1
 83205  				yyv2.CodecDecodeSelf(d)
 83206  			}
 83207  
 83208  			yyms1 = true
 83209  			if yymg1 {
 83210  				yymv1, yymok1 = yyv1[yymk1]
 83211  				if yymok1 {
 83212  					yyms1 = false
 83213  				}
 83214  			} else {
 83215  				yymv1 = nil
 83216  			}
 83217  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 83218  			if r.TryDecodeAsNil() {
 83219  				if yymv1 != nil {
 83220  					*yymv1 = JobDeregisterOptions{}
 83221  				}
 83222  			} else {
 83223  				if yymv1 == nil {
 83224  					yymv1 = new(JobDeregisterOptions)
 83225  				}
 83226  				yymv1.CodecDecodeSelf(d)
 83227  			}
 83228  
 83229  			if yyms1 && yyv1 != nil {
 83230  				yyv1[yymk1] = yymv1
 83231  			}
 83232  		}
 83233  	} else if yyl1 < 0 {
 83234  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 83235  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 83236  			if r.TryDecodeAsNil() {
 83237  				yymk1 = NamespacedID{}
 83238  			} else {
 83239  				yyv4 := &yymk1
 83240  				yyv4.CodecDecodeSelf(d)
 83241  			}
 83242  
 83243  			yyms1 = true
 83244  			if yymg1 {
 83245  				yymv1, yymok1 = yyv1[yymk1]
 83246  				if yymok1 {
 83247  					yyms1 = false
 83248  				}
 83249  			} else {
 83250  				yymv1 = nil
 83251  			}
 83252  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 83253  			if r.TryDecodeAsNil() {
 83254  				if yymv1 != nil {
 83255  					*yymv1 = JobDeregisterOptions{}
 83256  				}
 83257  			} else {
 83258  				if yymv1 == nil {
 83259  					yymv1 = new(JobDeregisterOptions)
 83260  				}
 83261  				yymv1.CodecDecodeSelf(d)
 83262  			}
 83263  
 83264  			if yyms1 && yyv1 != nil {
 83265  				yyv1[yymk1] = yymv1
 83266  			}
 83267  		}
 83268  	} // else len==0: TODO: Should we clear map entries?
 83269  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 83270  }
 83271  
 83272  func (x codecSelfer100) encSlicePtrtoEvaluation(v []*Evaluation, e *codec1978.Encoder) {
 83273  	var h codecSelfer100
 83274  	z, r := codec1978.GenHelperEncoder(e)
 83275  	_, _, _ = h, z, r
 83276  	r.EncodeArrayStart(len(v))
 83277  	for _, yyv1 := range v {
 83278  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 83279  		if yyv1 == nil {
 83280  			r.EncodeNil()
 83281  		} else {
 83282  			yyv1.CodecEncodeSelf(e)
 83283  		}
 83284  	}
 83285  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 83286  }
 83287  
 83288  func (x codecSelfer100) decSlicePtrtoEvaluation(v *[]*Evaluation, d *codec1978.Decoder) {
 83289  	var h codecSelfer100
 83290  	z, r := codec1978.GenHelperDecoder(d)
 83291  	_, _, _ = h, z, r
 83292  
 83293  	yyv1 := *v
 83294  	yyh1, yyl1 := z.DecSliceHelperStart()
 83295  	var yyc1 bool
 83296  	_ = yyc1
 83297  	if yyl1 == 0 {
 83298  		if yyv1 == nil {
 83299  			yyv1 = []*Evaluation{}
 83300  			yyc1 = true
 83301  		} else if len(yyv1) != 0 {
 83302  			yyv1 = yyv1[:0]
 83303  			yyc1 = true
 83304  		}
 83305  	} else if yyl1 > 0 {
 83306  		var yyrr1, yyrl1 int
 83307  		var yyrt1 bool
 83308  		_, _ = yyrl1, yyrt1
 83309  		yyrr1 = yyl1 // len(yyv1)
 83310  		if yyl1 > cap(yyv1) {
 83311  
 83312  			yyrg1 := len(yyv1) > 0
 83313  			yyv21 := yyv1
 83314  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 83315  			if yyrt1 {
 83316  				if yyrl1 <= cap(yyv1) {
 83317  					yyv1 = yyv1[:yyrl1]
 83318  				} else {
 83319  					yyv1 = make([]*Evaluation, yyrl1)
 83320  				}
 83321  			} else {
 83322  				yyv1 = make([]*Evaluation, yyrl1)
 83323  			}
 83324  			yyc1 = true
 83325  			yyrr1 = len(yyv1)
 83326  			if yyrg1 {
 83327  				copy(yyv1, yyv21)
 83328  			}
 83329  		} else if yyl1 != len(yyv1) {
 83330  			yyv1 = yyv1[:yyl1]
 83331  			yyc1 = true
 83332  		}
 83333  		yyj1 := 0
 83334  		for ; yyj1 < yyrr1; yyj1++ {
 83335  			yyh1.ElemContainerState(yyj1)
 83336  			if r.TryDecodeAsNil() {
 83337  				if yyv1[yyj1] != nil {
 83338  					*yyv1[yyj1] = Evaluation{}
 83339  				}
 83340  			} else {
 83341  				if yyv1[yyj1] == nil {
 83342  					yyv1[yyj1] = new(Evaluation)
 83343  				}
 83344  				yyw2 := yyv1[yyj1]
 83345  				yyw2.CodecDecodeSelf(d)
 83346  			}
 83347  
 83348  		}
 83349  		if yyrt1 {
 83350  			for ; yyj1 < yyl1; yyj1++ {
 83351  				yyv1 = append(yyv1, nil)
 83352  				yyh1.ElemContainerState(yyj1)
 83353  				if r.TryDecodeAsNil() {
 83354  					if yyv1[yyj1] != nil {
 83355  						*yyv1[yyj1] = Evaluation{}
 83356  					}
 83357  				} else {
 83358  					if yyv1[yyj1] == nil {
 83359  						yyv1[yyj1] = new(Evaluation)
 83360  					}
 83361  					yyw3 := yyv1[yyj1]
 83362  					yyw3.CodecDecodeSelf(d)
 83363  				}
 83364  
 83365  			}
 83366  		}
 83367  
 83368  	} else {
 83369  		yyj1 := 0
 83370  		for ; !r.CheckBreak(); yyj1++ {
 83371  
 83372  			if yyj1 >= len(yyv1) {
 83373  				yyv1 = append(yyv1, nil) // var yyz1 *Evaluation
 83374  				yyc1 = true
 83375  			}
 83376  			yyh1.ElemContainerState(yyj1)
 83377  			if yyj1 < len(yyv1) {
 83378  				if r.TryDecodeAsNil() {
 83379  					if yyv1[yyj1] != nil {
 83380  						*yyv1[yyj1] = Evaluation{}
 83381  					}
 83382  				} else {
 83383  					if yyv1[yyj1] == nil {
 83384  						yyv1[yyj1] = new(Evaluation)
 83385  					}
 83386  					yyw4 := yyv1[yyj1]
 83387  					yyw4.CodecDecodeSelf(d)
 83388  				}
 83389  
 83390  			} else {
 83391  				z.DecSwallow()
 83392  			}
 83393  
 83394  		}
 83395  		if yyj1 < len(yyv1) {
 83396  			yyv1 = yyv1[:yyj1]
 83397  			yyc1 = true
 83398  		} else if yyj1 == 0 && yyv1 == nil {
 83399  			yyv1 = []*Evaluation{}
 83400  			yyc1 = true
 83401  		}
 83402  	}
 83403  	yyh1.End()
 83404  	if yyc1 {
 83405  		*v = yyv1
 83406  	}
 83407  }
 83408  
 83409  func (x codecSelfer100) encSlicePtrtoAllocation(v []*Allocation, e *codec1978.Encoder) {
 83410  	var h codecSelfer100
 83411  	z, r := codec1978.GenHelperEncoder(e)
 83412  	_, _, _ = h, z, r
 83413  	r.EncodeArrayStart(len(v))
 83414  	for _, yyv1 := range v {
 83415  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 83416  		if yyv1 == nil {
 83417  			r.EncodeNil()
 83418  		} else {
 83419  			yyv1.CodecEncodeSelf(e)
 83420  		}
 83421  	}
 83422  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 83423  }
 83424  
 83425  func (x codecSelfer100) decSlicePtrtoAllocation(v *[]*Allocation, d *codec1978.Decoder) {
 83426  	var h codecSelfer100
 83427  	z, r := codec1978.GenHelperDecoder(d)
 83428  	_, _, _ = h, z, r
 83429  
 83430  	yyv1 := *v
 83431  	yyh1, yyl1 := z.DecSliceHelperStart()
 83432  	var yyc1 bool
 83433  	_ = yyc1
 83434  	if yyl1 == 0 {
 83435  		if yyv1 == nil {
 83436  			yyv1 = []*Allocation{}
 83437  			yyc1 = true
 83438  		} else if len(yyv1) != 0 {
 83439  			yyv1 = yyv1[:0]
 83440  			yyc1 = true
 83441  		}
 83442  	} else if yyl1 > 0 {
 83443  		var yyrr1, yyrl1 int
 83444  		var yyrt1 bool
 83445  		_, _ = yyrl1, yyrt1
 83446  		yyrr1 = yyl1 // len(yyv1)
 83447  		if yyl1 > cap(yyv1) {
 83448  
 83449  			yyrg1 := len(yyv1) > 0
 83450  			yyv21 := yyv1
 83451  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 83452  			if yyrt1 {
 83453  				if yyrl1 <= cap(yyv1) {
 83454  					yyv1 = yyv1[:yyrl1]
 83455  				} else {
 83456  					yyv1 = make([]*Allocation, yyrl1)
 83457  				}
 83458  			} else {
 83459  				yyv1 = make([]*Allocation, yyrl1)
 83460  			}
 83461  			yyc1 = true
 83462  			yyrr1 = len(yyv1)
 83463  			if yyrg1 {
 83464  				copy(yyv1, yyv21)
 83465  			}
 83466  		} else if yyl1 != len(yyv1) {
 83467  			yyv1 = yyv1[:yyl1]
 83468  			yyc1 = true
 83469  		}
 83470  		yyj1 := 0
 83471  		for ; yyj1 < yyrr1; yyj1++ {
 83472  			yyh1.ElemContainerState(yyj1)
 83473  			if r.TryDecodeAsNil() {
 83474  				if yyv1[yyj1] != nil {
 83475  					*yyv1[yyj1] = Allocation{}
 83476  				}
 83477  			} else {
 83478  				if yyv1[yyj1] == nil {
 83479  					yyv1[yyj1] = new(Allocation)
 83480  				}
 83481  				yyw2 := yyv1[yyj1]
 83482  				yyw2.CodecDecodeSelf(d)
 83483  			}
 83484  
 83485  		}
 83486  		if yyrt1 {
 83487  			for ; yyj1 < yyl1; yyj1++ {
 83488  				yyv1 = append(yyv1, nil)
 83489  				yyh1.ElemContainerState(yyj1)
 83490  				if r.TryDecodeAsNil() {
 83491  					if yyv1[yyj1] != nil {
 83492  						*yyv1[yyj1] = Allocation{}
 83493  					}
 83494  				} else {
 83495  					if yyv1[yyj1] == nil {
 83496  						yyv1[yyj1] = new(Allocation)
 83497  					}
 83498  					yyw3 := yyv1[yyj1]
 83499  					yyw3.CodecDecodeSelf(d)
 83500  				}
 83501  
 83502  			}
 83503  		}
 83504  
 83505  	} else {
 83506  		yyj1 := 0
 83507  		for ; !r.CheckBreak(); yyj1++ {
 83508  
 83509  			if yyj1 >= len(yyv1) {
 83510  				yyv1 = append(yyv1, nil) // var yyz1 *Allocation
 83511  				yyc1 = true
 83512  			}
 83513  			yyh1.ElemContainerState(yyj1)
 83514  			if yyj1 < len(yyv1) {
 83515  				if r.TryDecodeAsNil() {
 83516  					if yyv1[yyj1] != nil {
 83517  						*yyv1[yyj1] = Allocation{}
 83518  					}
 83519  				} else {
 83520  					if yyv1[yyj1] == nil {
 83521  						yyv1[yyj1] = new(Allocation)
 83522  					}
 83523  					yyw4 := yyv1[yyj1]
 83524  					yyw4.CodecDecodeSelf(d)
 83525  				}
 83526  
 83527  			} else {
 83528  				z.DecSwallow()
 83529  			}
 83530  
 83531  		}
 83532  		if yyj1 < len(yyv1) {
 83533  			yyv1 = yyv1[:yyj1]
 83534  			yyc1 = true
 83535  		} else if yyj1 == 0 && yyv1 == nil {
 83536  			yyv1 = []*Allocation{}
 83537  			yyc1 = true
 83538  		}
 83539  	}
 83540  	yyh1.End()
 83541  	if yyc1 {
 83542  		*v = yyv1
 83543  	}
 83544  }
 83545  
 83546  func (x codecSelfer100) encSlicePtrtoDeploymentStatusUpdate(v []*DeploymentStatusUpdate, e *codec1978.Encoder) {
 83547  	var h codecSelfer100
 83548  	z, r := codec1978.GenHelperEncoder(e)
 83549  	_, _, _ = h, z, r
 83550  	r.EncodeArrayStart(len(v))
 83551  	for _, yyv1 := range v {
 83552  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 83553  		if yyv1 == nil {
 83554  			r.EncodeNil()
 83555  		} else {
 83556  			yyv1.CodecEncodeSelf(e)
 83557  		}
 83558  	}
 83559  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 83560  }
 83561  
 83562  func (x codecSelfer100) decSlicePtrtoDeploymentStatusUpdate(v *[]*DeploymentStatusUpdate, d *codec1978.Decoder) {
 83563  	var h codecSelfer100
 83564  	z, r := codec1978.GenHelperDecoder(d)
 83565  	_, _, _ = h, z, r
 83566  
 83567  	yyv1 := *v
 83568  	yyh1, yyl1 := z.DecSliceHelperStart()
 83569  	var yyc1 bool
 83570  	_ = yyc1
 83571  	if yyl1 == 0 {
 83572  		if yyv1 == nil {
 83573  			yyv1 = []*DeploymentStatusUpdate{}
 83574  			yyc1 = true
 83575  		} else if len(yyv1) != 0 {
 83576  			yyv1 = yyv1[:0]
 83577  			yyc1 = true
 83578  		}
 83579  	} else if yyl1 > 0 {
 83580  		var yyrr1, yyrl1 int
 83581  		var yyrt1 bool
 83582  		_, _ = yyrl1, yyrt1
 83583  		yyrr1 = yyl1 // len(yyv1)
 83584  		if yyl1 > cap(yyv1) {
 83585  
 83586  			yyrg1 := len(yyv1) > 0
 83587  			yyv21 := yyv1
 83588  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 83589  			if yyrt1 {
 83590  				if yyrl1 <= cap(yyv1) {
 83591  					yyv1 = yyv1[:yyrl1]
 83592  				} else {
 83593  					yyv1 = make([]*DeploymentStatusUpdate, yyrl1)
 83594  				}
 83595  			} else {
 83596  				yyv1 = make([]*DeploymentStatusUpdate, yyrl1)
 83597  			}
 83598  			yyc1 = true
 83599  			yyrr1 = len(yyv1)
 83600  			if yyrg1 {
 83601  				copy(yyv1, yyv21)
 83602  			}
 83603  		} else if yyl1 != len(yyv1) {
 83604  			yyv1 = yyv1[:yyl1]
 83605  			yyc1 = true
 83606  		}
 83607  		yyj1 := 0
 83608  		for ; yyj1 < yyrr1; yyj1++ {
 83609  			yyh1.ElemContainerState(yyj1)
 83610  			if r.TryDecodeAsNil() {
 83611  				if yyv1[yyj1] != nil {
 83612  					*yyv1[yyj1] = DeploymentStatusUpdate{}
 83613  				}
 83614  			} else {
 83615  				if yyv1[yyj1] == nil {
 83616  					yyv1[yyj1] = new(DeploymentStatusUpdate)
 83617  				}
 83618  				yyw2 := yyv1[yyj1]
 83619  				yyw2.CodecDecodeSelf(d)
 83620  			}
 83621  
 83622  		}
 83623  		if yyrt1 {
 83624  			for ; yyj1 < yyl1; yyj1++ {
 83625  				yyv1 = append(yyv1, nil)
 83626  				yyh1.ElemContainerState(yyj1)
 83627  				if r.TryDecodeAsNil() {
 83628  					if yyv1[yyj1] != nil {
 83629  						*yyv1[yyj1] = DeploymentStatusUpdate{}
 83630  					}
 83631  				} else {
 83632  					if yyv1[yyj1] == nil {
 83633  						yyv1[yyj1] = new(DeploymentStatusUpdate)
 83634  					}
 83635  					yyw3 := yyv1[yyj1]
 83636  					yyw3.CodecDecodeSelf(d)
 83637  				}
 83638  
 83639  			}
 83640  		}
 83641  
 83642  	} else {
 83643  		yyj1 := 0
 83644  		for ; !r.CheckBreak(); yyj1++ {
 83645  
 83646  			if yyj1 >= len(yyv1) {
 83647  				yyv1 = append(yyv1, nil) // var yyz1 *DeploymentStatusUpdate
 83648  				yyc1 = true
 83649  			}
 83650  			yyh1.ElemContainerState(yyj1)
 83651  			if yyj1 < len(yyv1) {
 83652  				if r.TryDecodeAsNil() {
 83653  					if yyv1[yyj1] != nil {
 83654  						*yyv1[yyj1] = DeploymentStatusUpdate{}
 83655  					}
 83656  				} else {
 83657  					if yyv1[yyj1] == nil {
 83658  						yyv1[yyj1] = new(DeploymentStatusUpdate)
 83659  					}
 83660  					yyw4 := yyv1[yyj1]
 83661  					yyw4.CodecDecodeSelf(d)
 83662  				}
 83663  
 83664  			} else {
 83665  				z.DecSwallow()
 83666  			}
 83667  
 83668  		}
 83669  		if yyj1 < len(yyv1) {
 83670  			yyv1 = yyv1[:yyj1]
 83671  			yyc1 = true
 83672  		} else if yyj1 == 0 && yyv1 == nil {
 83673  			yyv1 = []*DeploymentStatusUpdate{}
 83674  			yyc1 = true
 83675  		}
 83676  	}
 83677  	yyh1.End()
 83678  	if yyc1 {
 83679  		*v = yyv1
 83680  	}
 83681  }
 83682  
 83683  func (x codecSelfer100) encMapstringPtrtoDesiredTransition(v map[string]*DesiredTransition, e *codec1978.Encoder) {
 83684  	var h codecSelfer100
 83685  	z, r := codec1978.GenHelperEncoder(e)
 83686  	_, _, _ = h, z, r
 83687  	r.EncodeMapStart(len(v))
 83688  	for yyk1, yyv1 := range v {
 83689  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 83690  		yym2 := z.EncBinary()
 83691  		_ = yym2
 83692  		if false {
 83693  		} else {
 83694  			r.EncodeString(codecSelferC_UTF8100, string(yyk1))
 83695  		}
 83696  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 83697  		if yyv1 == nil {
 83698  			r.EncodeNil()
 83699  		} else {
 83700  			yyv1.CodecEncodeSelf(e)
 83701  		}
 83702  	}
 83703  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 83704  }
 83705  
 83706  func (x codecSelfer100) decMapstringPtrtoDesiredTransition(v *map[string]*DesiredTransition, d *codec1978.Decoder) {
 83707  	var h codecSelfer100
 83708  	z, r := codec1978.GenHelperDecoder(d)
 83709  	_, _, _ = h, z, r
 83710  
 83711  	yyv1 := *v
 83712  	yyl1 := r.ReadMapStart()
 83713  	yybh1 := z.DecBasicHandle()
 83714  	if yyv1 == nil {
 83715  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 24)
 83716  		yyv1 = make(map[string]*DesiredTransition, yyrl1)
 83717  		*v = yyv1
 83718  	}
 83719  	var yymk1 string
 83720  	var yymv1 *DesiredTransition
 83721  	var yymg1, yyms1, yymok1 bool
 83722  	if yybh1.MapValueReset {
 83723  		yymg1 = true
 83724  	}
 83725  	if yyl1 > 0 {
 83726  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 83727  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 83728  			if r.TryDecodeAsNil() {
 83729  				yymk1 = ""
 83730  			} else {
 83731  				yyv2 := &yymk1
 83732  				yym3 := z.DecBinary()
 83733  				_ = yym3
 83734  				if false {
 83735  				} else {
 83736  					*((*string)(yyv2)) = r.DecodeString()
 83737  				}
 83738  			}
 83739  
 83740  			yyms1 = true
 83741  			if yymg1 {
 83742  				yymv1, yymok1 = yyv1[yymk1]
 83743  				if yymok1 {
 83744  					yyms1 = false
 83745  				}
 83746  			} else {
 83747  				yymv1 = nil
 83748  			}
 83749  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 83750  			if r.TryDecodeAsNil() {
 83751  				if yymv1 != nil {
 83752  					*yymv1 = DesiredTransition{}
 83753  				}
 83754  			} else {
 83755  				if yymv1 == nil {
 83756  					yymv1 = new(DesiredTransition)
 83757  				}
 83758  				yymv1.CodecDecodeSelf(d)
 83759  			}
 83760  
 83761  			if yyms1 && yyv1 != nil {
 83762  				yyv1[yymk1] = yymv1
 83763  			}
 83764  		}
 83765  	} else if yyl1 < 0 {
 83766  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 83767  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 83768  			if r.TryDecodeAsNil() {
 83769  				yymk1 = ""
 83770  			} else {
 83771  				yyv5 := &yymk1
 83772  				yym6 := z.DecBinary()
 83773  				_ = yym6
 83774  				if false {
 83775  				} else {
 83776  					*((*string)(yyv5)) = r.DecodeString()
 83777  				}
 83778  			}
 83779  
 83780  			yyms1 = true
 83781  			if yymg1 {
 83782  				yymv1, yymok1 = yyv1[yymk1]
 83783  				if yymok1 {
 83784  					yyms1 = false
 83785  				}
 83786  			} else {
 83787  				yymv1 = nil
 83788  			}
 83789  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 83790  			if r.TryDecodeAsNil() {
 83791  				if yymv1 != nil {
 83792  					*yymv1 = DesiredTransition{}
 83793  				}
 83794  			} else {
 83795  				if yymv1 == nil {
 83796  					yymv1 = new(DesiredTransition)
 83797  				}
 83798  				yymv1.CodecDecodeSelf(d)
 83799  			}
 83800  
 83801  			if yyms1 && yyv1 != nil {
 83802  				yyv1[yymk1] = yymv1
 83803  			}
 83804  		}
 83805  	} // else len==0: TODO: Should we clear map entries?
 83806  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 83807  }
 83808  
 83809  func (x codecSelfer100) encSlicePtrtoServerMember(v []*ServerMember, e *codec1978.Encoder) {
 83810  	var h codecSelfer100
 83811  	z, r := codec1978.GenHelperEncoder(e)
 83812  	_, _, _ = h, z, r
 83813  	r.EncodeArrayStart(len(v))
 83814  	for _, yyv1 := range v {
 83815  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 83816  		if yyv1 == nil {
 83817  			r.EncodeNil()
 83818  		} else {
 83819  			yyv1.CodecEncodeSelf(e)
 83820  		}
 83821  	}
 83822  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 83823  }
 83824  
 83825  func (x codecSelfer100) decSlicePtrtoServerMember(v *[]*ServerMember, d *codec1978.Decoder) {
 83826  	var h codecSelfer100
 83827  	z, r := codec1978.GenHelperDecoder(d)
 83828  	_, _, _ = h, z, r
 83829  
 83830  	yyv1 := *v
 83831  	yyh1, yyl1 := z.DecSliceHelperStart()
 83832  	var yyc1 bool
 83833  	_ = yyc1
 83834  	if yyl1 == 0 {
 83835  		if yyv1 == nil {
 83836  			yyv1 = []*ServerMember{}
 83837  			yyc1 = true
 83838  		} else if len(yyv1) != 0 {
 83839  			yyv1 = yyv1[:0]
 83840  			yyc1 = true
 83841  		}
 83842  	} else if yyl1 > 0 {
 83843  		var yyrr1, yyrl1 int
 83844  		var yyrt1 bool
 83845  		_, _ = yyrl1, yyrt1
 83846  		yyrr1 = yyl1 // len(yyv1)
 83847  		if yyl1 > cap(yyv1) {
 83848  
 83849  			yyrg1 := len(yyv1) > 0
 83850  			yyv21 := yyv1
 83851  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 83852  			if yyrt1 {
 83853  				if yyrl1 <= cap(yyv1) {
 83854  					yyv1 = yyv1[:yyrl1]
 83855  				} else {
 83856  					yyv1 = make([]*ServerMember, yyrl1)
 83857  				}
 83858  			} else {
 83859  				yyv1 = make([]*ServerMember, yyrl1)
 83860  			}
 83861  			yyc1 = true
 83862  			yyrr1 = len(yyv1)
 83863  			if yyrg1 {
 83864  				copy(yyv1, yyv21)
 83865  			}
 83866  		} else if yyl1 != len(yyv1) {
 83867  			yyv1 = yyv1[:yyl1]
 83868  			yyc1 = true
 83869  		}
 83870  		yyj1 := 0
 83871  		for ; yyj1 < yyrr1; yyj1++ {
 83872  			yyh1.ElemContainerState(yyj1)
 83873  			if r.TryDecodeAsNil() {
 83874  				if yyv1[yyj1] != nil {
 83875  					*yyv1[yyj1] = ServerMember{}
 83876  				}
 83877  			} else {
 83878  				if yyv1[yyj1] == nil {
 83879  					yyv1[yyj1] = new(ServerMember)
 83880  				}
 83881  				yyw2 := yyv1[yyj1]
 83882  				yyw2.CodecDecodeSelf(d)
 83883  			}
 83884  
 83885  		}
 83886  		if yyrt1 {
 83887  			for ; yyj1 < yyl1; yyj1++ {
 83888  				yyv1 = append(yyv1, nil)
 83889  				yyh1.ElemContainerState(yyj1)
 83890  				if r.TryDecodeAsNil() {
 83891  					if yyv1[yyj1] != nil {
 83892  						*yyv1[yyj1] = ServerMember{}
 83893  					}
 83894  				} else {
 83895  					if yyv1[yyj1] == nil {
 83896  						yyv1[yyj1] = new(ServerMember)
 83897  					}
 83898  					yyw3 := yyv1[yyj1]
 83899  					yyw3.CodecDecodeSelf(d)
 83900  				}
 83901  
 83902  			}
 83903  		}
 83904  
 83905  	} else {
 83906  		yyj1 := 0
 83907  		for ; !r.CheckBreak(); yyj1++ {
 83908  
 83909  			if yyj1 >= len(yyv1) {
 83910  				yyv1 = append(yyv1, nil) // var yyz1 *ServerMember
 83911  				yyc1 = true
 83912  			}
 83913  			yyh1.ElemContainerState(yyj1)
 83914  			if yyj1 < len(yyv1) {
 83915  				if r.TryDecodeAsNil() {
 83916  					if yyv1[yyj1] != nil {
 83917  						*yyv1[yyj1] = ServerMember{}
 83918  					}
 83919  				} else {
 83920  					if yyv1[yyj1] == nil {
 83921  						yyv1[yyj1] = new(ServerMember)
 83922  					}
 83923  					yyw4 := yyv1[yyj1]
 83924  					yyw4.CodecDecodeSelf(d)
 83925  				}
 83926  
 83927  			} else {
 83928  				z.DecSwallow()
 83929  			}
 83930  
 83931  		}
 83932  		if yyj1 < len(yyv1) {
 83933  			yyv1 = yyv1[:yyj1]
 83934  			yyc1 = true
 83935  		} else if yyj1 == 0 && yyv1 == nil {
 83936  			yyv1 = []*ServerMember{}
 83937  			yyc1 = true
 83938  		}
 83939  	}
 83940  	yyh1.End()
 83941  	if yyc1 {
 83942  		*v = yyv1
 83943  	}
 83944  }
 83945  
 83946  func (x codecSelfer100) encnet_IP(v net.IP, e *codec1978.Encoder) {
 83947  	var h codecSelfer100
 83948  	z, r := codec1978.GenHelperEncoder(e)
 83949  	_, _, _ = h, z, r
 83950  	r.EncodeStringBytes(codecSelferC_RAW100, []byte(v))
 83951  }
 83952  
 83953  func (x codecSelfer100) decnet_IP(v *net.IP, d *codec1978.Decoder) {
 83954  	var h codecSelfer100
 83955  	z, r := codec1978.GenHelperDecoder(d)
 83956  	_, _, _ = h, z, r
 83957  	*v = r.DecodeBytes(*((*[]byte)(v)), false, false)
 83958  }
 83959  
 83960  func (x codecSelfer100) encSlicePtrtoVaultAccessor(v []*VaultAccessor, e *codec1978.Encoder) {
 83961  	var h codecSelfer100
 83962  	z, r := codec1978.GenHelperEncoder(e)
 83963  	_, _, _ = h, z, r
 83964  	r.EncodeArrayStart(len(v))
 83965  	for _, yyv1 := range v {
 83966  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 83967  		if yyv1 == nil {
 83968  			r.EncodeNil()
 83969  		} else {
 83970  			yyv1.CodecEncodeSelf(e)
 83971  		}
 83972  	}
 83973  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 83974  }
 83975  
 83976  func (x codecSelfer100) decSlicePtrtoVaultAccessor(v *[]*VaultAccessor, d *codec1978.Decoder) {
 83977  	var h codecSelfer100
 83978  	z, r := codec1978.GenHelperDecoder(d)
 83979  	_, _, _ = h, z, r
 83980  
 83981  	yyv1 := *v
 83982  	yyh1, yyl1 := z.DecSliceHelperStart()
 83983  	var yyc1 bool
 83984  	_ = yyc1
 83985  	if yyl1 == 0 {
 83986  		if yyv1 == nil {
 83987  			yyv1 = []*VaultAccessor{}
 83988  			yyc1 = true
 83989  		} else if len(yyv1) != 0 {
 83990  			yyv1 = yyv1[:0]
 83991  			yyc1 = true
 83992  		}
 83993  	} else if yyl1 > 0 {
 83994  		var yyrr1, yyrl1 int
 83995  		var yyrt1 bool
 83996  		_, _ = yyrl1, yyrt1
 83997  		yyrr1 = yyl1 // len(yyv1)
 83998  		if yyl1 > cap(yyv1) {
 83999  
 84000  			yyrg1 := len(yyv1) > 0
 84001  			yyv21 := yyv1
 84002  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 84003  			if yyrt1 {
 84004  				if yyrl1 <= cap(yyv1) {
 84005  					yyv1 = yyv1[:yyrl1]
 84006  				} else {
 84007  					yyv1 = make([]*VaultAccessor, yyrl1)
 84008  				}
 84009  			} else {
 84010  				yyv1 = make([]*VaultAccessor, yyrl1)
 84011  			}
 84012  			yyc1 = true
 84013  			yyrr1 = len(yyv1)
 84014  			if yyrg1 {
 84015  				copy(yyv1, yyv21)
 84016  			}
 84017  		} else if yyl1 != len(yyv1) {
 84018  			yyv1 = yyv1[:yyl1]
 84019  			yyc1 = true
 84020  		}
 84021  		yyj1 := 0
 84022  		for ; yyj1 < yyrr1; yyj1++ {
 84023  			yyh1.ElemContainerState(yyj1)
 84024  			if r.TryDecodeAsNil() {
 84025  				if yyv1[yyj1] != nil {
 84026  					*yyv1[yyj1] = VaultAccessor{}
 84027  				}
 84028  			} else {
 84029  				if yyv1[yyj1] == nil {
 84030  					yyv1[yyj1] = new(VaultAccessor)
 84031  				}
 84032  				yyw2 := yyv1[yyj1]
 84033  				yyw2.CodecDecodeSelf(d)
 84034  			}
 84035  
 84036  		}
 84037  		if yyrt1 {
 84038  			for ; yyj1 < yyl1; yyj1++ {
 84039  				yyv1 = append(yyv1, nil)
 84040  				yyh1.ElemContainerState(yyj1)
 84041  				if r.TryDecodeAsNil() {
 84042  					if yyv1[yyj1] != nil {
 84043  						*yyv1[yyj1] = VaultAccessor{}
 84044  					}
 84045  				} else {
 84046  					if yyv1[yyj1] == nil {
 84047  						yyv1[yyj1] = new(VaultAccessor)
 84048  					}
 84049  					yyw3 := yyv1[yyj1]
 84050  					yyw3.CodecDecodeSelf(d)
 84051  				}
 84052  
 84053  			}
 84054  		}
 84055  
 84056  	} else {
 84057  		yyj1 := 0
 84058  		for ; !r.CheckBreak(); yyj1++ {
 84059  
 84060  			if yyj1 >= len(yyv1) {
 84061  				yyv1 = append(yyv1, nil) // var yyz1 *VaultAccessor
 84062  				yyc1 = true
 84063  			}
 84064  			yyh1.ElemContainerState(yyj1)
 84065  			if yyj1 < len(yyv1) {
 84066  				if r.TryDecodeAsNil() {
 84067  					if yyv1[yyj1] != nil {
 84068  						*yyv1[yyj1] = VaultAccessor{}
 84069  					}
 84070  				} else {
 84071  					if yyv1[yyj1] == nil {
 84072  						yyv1[yyj1] = new(VaultAccessor)
 84073  					}
 84074  					yyw4 := yyv1[yyj1]
 84075  					yyw4.CodecDecodeSelf(d)
 84076  				}
 84077  
 84078  			} else {
 84079  				z.DecSwallow()
 84080  			}
 84081  
 84082  		}
 84083  		if yyj1 < len(yyv1) {
 84084  			yyv1 = yyv1[:yyj1]
 84085  			yyc1 = true
 84086  		} else if yyj1 == 0 && yyv1 == nil {
 84087  			yyv1 = []*VaultAccessor{}
 84088  			yyc1 = true
 84089  		}
 84090  	}
 84091  	yyh1.End()
 84092  	if yyc1 {
 84093  		*v = yyv1
 84094  	}
 84095  }
 84096  
 84097  func (x codecSelfer100) encMapNamespacedIDstring(v map[NamespacedID]string, e *codec1978.Encoder) {
 84098  	var h codecSelfer100
 84099  	z, r := codec1978.GenHelperEncoder(e)
 84100  	_, _, _ = h, z, r
 84101  	r.EncodeMapStart(len(v))
 84102  	for yyk1, yyv1 := range v {
 84103  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 84104  		yy2 := &yyk1
 84105  		yy2.CodecEncodeSelf(e)
 84106  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 84107  		yym4 := z.EncBinary()
 84108  		_ = yym4
 84109  		if false {
 84110  		} else {
 84111  			r.EncodeString(codecSelferC_UTF8100, string(yyv1))
 84112  		}
 84113  	}
 84114  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 84115  }
 84116  
 84117  func (x codecSelfer100) decMapNamespacedIDstring(v *map[NamespacedID]string, d *codec1978.Decoder) {
 84118  	var h codecSelfer100
 84119  	z, r := codec1978.GenHelperDecoder(d)
 84120  	_, _, _ = h, z, r
 84121  
 84122  	yyv1 := *v
 84123  	yyl1 := r.ReadMapStart()
 84124  	yybh1 := z.DecBasicHandle()
 84125  	if yyv1 == nil {
 84126  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 48)
 84127  		yyv1 = make(map[NamespacedID]string, yyrl1)
 84128  		*v = yyv1
 84129  	}
 84130  	var yymk1 NamespacedID
 84131  	var yymv1 string
 84132  	var yymg1 bool
 84133  	if yybh1.MapValueReset {
 84134  	}
 84135  	if yyl1 > 0 {
 84136  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 84137  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 84138  			if r.TryDecodeAsNil() {
 84139  				yymk1 = NamespacedID{}
 84140  			} else {
 84141  				yyv2 := &yymk1
 84142  				yyv2.CodecDecodeSelf(d)
 84143  			}
 84144  
 84145  			if yymg1 {
 84146  				yymv1 = yyv1[yymk1]
 84147  			}
 84148  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 84149  			if r.TryDecodeAsNil() {
 84150  				yymv1 = ""
 84151  			} else {
 84152  				yyv3 := &yymv1
 84153  				yym4 := z.DecBinary()
 84154  				_ = yym4
 84155  				if false {
 84156  				} else {
 84157  					*((*string)(yyv3)) = r.DecodeString()
 84158  				}
 84159  			}
 84160  
 84161  			if yyv1 != nil {
 84162  				yyv1[yymk1] = yymv1
 84163  			}
 84164  		}
 84165  	} else if yyl1 < 0 {
 84166  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 84167  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 84168  			if r.TryDecodeAsNil() {
 84169  				yymk1 = NamespacedID{}
 84170  			} else {
 84171  				yyv5 := &yymk1
 84172  				yyv5.CodecDecodeSelf(d)
 84173  			}
 84174  
 84175  			if yymg1 {
 84176  				yymv1 = yyv1[yymk1]
 84177  			}
 84178  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 84179  			if r.TryDecodeAsNil() {
 84180  				yymv1 = ""
 84181  			} else {
 84182  				yyv6 := &yymv1
 84183  				yym7 := z.DecBinary()
 84184  				_ = yym7
 84185  				if false {
 84186  				} else {
 84187  					*((*string)(yyv6)) = r.DecodeString()
 84188  				}
 84189  			}
 84190  
 84191  			if yyv1 != nil {
 84192  				yyv1[yymk1] = yymv1
 84193  			}
 84194  		}
 84195  	} // else len==0: TODO: Should we clear map entries?
 84196  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 84197  }
 84198  
 84199  func (x codecSelfer100) encSlicePtrtoNodeServerInfo(v []*NodeServerInfo, e *codec1978.Encoder) {
 84200  	var h codecSelfer100
 84201  	z, r := codec1978.GenHelperEncoder(e)
 84202  	_, _, _ = h, z, r
 84203  	r.EncodeArrayStart(len(v))
 84204  	for _, yyv1 := range v {
 84205  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 84206  		if yyv1 == nil {
 84207  			r.EncodeNil()
 84208  		} else {
 84209  			yyv1.CodecEncodeSelf(e)
 84210  		}
 84211  	}
 84212  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 84213  }
 84214  
 84215  func (x codecSelfer100) decSlicePtrtoNodeServerInfo(v *[]*NodeServerInfo, d *codec1978.Decoder) {
 84216  	var h codecSelfer100
 84217  	z, r := codec1978.GenHelperDecoder(d)
 84218  	_, _, _ = h, z, r
 84219  
 84220  	yyv1 := *v
 84221  	yyh1, yyl1 := z.DecSliceHelperStart()
 84222  	var yyc1 bool
 84223  	_ = yyc1
 84224  	if yyl1 == 0 {
 84225  		if yyv1 == nil {
 84226  			yyv1 = []*NodeServerInfo{}
 84227  			yyc1 = true
 84228  		} else if len(yyv1) != 0 {
 84229  			yyv1 = yyv1[:0]
 84230  			yyc1 = true
 84231  		}
 84232  	} else if yyl1 > 0 {
 84233  		var yyrr1, yyrl1 int
 84234  		var yyrt1 bool
 84235  		_, _ = yyrl1, yyrt1
 84236  		yyrr1 = yyl1 // len(yyv1)
 84237  		if yyl1 > cap(yyv1) {
 84238  
 84239  			yyrg1 := len(yyv1) > 0
 84240  			yyv21 := yyv1
 84241  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 84242  			if yyrt1 {
 84243  				if yyrl1 <= cap(yyv1) {
 84244  					yyv1 = yyv1[:yyrl1]
 84245  				} else {
 84246  					yyv1 = make([]*NodeServerInfo, yyrl1)
 84247  				}
 84248  			} else {
 84249  				yyv1 = make([]*NodeServerInfo, yyrl1)
 84250  			}
 84251  			yyc1 = true
 84252  			yyrr1 = len(yyv1)
 84253  			if yyrg1 {
 84254  				copy(yyv1, yyv21)
 84255  			}
 84256  		} else if yyl1 != len(yyv1) {
 84257  			yyv1 = yyv1[:yyl1]
 84258  			yyc1 = true
 84259  		}
 84260  		yyj1 := 0
 84261  		for ; yyj1 < yyrr1; yyj1++ {
 84262  			yyh1.ElemContainerState(yyj1)
 84263  			if r.TryDecodeAsNil() {
 84264  				if yyv1[yyj1] != nil {
 84265  					*yyv1[yyj1] = NodeServerInfo{}
 84266  				}
 84267  			} else {
 84268  				if yyv1[yyj1] == nil {
 84269  					yyv1[yyj1] = new(NodeServerInfo)
 84270  				}
 84271  				yyw2 := yyv1[yyj1]
 84272  				yyw2.CodecDecodeSelf(d)
 84273  			}
 84274  
 84275  		}
 84276  		if yyrt1 {
 84277  			for ; yyj1 < yyl1; yyj1++ {
 84278  				yyv1 = append(yyv1, nil)
 84279  				yyh1.ElemContainerState(yyj1)
 84280  				if r.TryDecodeAsNil() {
 84281  					if yyv1[yyj1] != nil {
 84282  						*yyv1[yyj1] = NodeServerInfo{}
 84283  					}
 84284  				} else {
 84285  					if yyv1[yyj1] == nil {
 84286  						yyv1[yyj1] = new(NodeServerInfo)
 84287  					}
 84288  					yyw3 := yyv1[yyj1]
 84289  					yyw3.CodecDecodeSelf(d)
 84290  				}
 84291  
 84292  			}
 84293  		}
 84294  
 84295  	} else {
 84296  		yyj1 := 0
 84297  		for ; !r.CheckBreak(); yyj1++ {
 84298  
 84299  			if yyj1 >= len(yyv1) {
 84300  				yyv1 = append(yyv1, nil) // var yyz1 *NodeServerInfo
 84301  				yyc1 = true
 84302  			}
 84303  			yyh1.ElemContainerState(yyj1)
 84304  			if yyj1 < len(yyv1) {
 84305  				if r.TryDecodeAsNil() {
 84306  					if yyv1[yyj1] != nil {
 84307  						*yyv1[yyj1] = NodeServerInfo{}
 84308  					}
 84309  				} else {
 84310  					if yyv1[yyj1] == nil {
 84311  						yyv1[yyj1] = new(NodeServerInfo)
 84312  					}
 84313  					yyw4 := yyv1[yyj1]
 84314  					yyw4.CodecDecodeSelf(d)
 84315  				}
 84316  
 84317  			} else {
 84318  				z.DecSwallow()
 84319  			}
 84320  
 84321  		}
 84322  		if yyj1 < len(yyv1) {
 84323  			yyv1 = yyv1[:yyj1]
 84324  			yyc1 = true
 84325  		} else if yyj1 == 0 && yyv1 == nil {
 84326  			yyv1 = []*NodeServerInfo{}
 84327  			yyc1 = true
 84328  		}
 84329  	}
 84330  	yyh1.End()
 84331  	if yyc1 {
 84332  		*v = yyv1
 84333  	}
 84334  }
 84335  
 84336  func (x codecSelfer100) encSlicePtrtoNodeListStub(v []*NodeListStub, e *codec1978.Encoder) {
 84337  	var h codecSelfer100
 84338  	z, r := codec1978.GenHelperEncoder(e)
 84339  	_, _, _ = h, z, r
 84340  	r.EncodeArrayStart(len(v))
 84341  	for _, yyv1 := range v {
 84342  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 84343  		if yyv1 == nil {
 84344  			r.EncodeNil()
 84345  		} else {
 84346  			yyv1.CodecEncodeSelf(e)
 84347  		}
 84348  	}
 84349  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 84350  }
 84351  
 84352  func (x codecSelfer100) decSlicePtrtoNodeListStub(v *[]*NodeListStub, d *codec1978.Decoder) {
 84353  	var h codecSelfer100
 84354  	z, r := codec1978.GenHelperDecoder(d)
 84355  	_, _, _ = h, z, r
 84356  
 84357  	yyv1 := *v
 84358  	yyh1, yyl1 := z.DecSliceHelperStart()
 84359  	var yyc1 bool
 84360  	_ = yyc1
 84361  	if yyl1 == 0 {
 84362  		if yyv1 == nil {
 84363  			yyv1 = []*NodeListStub{}
 84364  			yyc1 = true
 84365  		} else if len(yyv1) != 0 {
 84366  			yyv1 = yyv1[:0]
 84367  			yyc1 = true
 84368  		}
 84369  	} else if yyl1 > 0 {
 84370  		var yyrr1, yyrl1 int
 84371  		var yyrt1 bool
 84372  		_, _ = yyrl1, yyrt1
 84373  		yyrr1 = yyl1 // len(yyv1)
 84374  		if yyl1 > cap(yyv1) {
 84375  
 84376  			yyrg1 := len(yyv1) > 0
 84377  			yyv21 := yyv1
 84378  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 84379  			if yyrt1 {
 84380  				if yyrl1 <= cap(yyv1) {
 84381  					yyv1 = yyv1[:yyrl1]
 84382  				} else {
 84383  					yyv1 = make([]*NodeListStub, yyrl1)
 84384  				}
 84385  			} else {
 84386  				yyv1 = make([]*NodeListStub, yyrl1)
 84387  			}
 84388  			yyc1 = true
 84389  			yyrr1 = len(yyv1)
 84390  			if yyrg1 {
 84391  				copy(yyv1, yyv21)
 84392  			}
 84393  		} else if yyl1 != len(yyv1) {
 84394  			yyv1 = yyv1[:yyl1]
 84395  			yyc1 = true
 84396  		}
 84397  		yyj1 := 0
 84398  		for ; yyj1 < yyrr1; yyj1++ {
 84399  			yyh1.ElemContainerState(yyj1)
 84400  			if r.TryDecodeAsNil() {
 84401  				if yyv1[yyj1] != nil {
 84402  					*yyv1[yyj1] = NodeListStub{}
 84403  				}
 84404  			} else {
 84405  				if yyv1[yyj1] == nil {
 84406  					yyv1[yyj1] = new(NodeListStub)
 84407  				}
 84408  				yyw2 := yyv1[yyj1]
 84409  				yyw2.CodecDecodeSelf(d)
 84410  			}
 84411  
 84412  		}
 84413  		if yyrt1 {
 84414  			for ; yyj1 < yyl1; yyj1++ {
 84415  				yyv1 = append(yyv1, nil)
 84416  				yyh1.ElemContainerState(yyj1)
 84417  				if r.TryDecodeAsNil() {
 84418  					if yyv1[yyj1] != nil {
 84419  						*yyv1[yyj1] = NodeListStub{}
 84420  					}
 84421  				} else {
 84422  					if yyv1[yyj1] == nil {
 84423  						yyv1[yyj1] = new(NodeListStub)
 84424  					}
 84425  					yyw3 := yyv1[yyj1]
 84426  					yyw3.CodecDecodeSelf(d)
 84427  				}
 84428  
 84429  			}
 84430  		}
 84431  
 84432  	} else {
 84433  		yyj1 := 0
 84434  		for ; !r.CheckBreak(); yyj1++ {
 84435  
 84436  			if yyj1 >= len(yyv1) {
 84437  				yyv1 = append(yyv1, nil) // var yyz1 *NodeListStub
 84438  				yyc1 = true
 84439  			}
 84440  			yyh1.ElemContainerState(yyj1)
 84441  			if yyj1 < len(yyv1) {
 84442  				if r.TryDecodeAsNil() {
 84443  					if yyv1[yyj1] != nil {
 84444  						*yyv1[yyj1] = NodeListStub{}
 84445  					}
 84446  				} else {
 84447  					if yyv1[yyj1] == nil {
 84448  						yyv1[yyj1] = new(NodeListStub)
 84449  					}
 84450  					yyw4 := yyv1[yyj1]
 84451  					yyw4.CodecDecodeSelf(d)
 84452  				}
 84453  
 84454  			} else {
 84455  				z.DecSwallow()
 84456  			}
 84457  
 84458  		}
 84459  		if yyj1 < len(yyv1) {
 84460  			yyv1 = yyv1[:yyj1]
 84461  			yyc1 = true
 84462  		} else if yyj1 == 0 && yyv1 == nil {
 84463  			yyv1 = []*NodeListStub{}
 84464  			yyc1 = true
 84465  		}
 84466  	}
 84467  	yyh1.End()
 84468  	if yyc1 {
 84469  		*v = yyv1
 84470  	}
 84471  }
 84472  
 84473  func (x codecSelfer100) encSlicePtrtoJobListStub(v []*JobListStub, e *codec1978.Encoder) {
 84474  	var h codecSelfer100
 84475  	z, r := codec1978.GenHelperEncoder(e)
 84476  	_, _, _ = h, z, r
 84477  	r.EncodeArrayStart(len(v))
 84478  	for _, yyv1 := range v {
 84479  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 84480  		if yyv1 == nil {
 84481  			r.EncodeNil()
 84482  		} else {
 84483  			yyv1.CodecEncodeSelf(e)
 84484  		}
 84485  	}
 84486  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 84487  }
 84488  
 84489  func (x codecSelfer100) decSlicePtrtoJobListStub(v *[]*JobListStub, d *codec1978.Decoder) {
 84490  	var h codecSelfer100
 84491  	z, r := codec1978.GenHelperDecoder(d)
 84492  	_, _, _ = h, z, r
 84493  
 84494  	yyv1 := *v
 84495  	yyh1, yyl1 := z.DecSliceHelperStart()
 84496  	var yyc1 bool
 84497  	_ = yyc1
 84498  	if yyl1 == 0 {
 84499  		if yyv1 == nil {
 84500  			yyv1 = []*JobListStub{}
 84501  			yyc1 = true
 84502  		} else if len(yyv1) != 0 {
 84503  			yyv1 = yyv1[:0]
 84504  			yyc1 = true
 84505  		}
 84506  	} else if yyl1 > 0 {
 84507  		var yyrr1, yyrl1 int
 84508  		var yyrt1 bool
 84509  		_, _ = yyrl1, yyrt1
 84510  		yyrr1 = yyl1 // len(yyv1)
 84511  		if yyl1 > cap(yyv1) {
 84512  
 84513  			yyrg1 := len(yyv1) > 0
 84514  			yyv21 := yyv1
 84515  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 84516  			if yyrt1 {
 84517  				if yyrl1 <= cap(yyv1) {
 84518  					yyv1 = yyv1[:yyrl1]
 84519  				} else {
 84520  					yyv1 = make([]*JobListStub, yyrl1)
 84521  				}
 84522  			} else {
 84523  				yyv1 = make([]*JobListStub, yyrl1)
 84524  			}
 84525  			yyc1 = true
 84526  			yyrr1 = len(yyv1)
 84527  			if yyrg1 {
 84528  				copy(yyv1, yyv21)
 84529  			}
 84530  		} else if yyl1 != len(yyv1) {
 84531  			yyv1 = yyv1[:yyl1]
 84532  			yyc1 = true
 84533  		}
 84534  		yyj1 := 0
 84535  		for ; yyj1 < yyrr1; yyj1++ {
 84536  			yyh1.ElemContainerState(yyj1)
 84537  			if r.TryDecodeAsNil() {
 84538  				if yyv1[yyj1] != nil {
 84539  					*yyv1[yyj1] = JobListStub{}
 84540  				}
 84541  			} else {
 84542  				if yyv1[yyj1] == nil {
 84543  					yyv1[yyj1] = new(JobListStub)
 84544  				}
 84545  				yyw2 := yyv1[yyj1]
 84546  				yyw2.CodecDecodeSelf(d)
 84547  			}
 84548  
 84549  		}
 84550  		if yyrt1 {
 84551  			for ; yyj1 < yyl1; yyj1++ {
 84552  				yyv1 = append(yyv1, nil)
 84553  				yyh1.ElemContainerState(yyj1)
 84554  				if r.TryDecodeAsNil() {
 84555  					if yyv1[yyj1] != nil {
 84556  						*yyv1[yyj1] = JobListStub{}
 84557  					}
 84558  				} else {
 84559  					if yyv1[yyj1] == nil {
 84560  						yyv1[yyj1] = new(JobListStub)
 84561  					}
 84562  					yyw3 := yyv1[yyj1]
 84563  					yyw3.CodecDecodeSelf(d)
 84564  				}
 84565  
 84566  			}
 84567  		}
 84568  
 84569  	} else {
 84570  		yyj1 := 0
 84571  		for ; !r.CheckBreak(); yyj1++ {
 84572  
 84573  			if yyj1 >= len(yyv1) {
 84574  				yyv1 = append(yyv1, nil) // var yyz1 *JobListStub
 84575  				yyc1 = true
 84576  			}
 84577  			yyh1.ElemContainerState(yyj1)
 84578  			if yyj1 < len(yyv1) {
 84579  				if r.TryDecodeAsNil() {
 84580  					if yyv1[yyj1] != nil {
 84581  						*yyv1[yyj1] = JobListStub{}
 84582  					}
 84583  				} else {
 84584  					if yyv1[yyj1] == nil {
 84585  						yyv1[yyj1] = new(JobListStub)
 84586  					}
 84587  					yyw4 := yyv1[yyj1]
 84588  					yyw4.CodecDecodeSelf(d)
 84589  				}
 84590  
 84591  			} else {
 84592  				z.DecSwallow()
 84593  			}
 84594  
 84595  		}
 84596  		if yyj1 < len(yyv1) {
 84597  			yyv1 = yyv1[:yyj1]
 84598  			yyc1 = true
 84599  		} else if yyj1 == 0 && yyv1 == nil {
 84600  			yyv1 = []*JobListStub{}
 84601  			yyc1 = true
 84602  		}
 84603  	}
 84604  	yyh1.End()
 84605  	if yyc1 {
 84606  		*v = yyv1
 84607  	}
 84608  }
 84609  
 84610  func (x codecSelfer100) encSlicePtrtoJob(v []*Job, e *codec1978.Encoder) {
 84611  	var h codecSelfer100
 84612  	z, r := codec1978.GenHelperEncoder(e)
 84613  	_, _, _ = h, z, r
 84614  	r.EncodeArrayStart(len(v))
 84615  	for _, yyv1 := range v {
 84616  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 84617  		if yyv1 == nil {
 84618  			r.EncodeNil()
 84619  		} else {
 84620  			yyv1.CodecEncodeSelf(e)
 84621  		}
 84622  	}
 84623  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 84624  }
 84625  
 84626  func (x codecSelfer100) decSlicePtrtoJob(v *[]*Job, d *codec1978.Decoder) {
 84627  	var h codecSelfer100
 84628  	z, r := codec1978.GenHelperDecoder(d)
 84629  	_, _, _ = h, z, r
 84630  
 84631  	yyv1 := *v
 84632  	yyh1, yyl1 := z.DecSliceHelperStart()
 84633  	var yyc1 bool
 84634  	_ = yyc1
 84635  	if yyl1 == 0 {
 84636  		if yyv1 == nil {
 84637  			yyv1 = []*Job{}
 84638  			yyc1 = true
 84639  		} else if len(yyv1) != 0 {
 84640  			yyv1 = yyv1[:0]
 84641  			yyc1 = true
 84642  		}
 84643  	} else if yyl1 > 0 {
 84644  		var yyrr1, yyrl1 int
 84645  		var yyrt1 bool
 84646  		_, _ = yyrl1, yyrt1
 84647  		yyrr1 = yyl1 // len(yyv1)
 84648  		if yyl1 > cap(yyv1) {
 84649  
 84650  			yyrg1 := len(yyv1) > 0
 84651  			yyv21 := yyv1
 84652  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 84653  			if yyrt1 {
 84654  				if yyrl1 <= cap(yyv1) {
 84655  					yyv1 = yyv1[:yyrl1]
 84656  				} else {
 84657  					yyv1 = make([]*Job, yyrl1)
 84658  				}
 84659  			} else {
 84660  				yyv1 = make([]*Job, yyrl1)
 84661  			}
 84662  			yyc1 = true
 84663  			yyrr1 = len(yyv1)
 84664  			if yyrg1 {
 84665  				copy(yyv1, yyv21)
 84666  			}
 84667  		} else if yyl1 != len(yyv1) {
 84668  			yyv1 = yyv1[:yyl1]
 84669  			yyc1 = true
 84670  		}
 84671  		yyj1 := 0
 84672  		for ; yyj1 < yyrr1; yyj1++ {
 84673  			yyh1.ElemContainerState(yyj1)
 84674  			if r.TryDecodeAsNil() {
 84675  				if yyv1[yyj1] != nil {
 84676  					*yyv1[yyj1] = Job{}
 84677  				}
 84678  			} else {
 84679  				if yyv1[yyj1] == nil {
 84680  					yyv1[yyj1] = new(Job)
 84681  				}
 84682  				yyw2 := yyv1[yyj1]
 84683  				yyw2.CodecDecodeSelf(d)
 84684  			}
 84685  
 84686  		}
 84687  		if yyrt1 {
 84688  			for ; yyj1 < yyl1; yyj1++ {
 84689  				yyv1 = append(yyv1, nil)
 84690  				yyh1.ElemContainerState(yyj1)
 84691  				if r.TryDecodeAsNil() {
 84692  					if yyv1[yyj1] != nil {
 84693  						*yyv1[yyj1] = Job{}
 84694  					}
 84695  				} else {
 84696  					if yyv1[yyj1] == nil {
 84697  						yyv1[yyj1] = new(Job)
 84698  					}
 84699  					yyw3 := yyv1[yyj1]
 84700  					yyw3.CodecDecodeSelf(d)
 84701  				}
 84702  
 84703  			}
 84704  		}
 84705  
 84706  	} else {
 84707  		yyj1 := 0
 84708  		for ; !r.CheckBreak(); yyj1++ {
 84709  
 84710  			if yyj1 >= len(yyv1) {
 84711  				yyv1 = append(yyv1, nil) // var yyz1 *Job
 84712  				yyc1 = true
 84713  			}
 84714  			yyh1.ElemContainerState(yyj1)
 84715  			if yyj1 < len(yyv1) {
 84716  				if r.TryDecodeAsNil() {
 84717  					if yyv1[yyj1] != nil {
 84718  						*yyv1[yyj1] = Job{}
 84719  					}
 84720  				} else {
 84721  					if yyv1[yyj1] == nil {
 84722  						yyv1[yyj1] = new(Job)
 84723  					}
 84724  					yyw4 := yyv1[yyj1]
 84725  					yyw4.CodecDecodeSelf(d)
 84726  				}
 84727  
 84728  			} else {
 84729  				z.DecSwallow()
 84730  			}
 84731  
 84732  		}
 84733  		if yyj1 < len(yyv1) {
 84734  			yyv1 = yyv1[:yyj1]
 84735  			yyc1 = true
 84736  		} else if yyj1 == 0 && yyv1 == nil {
 84737  			yyv1 = []*Job{}
 84738  			yyc1 = true
 84739  		}
 84740  	}
 84741  	yyh1.End()
 84742  	if yyc1 {
 84743  		*v = yyv1
 84744  	}
 84745  }
 84746  
 84747  func (x codecSelfer100) encSlicePtrtoJobDiff(v []*JobDiff, e *codec1978.Encoder) {
 84748  	var h codecSelfer100
 84749  	z, r := codec1978.GenHelperEncoder(e)
 84750  	_, _, _ = h, z, r
 84751  	r.EncodeArrayStart(len(v))
 84752  	for _, yyv1 := range v {
 84753  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 84754  		if yyv1 == nil {
 84755  			r.EncodeNil()
 84756  		} else {
 84757  			yym2 := z.EncBinary()
 84758  			_ = yym2
 84759  			if false {
 84760  			} else if z.HasExtensions() && z.EncExt(yyv1) {
 84761  			} else {
 84762  				z.EncFallback(yyv1)
 84763  			}
 84764  		}
 84765  	}
 84766  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 84767  }
 84768  
 84769  func (x codecSelfer100) decSlicePtrtoJobDiff(v *[]*JobDiff, d *codec1978.Decoder) {
 84770  	var h codecSelfer100
 84771  	z, r := codec1978.GenHelperDecoder(d)
 84772  	_, _, _ = h, z, r
 84773  
 84774  	yyv1 := *v
 84775  	yyh1, yyl1 := z.DecSliceHelperStart()
 84776  	var yyc1 bool
 84777  	_ = yyc1
 84778  	if yyl1 == 0 {
 84779  		if yyv1 == nil {
 84780  			yyv1 = []*JobDiff{}
 84781  			yyc1 = true
 84782  		} else if len(yyv1) != 0 {
 84783  			yyv1 = yyv1[:0]
 84784  			yyc1 = true
 84785  		}
 84786  	} else if yyl1 > 0 {
 84787  		var yyrr1, yyrl1 int
 84788  		var yyrt1 bool
 84789  		_, _ = yyrl1, yyrt1
 84790  		yyrr1 = yyl1 // len(yyv1)
 84791  		if yyl1 > cap(yyv1) {
 84792  
 84793  			yyrg1 := len(yyv1) > 0
 84794  			yyv21 := yyv1
 84795  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 84796  			if yyrt1 {
 84797  				if yyrl1 <= cap(yyv1) {
 84798  					yyv1 = yyv1[:yyrl1]
 84799  				} else {
 84800  					yyv1 = make([]*JobDiff, yyrl1)
 84801  				}
 84802  			} else {
 84803  				yyv1 = make([]*JobDiff, yyrl1)
 84804  			}
 84805  			yyc1 = true
 84806  			yyrr1 = len(yyv1)
 84807  			if yyrg1 {
 84808  				copy(yyv1, yyv21)
 84809  			}
 84810  		} else if yyl1 != len(yyv1) {
 84811  			yyv1 = yyv1[:yyl1]
 84812  			yyc1 = true
 84813  		}
 84814  		yyj1 := 0
 84815  		for ; yyj1 < yyrr1; yyj1++ {
 84816  			yyh1.ElemContainerState(yyj1)
 84817  			if r.TryDecodeAsNil() {
 84818  				if yyv1[yyj1] != nil {
 84819  					*yyv1[yyj1] = JobDiff{}
 84820  				}
 84821  			} else {
 84822  				if yyv1[yyj1] == nil {
 84823  					yyv1[yyj1] = new(JobDiff)
 84824  				}
 84825  				yyw2 := yyv1[yyj1]
 84826  				yym3 := z.DecBinary()
 84827  				_ = yym3
 84828  				if false {
 84829  				} else if z.HasExtensions() && z.DecExt(yyw2) {
 84830  				} else {
 84831  					z.DecFallback(yyw2, false)
 84832  				}
 84833  			}
 84834  
 84835  		}
 84836  		if yyrt1 {
 84837  			for ; yyj1 < yyl1; yyj1++ {
 84838  				yyv1 = append(yyv1, nil)
 84839  				yyh1.ElemContainerState(yyj1)
 84840  				if r.TryDecodeAsNil() {
 84841  					if yyv1[yyj1] != nil {
 84842  						*yyv1[yyj1] = JobDiff{}
 84843  					}
 84844  				} else {
 84845  					if yyv1[yyj1] == nil {
 84846  						yyv1[yyj1] = new(JobDiff)
 84847  					}
 84848  					yyw4 := yyv1[yyj1]
 84849  					yym5 := z.DecBinary()
 84850  					_ = yym5
 84851  					if false {
 84852  					} else if z.HasExtensions() && z.DecExt(yyw4) {
 84853  					} else {
 84854  						z.DecFallback(yyw4, false)
 84855  					}
 84856  				}
 84857  
 84858  			}
 84859  		}
 84860  
 84861  	} else {
 84862  		yyj1 := 0
 84863  		for ; !r.CheckBreak(); yyj1++ {
 84864  
 84865  			if yyj1 >= len(yyv1) {
 84866  				yyv1 = append(yyv1, nil) // var yyz1 *JobDiff
 84867  				yyc1 = true
 84868  			}
 84869  			yyh1.ElemContainerState(yyj1)
 84870  			if yyj1 < len(yyv1) {
 84871  				if r.TryDecodeAsNil() {
 84872  					if yyv1[yyj1] != nil {
 84873  						*yyv1[yyj1] = JobDiff{}
 84874  					}
 84875  				} else {
 84876  					if yyv1[yyj1] == nil {
 84877  						yyv1[yyj1] = new(JobDiff)
 84878  					}
 84879  					yyw6 := yyv1[yyj1]
 84880  					yym7 := z.DecBinary()
 84881  					_ = yym7
 84882  					if false {
 84883  					} else if z.HasExtensions() && z.DecExt(yyw6) {
 84884  					} else {
 84885  						z.DecFallback(yyw6, false)
 84886  					}
 84887  				}
 84888  
 84889  			} else {
 84890  				z.DecSwallow()
 84891  			}
 84892  
 84893  		}
 84894  		if yyj1 < len(yyv1) {
 84895  			yyv1 = yyv1[:yyj1]
 84896  			yyc1 = true
 84897  		} else if yyj1 == 0 && yyv1 == nil {
 84898  			yyv1 = []*JobDiff{}
 84899  			yyc1 = true
 84900  		}
 84901  	}
 84902  	yyh1.End()
 84903  	if yyc1 {
 84904  		*v = yyv1
 84905  	}
 84906  }
 84907  
 84908  func (x codecSelfer100) encMapstringPtrtoAllocMetric(v map[string]*AllocMetric, e *codec1978.Encoder) {
 84909  	var h codecSelfer100
 84910  	z, r := codec1978.GenHelperEncoder(e)
 84911  	_, _, _ = h, z, r
 84912  	r.EncodeMapStart(len(v))
 84913  	for yyk1, yyv1 := range v {
 84914  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 84915  		yym2 := z.EncBinary()
 84916  		_ = yym2
 84917  		if false {
 84918  		} else {
 84919  			r.EncodeString(codecSelferC_UTF8100, string(yyk1))
 84920  		}
 84921  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 84922  		if yyv1 == nil {
 84923  			r.EncodeNil()
 84924  		} else {
 84925  			yyv1.CodecEncodeSelf(e)
 84926  		}
 84927  	}
 84928  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 84929  }
 84930  
 84931  func (x codecSelfer100) decMapstringPtrtoAllocMetric(v *map[string]*AllocMetric, d *codec1978.Decoder) {
 84932  	var h codecSelfer100
 84933  	z, r := codec1978.GenHelperDecoder(d)
 84934  	_, _, _ = h, z, r
 84935  
 84936  	yyv1 := *v
 84937  	yyl1 := r.ReadMapStart()
 84938  	yybh1 := z.DecBasicHandle()
 84939  	if yyv1 == nil {
 84940  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 24)
 84941  		yyv1 = make(map[string]*AllocMetric, yyrl1)
 84942  		*v = yyv1
 84943  	}
 84944  	var yymk1 string
 84945  	var yymv1 *AllocMetric
 84946  	var yymg1, yyms1, yymok1 bool
 84947  	if yybh1.MapValueReset {
 84948  		yymg1 = true
 84949  	}
 84950  	if yyl1 > 0 {
 84951  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 84952  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 84953  			if r.TryDecodeAsNil() {
 84954  				yymk1 = ""
 84955  			} else {
 84956  				yyv2 := &yymk1
 84957  				yym3 := z.DecBinary()
 84958  				_ = yym3
 84959  				if false {
 84960  				} else {
 84961  					*((*string)(yyv2)) = r.DecodeString()
 84962  				}
 84963  			}
 84964  
 84965  			yyms1 = true
 84966  			if yymg1 {
 84967  				yymv1, yymok1 = yyv1[yymk1]
 84968  				if yymok1 {
 84969  					yyms1 = false
 84970  				}
 84971  			} else {
 84972  				yymv1 = nil
 84973  			}
 84974  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 84975  			if r.TryDecodeAsNil() {
 84976  				if yymv1 != nil {
 84977  					*yymv1 = AllocMetric{}
 84978  				}
 84979  			} else {
 84980  				if yymv1 == nil {
 84981  					yymv1 = new(AllocMetric)
 84982  				}
 84983  				yymv1.CodecDecodeSelf(d)
 84984  			}
 84985  
 84986  			if yyms1 && yyv1 != nil {
 84987  				yyv1[yymk1] = yymv1
 84988  			}
 84989  		}
 84990  	} else if yyl1 < 0 {
 84991  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 84992  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 84993  			if r.TryDecodeAsNil() {
 84994  				yymk1 = ""
 84995  			} else {
 84996  				yyv5 := &yymk1
 84997  				yym6 := z.DecBinary()
 84998  				_ = yym6
 84999  				if false {
 85000  				} else {
 85001  					*((*string)(yyv5)) = r.DecodeString()
 85002  				}
 85003  			}
 85004  
 85005  			yyms1 = true
 85006  			if yymg1 {
 85007  				yymv1, yymok1 = yyv1[yymk1]
 85008  				if yymok1 {
 85009  					yyms1 = false
 85010  				}
 85011  			} else {
 85012  				yymv1 = nil
 85013  			}
 85014  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 85015  			if r.TryDecodeAsNil() {
 85016  				if yymv1 != nil {
 85017  					*yymv1 = AllocMetric{}
 85018  				}
 85019  			} else {
 85020  				if yymv1 == nil {
 85021  					yymv1 = new(AllocMetric)
 85022  				}
 85023  				yymv1.CodecDecodeSelf(d)
 85024  			}
 85025  
 85026  			if yyms1 && yyv1 != nil {
 85027  				yyv1[yymk1] = yymv1
 85028  			}
 85029  		}
 85030  	} // else len==0: TODO: Should we clear map entries?
 85031  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 85032  }
 85033  
 85034  func (x codecSelfer100) encSlicePtrtoAllocListStub(v []*AllocListStub, e *codec1978.Encoder) {
 85035  	var h codecSelfer100
 85036  	z, r := codec1978.GenHelperEncoder(e)
 85037  	_, _, _ = h, z, r
 85038  	r.EncodeArrayStart(len(v))
 85039  	for _, yyv1 := range v {
 85040  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 85041  		if yyv1 == nil {
 85042  			r.EncodeNil()
 85043  		} else {
 85044  			yyv1.CodecEncodeSelf(e)
 85045  		}
 85046  	}
 85047  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 85048  }
 85049  
 85050  func (x codecSelfer100) decSlicePtrtoAllocListStub(v *[]*AllocListStub, d *codec1978.Decoder) {
 85051  	var h codecSelfer100
 85052  	z, r := codec1978.GenHelperDecoder(d)
 85053  	_, _, _ = h, z, r
 85054  
 85055  	yyv1 := *v
 85056  	yyh1, yyl1 := z.DecSliceHelperStart()
 85057  	var yyc1 bool
 85058  	_ = yyc1
 85059  	if yyl1 == 0 {
 85060  		if yyv1 == nil {
 85061  			yyv1 = []*AllocListStub{}
 85062  			yyc1 = true
 85063  		} else if len(yyv1) != 0 {
 85064  			yyv1 = yyv1[:0]
 85065  			yyc1 = true
 85066  		}
 85067  	} else if yyl1 > 0 {
 85068  		var yyrr1, yyrl1 int
 85069  		var yyrt1 bool
 85070  		_, _ = yyrl1, yyrt1
 85071  		yyrr1 = yyl1 // len(yyv1)
 85072  		if yyl1 > cap(yyv1) {
 85073  
 85074  			yyrg1 := len(yyv1) > 0
 85075  			yyv21 := yyv1
 85076  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 85077  			if yyrt1 {
 85078  				if yyrl1 <= cap(yyv1) {
 85079  					yyv1 = yyv1[:yyrl1]
 85080  				} else {
 85081  					yyv1 = make([]*AllocListStub, yyrl1)
 85082  				}
 85083  			} else {
 85084  				yyv1 = make([]*AllocListStub, yyrl1)
 85085  			}
 85086  			yyc1 = true
 85087  			yyrr1 = len(yyv1)
 85088  			if yyrg1 {
 85089  				copy(yyv1, yyv21)
 85090  			}
 85091  		} else if yyl1 != len(yyv1) {
 85092  			yyv1 = yyv1[:yyl1]
 85093  			yyc1 = true
 85094  		}
 85095  		yyj1 := 0
 85096  		for ; yyj1 < yyrr1; yyj1++ {
 85097  			yyh1.ElemContainerState(yyj1)
 85098  			if r.TryDecodeAsNil() {
 85099  				if yyv1[yyj1] != nil {
 85100  					*yyv1[yyj1] = AllocListStub{}
 85101  				}
 85102  			} else {
 85103  				if yyv1[yyj1] == nil {
 85104  					yyv1[yyj1] = new(AllocListStub)
 85105  				}
 85106  				yyw2 := yyv1[yyj1]
 85107  				yyw2.CodecDecodeSelf(d)
 85108  			}
 85109  
 85110  		}
 85111  		if yyrt1 {
 85112  			for ; yyj1 < yyl1; yyj1++ {
 85113  				yyv1 = append(yyv1, nil)
 85114  				yyh1.ElemContainerState(yyj1)
 85115  				if r.TryDecodeAsNil() {
 85116  					if yyv1[yyj1] != nil {
 85117  						*yyv1[yyj1] = AllocListStub{}
 85118  					}
 85119  				} else {
 85120  					if yyv1[yyj1] == nil {
 85121  						yyv1[yyj1] = new(AllocListStub)
 85122  					}
 85123  					yyw3 := yyv1[yyj1]
 85124  					yyw3.CodecDecodeSelf(d)
 85125  				}
 85126  
 85127  			}
 85128  		}
 85129  
 85130  	} else {
 85131  		yyj1 := 0
 85132  		for ; !r.CheckBreak(); yyj1++ {
 85133  
 85134  			if yyj1 >= len(yyv1) {
 85135  				yyv1 = append(yyv1, nil) // var yyz1 *AllocListStub
 85136  				yyc1 = true
 85137  			}
 85138  			yyh1.ElemContainerState(yyj1)
 85139  			if yyj1 < len(yyv1) {
 85140  				if r.TryDecodeAsNil() {
 85141  					if yyv1[yyj1] != nil {
 85142  						*yyv1[yyj1] = AllocListStub{}
 85143  					}
 85144  				} else {
 85145  					if yyv1[yyj1] == nil {
 85146  						yyv1[yyj1] = new(AllocListStub)
 85147  					}
 85148  					yyw4 := yyv1[yyj1]
 85149  					yyw4.CodecDecodeSelf(d)
 85150  				}
 85151  
 85152  			} else {
 85153  				z.DecSwallow()
 85154  			}
 85155  
 85156  		}
 85157  		if yyj1 < len(yyv1) {
 85158  			yyv1 = yyv1[:yyj1]
 85159  			yyc1 = true
 85160  		} else if yyj1 == 0 && yyv1 == nil {
 85161  			yyv1 = []*AllocListStub{}
 85162  			yyc1 = true
 85163  		}
 85164  	}
 85165  	yyh1.End()
 85166  	if yyc1 {
 85167  		*v = yyv1
 85168  	}
 85169  }
 85170  
 85171  func (x codecSelfer100) encSlicePtrtoDeployment(v []*Deployment, e *codec1978.Encoder) {
 85172  	var h codecSelfer100
 85173  	z, r := codec1978.GenHelperEncoder(e)
 85174  	_, _, _ = h, z, r
 85175  	r.EncodeArrayStart(len(v))
 85176  	for _, yyv1 := range v {
 85177  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 85178  		if yyv1 == nil {
 85179  			r.EncodeNil()
 85180  		} else {
 85181  			yyv1.CodecEncodeSelf(e)
 85182  		}
 85183  	}
 85184  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 85185  }
 85186  
 85187  func (x codecSelfer100) decSlicePtrtoDeployment(v *[]*Deployment, d *codec1978.Decoder) {
 85188  	var h codecSelfer100
 85189  	z, r := codec1978.GenHelperDecoder(d)
 85190  	_, _, _ = h, z, r
 85191  
 85192  	yyv1 := *v
 85193  	yyh1, yyl1 := z.DecSliceHelperStart()
 85194  	var yyc1 bool
 85195  	_ = yyc1
 85196  	if yyl1 == 0 {
 85197  		if yyv1 == nil {
 85198  			yyv1 = []*Deployment{}
 85199  			yyc1 = true
 85200  		} else if len(yyv1) != 0 {
 85201  			yyv1 = yyv1[:0]
 85202  			yyc1 = true
 85203  		}
 85204  	} else if yyl1 > 0 {
 85205  		var yyrr1, yyrl1 int
 85206  		var yyrt1 bool
 85207  		_, _ = yyrl1, yyrt1
 85208  		yyrr1 = yyl1 // len(yyv1)
 85209  		if yyl1 > cap(yyv1) {
 85210  
 85211  			yyrg1 := len(yyv1) > 0
 85212  			yyv21 := yyv1
 85213  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 85214  			if yyrt1 {
 85215  				if yyrl1 <= cap(yyv1) {
 85216  					yyv1 = yyv1[:yyrl1]
 85217  				} else {
 85218  					yyv1 = make([]*Deployment, yyrl1)
 85219  				}
 85220  			} else {
 85221  				yyv1 = make([]*Deployment, yyrl1)
 85222  			}
 85223  			yyc1 = true
 85224  			yyrr1 = len(yyv1)
 85225  			if yyrg1 {
 85226  				copy(yyv1, yyv21)
 85227  			}
 85228  		} else if yyl1 != len(yyv1) {
 85229  			yyv1 = yyv1[:yyl1]
 85230  			yyc1 = true
 85231  		}
 85232  		yyj1 := 0
 85233  		for ; yyj1 < yyrr1; yyj1++ {
 85234  			yyh1.ElemContainerState(yyj1)
 85235  			if r.TryDecodeAsNil() {
 85236  				if yyv1[yyj1] != nil {
 85237  					*yyv1[yyj1] = Deployment{}
 85238  				}
 85239  			} else {
 85240  				if yyv1[yyj1] == nil {
 85241  					yyv1[yyj1] = new(Deployment)
 85242  				}
 85243  				yyw2 := yyv1[yyj1]
 85244  				yyw2.CodecDecodeSelf(d)
 85245  			}
 85246  
 85247  		}
 85248  		if yyrt1 {
 85249  			for ; yyj1 < yyl1; yyj1++ {
 85250  				yyv1 = append(yyv1, nil)
 85251  				yyh1.ElemContainerState(yyj1)
 85252  				if r.TryDecodeAsNil() {
 85253  					if yyv1[yyj1] != nil {
 85254  						*yyv1[yyj1] = Deployment{}
 85255  					}
 85256  				} else {
 85257  					if yyv1[yyj1] == nil {
 85258  						yyv1[yyj1] = new(Deployment)
 85259  					}
 85260  					yyw3 := yyv1[yyj1]
 85261  					yyw3.CodecDecodeSelf(d)
 85262  				}
 85263  
 85264  			}
 85265  		}
 85266  
 85267  	} else {
 85268  		yyj1 := 0
 85269  		for ; !r.CheckBreak(); yyj1++ {
 85270  
 85271  			if yyj1 >= len(yyv1) {
 85272  				yyv1 = append(yyv1, nil) // var yyz1 *Deployment
 85273  				yyc1 = true
 85274  			}
 85275  			yyh1.ElemContainerState(yyj1)
 85276  			if yyj1 < len(yyv1) {
 85277  				if r.TryDecodeAsNil() {
 85278  					if yyv1[yyj1] != nil {
 85279  						*yyv1[yyj1] = Deployment{}
 85280  					}
 85281  				} else {
 85282  					if yyv1[yyj1] == nil {
 85283  						yyv1[yyj1] = new(Deployment)
 85284  					}
 85285  					yyw4 := yyv1[yyj1]
 85286  					yyw4.CodecDecodeSelf(d)
 85287  				}
 85288  
 85289  			} else {
 85290  				z.DecSwallow()
 85291  			}
 85292  
 85293  		}
 85294  		if yyj1 < len(yyv1) {
 85295  			yyv1 = yyv1[:yyj1]
 85296  			yyc1 = true
 85297  		} else if yyj1 == 0 && yyv1 == nil {
 85298  			yyv1 = []*Deployment{}
 85299  			yyc1 = true
 85300  		}
 85301  	}
 85302  	yyh1.End()
 85303  	if yyc1 {
 85304  		*v = yyv1
 85305  	}
 85306  }
 85307  
 85308  func (x codecSelfer100) encMapstringSlicePtrtoNodeEvent(v map[string][]*NodeEvent, e *codec1978.Encoder) {
 85309  	var h codecSelfer100
 85310  	z, r := codec1978.GenHelperEncoder(e)
 85311  	_, _, _ = h, z, r
 85312  	r.EncodeMapStart(len(v))
 85313  	for yyk1, yyv1 := range v {
 85314  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 85315  		yym2 := z.EncBinary()
 85316  		_ = yym2
 85317  		if false {
 85318  		} else {
 85319  			r.EncodeString(codecSelferC_UTF8100, string(yyk1))
 85320  		}
 85321  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 85322  		if yyv1 == nil {
 85323  			r.EncodeNil()
 85324  		} else {
 85325  			yym3 := z.EncBinary()
 85326  			_ = yym3
 85327  			if false {
 85328  			} else {
 85329  				h.encSlicePtrtoNodeEvent(([]*NodeEvent)(yyv1), e)
 85330  			}
 85331  		}
 85332  	}
 85333  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 85334  }
 85335  
 85336  func (x codecSelfer100) decMapstringSlicePtrtoNodeEvent(v *map[string][]*NodeEvent, d *codec1978.Decoder) {
 85337  	var h codecSelfer100
 85338  	z, r := codec1978.GenHelperDecoder(d)
 85339  	_, _, _ = h, z, r
 85340  
 85341  	yyv1 := *v
 85342  	yyl1 := r.ReadMapStart()
 85343  	yybh1 := z.DecBasicHandle()
 85344  	if yyv1 == nil {
 85345  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 40)
 85346  		yyv1 = make(map[string][]*NodeEvent, yyrl1)
 85347  		*v = yyv1
 85348  	}
 85349  	var yymk1 string
 85350  	var yymv1 []*NodeEvent
 85351  	var yymg1 bool
 85352  	if yybh1.MapValueReset {
 85353  		yymg1 = true
 85354  	}
 85355  	if yyl1 > 0 {
 85356  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 85357  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 85358  			if r.TryDecodeAsNil() {
 85359  				yymk1 = ""
 85360  			} else {
 85361  				yyv2 := &yymk1
 85362  				yym3 := z.DecBinary()
 85363  				_ = yym3
 85364  				if false {
 85365  				} else {
 85366  					*((*string)(yyv2)) = r.DecodeString()
 85367  				}
 85368  			}
 85369  
 85370  			if yymg1 {
 85371  				yymv1 = yyv1[yymk1]
 85372  			} else {
 85373  				yymv1 = nil
 85374  			}
 85375  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 85376  			if r.TryDecodeAsNil() {
 85377  				yymv1 = nil
 85378  			} else {
 85379  				yyv4 := &yymv1
 85380  				yym5 := z.DecBinary()
 85381  				_ = yym5
 85382  				if false {
 85383  				} else {
 85384  					h.decSlicePtrtoNodeEvent((*[]*NodeEvent)(yyv4), d)
 85385  				}
 85386  			}
 85387  
 85388  			if yyv1 != nil {
 85389  				yyv1[yymk1] = yymv1
 85390  			}
 85391  		}
 85392  	} else if yyl1 < 0 {
 85393  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 85394  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 85395  			if r.TryDecodeAsNil() {
 85396  				yymk1 = ""
 85397  			} else {
 85398  				yyv6 := &yymk1
 85399  				yym7 := z.DecBinary()
 85400  				_ = yym7
 85401  				if false {
 85402  				} else {
 85403  					*((*string)(yyv6)) = r.DecodeString()
 85404  				}
 85405  			}
 85406  
 85407  			if yymg1 {
 85408  				yymv1 = yyv1[yymk1]
 85409  			} else {
 85410  				yymv1 = nil
 85411  			}
 85412  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 85413  			if r.TryDecodeAsNil() {
 85414  				yymv1 = nil
 85415  			} else {
 85416  				yyv8 := &yymv1
 85417  				yym9 := z.DecBinary()
 85418  				_ = yym9
 85419  				if false {
 85420  				} else {
 85421  					h.decSlicePtrtoNodeEvent((*[]*NodeEvent)(yyv8), d)
 85422  				}
 85423  			}
 85424  
 85425  			if yyv1 != nil {
 85426  				yyv1[yymk1] = yymv1
 85427  			}
 85428  		}
 85429  	} // else len==0: TODO: Should we clear map entries?
 85430  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 85431  }
 85432  
 85433  func (x codecSelfer100) encSlicePtrtoNodeEvent(v []*NodeEvent, e *codec1978.Encoder) {
 85434  	var h codecSelfer100
 85435  	z, r := codec1978.GenHelperEncoder(e)
 85436  	_, _, _ = h, z, r
 85437  	r.EncodeArrayStart(len(v))
 85438  	for _, yyv1 := range v {
 85439  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 85440  		if yyv1 == nil {
 85441  			r.EncodeNil()
 85442  		} else {
 85443  			yyv1.CodecEncodeSelf(e)
 85444  		}
 85445  	}
 85446  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 85447  }
 85448  
 85449  func (x codecSelfer100) decSlicePtrtoNodeEvent(v *[]*NodeEvent, d *codec1978.Decoder) {
 85450  	var h codecSelfer100
 85451  	z, r := codec1978.GenHelperDecoder(d)
 85452  	_, _, _ = h, z, r
 85453  
 85454  	yyv1 := *v
 85455  	yyh1, yyl1 := z.DecSliceHelperStart()
 85456  	var yyc1 bool
 85457  	_ = yyc1
 85458  	if yyl1 == 0 {
 85459  		if yyv1 == nil {
 85460  			yyv1 = []*NodeEvent{}
 85461  			yyc1 = true
 85462  		} else if len(yyv1) != 0 {
 85463  			yyv1 = yyv1[:0]
 85464  			yyc1 = true
 85465  		}
 85466  	} else if yyl1 > 0 {
 85467  		var yyrr1, yyrl1 int
 85468  		var yyrt1 bool
 85469  		_, _ = yyrl1, yyrt1
 85470  		yyrr1 = yyl1 // len(yyv1)
 85471  		if yyl1 > cap(yyv1) {
 85472  
 85473  			yyrg1 := len(yyv1) > 0
 85474  			yyv21 := yyv1
 85475  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 85476  			if yyrt1 {
 85477  				if yyrl1 <= cap(yyv1) {
 85478  					yyv1 = yyv1[:yyrl1]
 85479  				} else {
 85480  					yyv1 = make([]*NodeEvent, yyrl1)
 85481  				}
 85482  			} else {
 85483  				yyv1 = make([]*NodeEvent, yyrl1)
 85484  			}
 85485  			yyc1 = true
 85486  			yyrr1 = len(yyv1)
 85487  			if yyrg1 {
 85488  				copy(yyv1, yyv21)
 85489  			}
 85490  		} else if yyl1 != len(yyv1) {
 85491  			yyv1 = yyv1[:yyl1]
 85492  			yyc1 = true
 85493  		}
 85494  		yyj1 := 0
 85495  		for ; yyj1 < yyrr1; yyj1++ {
 85496  			yyh1.ElemContainerState(yyj1)
 85497  			if r.TryDecodeAsNil() {
 85498  				if yyv1[yyj1] != nil {
 85499  					*yyv1[yyj1] = NodeEvent{}
 85500  				}
 85501  			} else {
 85502  				if yyv1[yyj1] == nil {
 85503  					yyv1[yyj1] = new(NodeEvent)
 85504  				}
 85505  				yyw2 := yyv1[yyj1]
 85506  				yyw2.CodecDecodeSelf(d)
 85507  			}
 85508  
 85509  		}
 85510  		if yyrt1 {
 85511  			for ; yyj1 < yyl1; yyj1++ {
 85512  				yyv1 = append(yyv1, nil)
 85513  				yyh1.ElemContainerState(yyj1)
 85514  				if r.TryDecodeAsNil() {
 85515  					if yyv1[yyj1] != nil {
 85516  						*yyv1[yyj1] = NodeEvent{}
 85517  					}
 85518  				} else {
 85519  					if yyv1[yyj1] == nil {
 85520  						yyv1[yyj1] = new(NodeEvent)
 85521  					}
 85522  					yyw3 := yyv1[yyj1]
 85523  					yyw3.CodecDecodeSelf(d)
 85524  				}
 85525  
 85526  			}
 85527  		}
 85528  
 85529  	} else {
 85530  		yyj1 := 0
 85531  		for ; !r.CheckBreak(); yyj1++ {
 85532  
 85533  			if yyj1 >= len(yyv1) {
 85534  				yyv1 = append(yyv1, nil) // var yyz1 *NodeEvent
 85535  				yyc1 = true
 85536  			}
 85537  			yyh1.ElemContainerState(yyj1)
 85538  			if yyj1 < len(yyv1) {
 85539  				if r.TryDecodeAsNil() {
 85540  					if yyv1[yyj1] != nil {
 85541  						*yyv1[yyj1] = NodeEvent{}
 85542  					}
 85543  				} else {
 85544  					if yyv1[yyj1] == nil {
 85545  						yyv1[yyj1] = new(NodeEvent)
 85546  					}
 85547  					yyw4 := yyv1[yyj1]
 85548  					yyw4.CodecDecodeSelf(d)
 85549  				}
 85550  
 85551  			} else {
 85552  				z.DecSwallow()
 85553  			}
 85554  
 85555  		}
 85556  		if yyj1 < len(yyv1) {
 85557  			yyv1 = yyv1[:yyj1]
 85558  			yyc1 = true
 85559  		} else if yyj1 == 0 && yyv1 == nil {
 85560  			yyv1 = []*NodeEvent{}
 85561  			yyc1 = true
 85562  		}
 85563  	}
 85564  	yyh1.End()
 85565  	if yyc1 {
 85566  		*v = yyv1
 85567  	}
 85568  }
 85569  
 85570  func (x codecSelfer100) encMapstringPtrtoDriverInfo(v map[string]*DriverInfo, e *codec1978.Encoder) {
 85571  	var h codecSelfer100
 85572  	z, r := codec1978.GenHelperEncoder(e)
 85573  	_, _, _ = h, z, r
 85574  	r.EncodeMapStart(len(v))
 85575  	for yyk1, yyv1 := range v {
 85576  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 85577  		yym2 := z.EncBinary()
 85578  		_ = yym2
 85579  		if false {
 85580  		} else {
 85581  			r.EncodeString(codecSelferC_UTF8100, string(yyk1))
 85582  		}
 85583  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 85584  		if yyv1 == nil {
 85585  			r.EncodeNil()
 85586  		} else {
 85587  			yym3 := z.EncBinary()
 85588  			_ = yym3
 85589  			if false {
 85590  			} else if z.HasExtensions() && z.EncExt(yyv1) {
 85591  			} else {
 85592  				z.EncFallback(yyv1)
 85593  			}
 85594  		}
 85595  	}
 85596  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 85597  }
 85598  
 85599  func (x codecSelfer100) decMapstringPtrtoDriverInfo(v *map[string]*DriverInfo, d *codec1978.Decoder) {
 85600  	var h codecSelfer100
 85601  	z, r := codec1978.GenHelperDecoder(d)
 85602  	_, _, _ = h, z, r
 85603  
 85604  	yyv1 := *v
 85605  	yyl1 := r.ReadMapStart()
 85606  	yybh1 := z.DecBasicHandle()
 85607  	if yyv1 == nil {
 85608  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 24)
 85609  		yyv1 = make(map[string]*DriverInfo, yyrl1)
 85610  		*v = yyv1
 85611  	}
 85612  	var yymk1 string
 85613  	var yymv1 *DriverInfo
 85614  	var yymg1, yyms1, yymok1 bool
 85615  	if yybh1.MapValueReset {
 85616  		yymg1 = true
 85617  	}
 85618  	if yyl1 > 0 {
 85619  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 85620  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 85621  			if r.TryDecodeAsNil() {
 85622  				yymk1 = ""
 85623  			} else {
 85624  				yyv2 := &yymk1
 85625  				yym3 := z.DecBinary()
 85626  				_ = yym3
 85627  				if false {
 85628  				} else {
 85629  					*((*string)(yyv2)) = r.DecodeString()
 85630  				}
 85631  			}
 85632  
 85633  			yyms1 = true
 85634  			if yymg1 {
 85635  				yymv1, yymok1 = yyv1[yymk1]
 85636  				if yymok1 {
 85637  					yyms1 = false
 85638  				}
 85639  			} else {
 85640  				yymv1 = nil
 85641  			}
 85642  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 85643  			if r.TryDecodeAsNil() {
 85644  				if yymv1 != nil {
 85645  					*yymv1 = DriverInfo{}
 85646  				}
 85647  			} else {
 85648  				if yymv1 == nil {
 85649  					yymv1 = new(DriverInfo)
 85650  				}
 85651  				yym5 := z.DecBinary()
 85652  				_ = yym5
 85653  				if false {
 85654  				} else if z.HasExtensions() && z.DecExt(yymv1) {
 85655  				} else {
 85656  					z.DecFallback(yymv1, false)
 85657  				}
 85658  			}
 85659  
 85660  			if yyms1 && yyv1 != nil {
 85661  				yyv1[yymk1] = yymv1
 85662  			}
 85663  		}
 85664  	} else if yyl1 < 0 {
 85665  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 85666  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 85667  			if r.TryDecodeAsNil() {
 85668  				yymk1 = ""
 85669  			} else {
 85670  				yyv6 := &yymk1
 85671  				yym7 := z.DecBinary()
 85672  				_ = yym7
 85673  				if false {
 85674  				} else {
 85675  					*((*string)(yyv6)) = r.DecodeString()
 85676  				}
 85677  			}
 85678  
 85679  			yyms1 = true
 85680  			if yymg1 {
 85681  				yymv1, yymok1 = yyv1[yymk1]
 85682  				if yymok1 {
 85683  					yyms1 = false
 85684  				}
 85685  			} else {
 85686  				yymv1 = nil
 85687  			}
 85688  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 85689  			if r.TryDecodeAsNil() {
 85690  				if yymv1 != nil {
 85691  					*yymv1 = DriverInfo{}
 85692  				}
 85693  			} else {
 85694  				if yymv1 == nil {
 85695  					yymv1 = new(DriverInfo)
 85696  				}
 85697  				yym9 := z.DecBinary()
 85698  				_ = yym9
 85699  				if false {
 85700  				} else if z.HasExtensions() && z.DecExt(yymv1) {
 85701  				} else {
 85702  					z.DecFallback(yymv1, false)
 85703  				}
 85704  			}
 85705  
 85706  			if yyms1 && yyv1 != nil {
 85707  				yyv1[yymk1] = yymv1
 85708  			}
 85709  		}
 85710  	} // else len==0: TODO: Should we clear map entries?
 85711  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 85712  }
 85713  
 85714  func (x codecSelfer100) encNetworks(v Networks, e *codec1978.Encoder) {
 85715  	var h codecSelfer100
 85716  	z, r := codec1978.GenHelperEncoder(e)
 85717  	_, _, _ = h, z, r
 85718  	r.EncodeArrayStart(len(v))
 85719  	for _, yyv1 := range v {
 85720  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 85721  		if yyv1 == nil {
 85722  			r.EncodeNil()
 85723  		} else {
 85724  			yyv1.CodecEncodeSelf(e)
 85725  		}
 85726  	}
 85727  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 85728  }
 85729  
 85730  func (x codecSelfer100) decNetworks(v *Networks, d *codec1978.Decoder) {
 85731  	var h codecSelfer100
 85732  	z, r := codec1978.GenHelperDecoder(d)
 85733  	_, _, _ = h, z, r
 85734  
 85735  	yyv1 := *v
 85736  	yyh1, yyl1 := z.DecSliceHelperStart()
 85737  	var yyc1 bool
 85738  	_ = yyc1
 85739  	if yyl1 == 0 {
 85740  		if yyv1 == nil {
 85741  			yyv1 = []*NetworkResource{}
 85742  			yyc1 = true
 85743  		} else if len(yyv1) != 0 {
 85744  			yyv1 = yyv1[:0]
 85745  			yyc1 = true
 85746  		}
 85747  	} else if yyl1 > 0 {
 85748  		var yyrr1, yyrl1 int
 85749  		var yyrt1 bool
 85750  		_, _ = yyrl1, yyrt1
 85751  		yyrr1 = yyl1 // len(yyv1)
 85752  		if yyl1 > cap(yyv1) {
 85753  
 85754  			yyrg1 := len(yyv1) > 0
 85755  			yyv21 := yyv1
 85756  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 85757  			if yyrt1 {
 85758  				if yyrl1 <= cap(yyv1) {
 85759  					yyv1 = yyv1[:yyrl1]
 85760  				} else {
 85761  					yyv1 = make([]*NetworkResource, yyrl1)
 85762  				}
 85763  			} else {
 85764  				yyv1 = make([]*NetworkResource, yyrl1)
 85765  			}
 85766  			yyc1 = true
 85767  			yyrr1 = len(yyv1)
 85768  			if yyrg1 {
 85769  				copy(yyv1, yyv21)
 85770  			}
 85771  		} else if yyl1 != len(yyv1) {
 85772  			yyv1 = yyv1[:yyl1]
 85773  			yyc1 = true
 85774  		}
 85775  		yyj1 := 0
 85776  		for ; yyj1 < yyrr1; yyj1++ {
 85777  			yyh1.ElemContainerState(yyj1)
 85778  			if r.TryDecodeAsNil() {
 85779  				if yyv1[yyj1] != nil {
 85780  					*yyv1[yyj1] = NetworkResource{}
 85781  				}
 85782  			} else {
 85783  				if yyv1[yyj1] == nil {
 85784  					yyv1[yyj1] = new(NetworkResource)
 85785  				}
 85786  				yyw2 := yyv1[yyj1]
 85787  				yyw2.CodecDecodeSelf(d)
 85788  			}
 85789  
 85790  		}
 85791  		if yyrt1 {
 85792  			for ; yyj1 < yyl1; yyj1++ {
 85793  				yyv1 = append(yyv1, nil)
 85794  				yyh1.ElemContainerState(yyj1)
 85795  				if r.TryDecodeAsNil() {
 85796  					if yyv1[yyj1] != nil {
 85797  						*yyv1[yyj1] = NetworkResource{}
 85798  					}
 85799  				} else {
 85800  					if yyv1[yyj1] == nil {
 85801  						yyv1[yyj1] = new(NetworkResource)
 85802  					}
 85803  					yyw3 := yyv1[yyj1]
 85804  					yyw3.CodecDecodeSelf(d)
 85805  				}
 85806  
 85807  			}
 85808  		}
 85809  
 85810  	} else {
 85811  		yyj1 := 0
 85812  		for ; !r.CheckBreak(); yyj1++ {
 85813  
 85814  			if yyj1 >= len(yyv1) {
 85815  				yyv1 = append(yyv1, nil) // var yyz1 *NetworkResource
 85816  				yyc1 = true
 85817  			}
 85818  			yyh1.ElemContainerState(yyj1)
 85819  			if yyj1 < len(yyv1) {
 85820  				if r.TryDecodeAsNil() {
 85821  					if yyv1[yyj1] != nil {
 85822  						*yyv1[yyj1] = NetworkResource{}
 85823  					}
 85824  				} else {
 85825  					if yyv1[yyj1] == nil {
 85826  						yyv1[yyj1] = new(NetworkResource)
 85827  					}
 85828  					yyw4 := yyv1[yyj1]
 85829  					yyw4.CodecDecodeSelf(d)
 85830  				}
 85831  
 85832  			} else {
 85833  				z.DecSwallow()
 85834  			}
 85835  
 85836  		}
 85837  		if yyj1 < len(yyv1) {
 85838  			yyv1 = yyv1[:yyj1]
 85839  			yyc1 = true
 85840  		} else if yyj1 == 0 && yyv1 == nil {
 85841  			yyv1 = []*NetworkResource{}
 85842  			yyc1 = true
 85843  		}
 85844  	}
 85845  	yyh1.End()
 85846  	if yyc1 {
 85847  		*v = yyv1
 85848  	}
 85849  }
 85850  
 85851  func (x codecSelfer100) encSlicePort(v []Port, e *codec1978.Encoder) {
 85852  	var h codecSelfer100
 85853  	z, r := codec1978.GenHelperEncoder(e)
 85854  	_, _, _ = h, z, r
 85855  	r.EncodeArrayStart(len(v))
 85856  	for _, yyv1 := range v {
 85857  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 85858  		yy2 := &yyv1
 85859  		yy2.CodecEncodeSelf(e)
 85860  	}
 85861  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 85862  }
 85863  
 85864  func (x codecSelfer100) decSlicePort(v *[]Port, d *codec1978.Decoder) {
 85865  	var h codecSelfer100
 85866  	z, r := codec1978.GenHelperDecoder(d)
 85867  	_, _, _ = h, z, r
 85868  
 85869  	yyv1 := *v
 85870  	yyh1, yyl1 := z.DecSliceHelperStart()
 85871  	var yyc1 bool
 85872  	_ = yyc1
 85873  	if yyl1 == 0 {
 85874  		if yyv1 == nil {
 85875  			yyv1 = []Port{}
 85876  			yyc1 = true
 85877  		} else if len(yyv1) != 0 {
 85878  			yyv1 = yyv1[:0]
 85879  			yyc1 = true
 85880  		}
 85881  	} else if yyl1 > 0 {
 85882  		var yyrr1, yyrl1 int
 85883  		var yyrt1 bool
 85884  		_, _ = yyrl1, yyrt1
 85885  		yyrr1 = yyl1 // len(yyv1)
 85886  		if yyl1 > cap(yyv1) {
 85887  
 85888  			yyrg1 := len(yyv1) > 0
 85889  			yyv21 := yyv1
 85890  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 24)
 85891  			if yyrt1 {
 85892  				if yyrl1 <= cap(yyv1) {
 85893  					yyv1 = yyv1[:yyrl1]
 85894  				} else {
 85895  					yyv1 = make([]Port, yyrl1)
 85896  				}
 85897  			} else {
 85898  				yyv1 = make([]Port, yyrl1)
 85899  			}
 85900  			yyc1 = true
 85901  			yyrr1 = len(yyv1)
 85902  			if yyrg1 {
 85903  				copy(yyv1, yyv21)
 85904  			}
 85905  		} else if yyl1 != len(yyv1) {
 85906  			yyv1 = yyv1[:yyl1]
 85907  			yyc1 = true
 85908  		}
 85909  		yyj1 := 0
 85910  		for ; yyj1 < yyrr1; yyj1++ {
 85911  			yyh1.ElemContainerState(yyj1)
 85912  			if r.TryDecodeAsNil() {
 85913  				yyv1[yyj1] = Port{}
 85914  			} else {
 85915  				yyv2 := &yyv1[yyj1]
 85916  				yyv2.CodecDecodeSelf(d)
 85917  			}
 85918  
 85919  		}
 85920  		if yyrt1 {
 85921  			for ; yyj1 < yyl1; yyj1++ {
 85922  				yyv1 = append(yyv1, Port{})
 85923  				yyh1.ElemContainerState(yyj1)
 85924  				if r.TryDecodeAsNil() {
 85925  					yyv1[yyj1] = Port{}
 85926  				} else {
 85927  					yyv3 := &yyv1[yyj1]
 85928  					yyv3.CodecDecodeSelf(d)
 85929  				}
 85930  
 85931  			}
 85932  		}
 85933  
 85934  	} else {
 85935  		yyj1 := 0
 85936  		for ; !r.CheckBreak(); yyj1++ {
 85937  
 85938  			if yyj1 >= len(yyv1) {
 85939  				yyv1 = append(yyv1, Port{}) // var yyz1 Port
 85940  				yyc1 = true
 85941  			}
 85942  			yyh1.ElemContainerState(yyj1)
 85943  			if yyj1 < len(yyv1) {
 85944  				if r.TryDecodeAsNil() {
 85945  					yyv1[yyj1] = Port{}
 85946  				} else {
 85947  					yyv4 := &yyv1[yyj1]
 85948  					yyv4.CodecDecodeSelf(d)
 85949  				}
 85950  
 85951  			} else {
 85952  				z.DecSwallow()
 85953  			}
 85954  
 85955  		}
 85956  		if yyj1 < len(yyv1) {
 85957  			yyv1 = yyv1[:yyj1]
 85958  			yyc1 = true
 85959  		} else if yyj1 == 0 && yyv1 == nil {
 85960  			yyv1 = []Port{}
 85961  			yyc1 = true
 85962  		}
 85963  	}
 85964  	yyh1.End()
 85965  	if yyc1 {
 85966  		*v = yyv1
 85967  	}
 85968  }
 85969  
 85970  func (x codecSelfer100) encSlicePtrtoConstraint(v []*Constraint, e *codec1978.Encoder) {
 85971  	var h codecSelfer100
 85972  	z, r := codec1978.GenHelperEncoder(e)
 85973  	_, _, _ = h, z, r
 85974  	r.EncodeArrayStart(len(v))
 85975  	for _, yyv1 := range v {
 85976  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 85977  		if yyv1 == nil {
 85978  			r.EncodeNil()
 85979  		} else {
 85980  			yyv1.CodecEncodeSelf(e)
 85981  		}
 85982  	}
 85983  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 85984  }
 85985  
 85986  func (x codecSelfer100) decSlicePtrtoConstraint(v *[]*Constraint, d *codec1978.Decoder) {
 85987  	var h codecSelfer100
 85988  	z, r := codec1978.GenHelperDecoder(d)
 85989  	_, _, _ = h, z, r
 85990  
 85991  	yyv1 := *v
 85992  	yyh1, yyl1 := z.DecSliceHelperStart()
 85993  	var yyc1 bool
 85994  	_ = yyc1
 85995  	if yyl1 == 0 {
 85996  		if yyv1 == nil {
 85997  			yyv1 = []*Constraint{}
 85998  			yyc1 = true
 85999  		} else if len(yyv1) != 0 {
 86000  			yyv1 = yyv1[:0]
 86001  			yyc1 = true
 86002  		}
 86003  	} else if yyl1 > 0 {
 86004  		var yyrr1, yyrl1 int
 86005  		var yyrt1 bool
 86006  		_, _ = yyrl1, yyrt1
 86007  		yyrr1 = yyl1 // len(yyv1)
 86008  		if yyl1 > cap(yyv1) {
 86009  
 86010  			yyrg1 := len(yyv1) > 0
 86011  			yyv21 := yyv1
 86012  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 86013  			if yyrt1 {
 86014  				if yyrl1 <= cap(yyv1) {
 86015  					yyv1 = yyv1[:yyrl1]
 86016  				} else {
 86017  					yyv1 = make([]*Constraint, yyrl1)
 86018  				}
 86019  			} else {
 86020  				yyv1 = make([]*Constraint, yyrl1)
 86021  			}
 86022  			yyc1 = true
 86023  			yyrr1 = len(yyv1)
 86024  			if yyrg1 {
 86025  				copy(yyv1, yyv21)
 86026  			}
 86027  		} else if yyl1 != len(yyv1) {
 86028  			yyv1 = yyv1[:yyl1]
 86029  			yyc1 = true
 86030  		}
 86031  		yyj1 := 0
 86032  		for ; yyj1 < yyrr1; yyj1++ {
 86033  			yyh1.ElemContainerState(yyj1)
 86034  			if r.TryDecodeAsNil() {
 86035  				if yyv1[yyj1] != nil {
 86036  					*yyv1[yyj1] = Constraint{}
 86037  				}
 86038  			} else {
 86039  				if yyv1[yyj1] == nil {
 86040  					yyv1[yyj1] = new(Constraint)
 86041  				}
 86042  				yyw2 := yyv1[yyj1]
 86043  				yyw2.CodecDecodeSelf(d)
 86044  			}
 86045  
 86046  		}
 86047  		if yyrt1 {
 86048  			for ; yyj1 < yyl1; yyj1++ {
 86049  				yyv1 = append(yyv1, nil)
 86050  				yyh1.ElemContainerState(yyj1)
 86051  				if r.TryDecodeAsNil() {
 86052  					if yyv1[yyj1] != nil {
 86053  						*yyv1[yyj1] = Constraint{}
 86054  					}
 86055  				} else {
 86056  					if yyv1[yyj1] == nil {
 86057  						yyv1[yyj1] = new(Constraint)
 86058  					}
 86059  					yyw3 := yyv1[yyj1]
 86060  					yyw3.CodecDecodeSelf(d)
 86061  				}
 86062  
 86063  			}
 86064  		}
 86065  
 86066  	} else {
 86067  		yyj1 := 0
 86068  		for ; !r.CheckBreak(); yyj1++ {
 86069  
 86070  			if yyj1 >= len(yyv1) {
 86071  				yyv1 = append(yyv1, nil) // var yyz1 *Constraint
 86072  				yyc1 = true
 86073  			}
 86074  			yyh1.ElemContainerState(yyj1)
 86075  			if yyj1 < len(yyv1) {
 86076  				if r.TryDecodeAsNil() {
 86077  					if yyv1[yyj1] != nil {
 86078  						*yyv1[yyj1] = Constraint{}
 86079  					}
 86080  				} else {
 86081  					if yyv1[yyj1] == nil {
 86082  						yyv1[yyj1] = new(Constraint)
 86083  					}
 86084  					yyw4 := yyv1[yyj1]
 86085  					yyw4.CodecDecodeSelf(d)
 86086  				}
 86087  
 86088  			} else {
 86089  				z.DecSwallow()
 86090  			}
 86091  
 86092  		}
 86093  		if yyj1 < len(yyv1) {
 86094  			yyv1 = yyv1[:yyj1]
 86095  			yyc1 = true
 86096  		} else if yyj1 == 0 && yyv1 == nil {
 86097  			yyv1 = []*Constraint{}
 86098  			yyc1 = true
 86099  		}
 86100  	}
 86101  	yyh1.End()
 86102  	if yyc1 {
 86103  		*v = yyv1
 86104  	}
 86105  }
 86106  
 86107  func (x codecSelfer100) encSlicePtrtoTaskGroup(v []*TaskGroup, e *codec1978.Encoder) {
 86108  	var h codecSelfer100
 86109  	z, r := codec1978.GenHelperEncoder(e)
 86110  	_, _, _ = h, z, r
 86111  	r.EncodeArrayStart(len(v))
 86112  	for _, yyv1 := range v {
 86113  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 86114  		if yyv1 == nil {
 86115  			r.EncodeNil()
 86116  		} else {
 86117  			yyv1.CodecEncodeSelf(e)
 86118  		}
 86119  	}
 86120  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 86121  }
 86122  
 86123  func (x codecSelfer100) decSlicePtrtoTaskGroup(v *[]*TaskGroup, d *codec1978.Decoder) {
 86124  	var h codecSelfer100
 86125  	z, r := codec1978.GenHelperDecoder(d)
 86126  	_, _, _ = h, z, r
 86127  
 86128  	yyv1 := *v
 86129  	yyh1, yyl1 := z.DecSliceHelperStart()
 86130  	var yyc1 bool
 86131  	_ = yyc1
 86132  	if yyl1 == 0 {
 86133  		if yyv1 == nil {
 86134  			yyv1 = []*TaskGroup{}
 86135  			yyc1 = true
 86136  		} else if len(yyv1) != 0 {
 86137  			yyv1 = yyv1[:0]
 86138  			yyc1 = true
 86139  		}
 86140  	} else if yyl1 > 0 {
 86141  		var yyrr1, yyrl1 int
 86142  		var yyrt1 bool
 86143  		_, _ = yyrl1, yyrt1
 86144  		yyrr1 = yyl1 // len(yyv1)
 86145  		if yyl1 > cap(yyv1) {
 86146  
 86147  			yyrg1 := len(yyv1) > 0
 86148  			yyv21 := yyv1
 86149  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 86150  			if yyrt1 {
 86151  				if yyrl1 <= cap(yyv1) {
 86152  					yyv1 = yyv1[:yyrl1]
 86153  				} else {
 86154  					yyv1 = make([]*TaskGroup, yyrl1)
 86155  				}
 86156  			} else {
 86157  				yyv1 = make([]*TaskGroup, yyrl1)
 86158  			}
 86159  			yyc1 = true
 86160  			yyrr1 = len(yyv1)
 86161  			if yyrg1 {
 86162  				copy(yyv1, yyv21)
 86163  			}
 86164  		} else if yyl1 != len(yyv1) {
 86165  			yyv1 = yyv1[:yyl1]
 86166  			yyc1 = true
 86167  		}
 86168  		yyj1 := 0
 86169  		for ; yyj1 < yyrr1; yyj1++ {
 86170  			yyh1.ElemContainerState(yyj1)
 86171  			if r.TryDecodeAsNil() {
 86172  				if yyv1[yyj1] != nil {
 86173  					*yyv1[yyj1] = TaskGroup{}
 86174  				}
 86175  			} else {
 86176  				if yyv1[yyj1] == nil {
 86177  					yyv1[yyj1] = new(TaskGroup)
 86178  				}
 86179  				yyw2 := yyv1[yyj1]
 86180  				yyw2.CodecDecodeSelf(d)
 86181  			}
 86182  
 86183  		}
 86184  		if yyrt1 {
 86185  			for ; yyj1 < yyl1; yyj1++ {
 86186  				yyv1 = append(yyv1, nil)
 86187  				yyh1.ElemContainerState(yyj1)
 86188  				if r.TryDecodeAsNil() {
 86189  					if yyv1[yyj1] != nil {
 86190  						*yyv1[yyj1] = TaskGroup{}
 86191  					}
 86192  				} else {
 86193  					if yyv1[yyj1] == nil {
 86194  						yyv1[yyj1] = new(TaskGroup)
 86195  					}
 86196  					yyw3 := yyv1[yyj1]
 86197  					yyw3.CodecDecodeSelf(d)
 86198  				}
 86199  
 86200  			}
 86201  		}
 86202  
 86203  	} else {
 86204  		yyj1 := 0
 86205  		for ; !r.CheckBreak(); yyj1++ {
 86206  
 86207  			if yyj1 >= len(yyv1) {
 86208  				yyv1 = append(yyv1, nil) // var yyz1 *TaskGroup
 86209  				yyc1 = true
 86210  			}
 86211  			yyh1.ElemContainerState(yyj1)
 86212  			if yyj1 < len(yyv1) {
 86213  				if r.TryDecodeAsNil() {
 86214  					if yyv1[yyj1] != nil {
 86215  						*yyv1[yyj1] = TaskGroup{}
 86216  					}
 86217  				} else {
 86218  					if yyv1[yyj1] == nil {
 86219  						yyv1[yyj1] = new(TaskGroup)
 86220  					}
 86221  					yyw4 := yyv1[yyj1]
 86222  					yyw4.CodecDecodeSelf(d)
 86223  				}
 86224  
 86225  			} else {
 86226  				z.DecSwallow()
 86227  			}
 86228  
 86229  		}
 86230  		if yyj1 < len(yyv1) {
 86231  			yyv1 = yyv1[:yyj1]
 86232  			yyc1 = true
 86233  		} else if yyj1 == 0 && yyv1 == nil {
 86234  			yyv1 = []*TaskGroup{}
 86235  			yyc1 = true
 86236  		}
 86237  	}
 86238  	yyh1.End()
 86239  	if yyc1 {
 86240  		*v = yyv1
 86241  	}
 86242  }
 86243  
 86244  func (x codecSelfer100) encMapstringTaskGroupSummary(v map[string]TaskGroupSummary, e *codec1978.Encoder) {
 86245  	var h codecSelfer100
 86246  	z, r := codec1978.GenHelperEncoder(e)
 86247  	_, _, _ = h, z, r
 86248  	r.EncodeMapStart(len(v))
 86249  	for yyk1, yyv1 := range v {
 86250  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 86251  		yym2 := z.EncBinary()
 86252  		_ = yym2
 86253  		if false {
 86254  		} else {
 86255  			r.EncodeString(codecSelferC_UTF8100, string(yyk1))
 86256  		}
 86257  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 86258  		yy3 := &yyv1
 86259  		yy3.CodecEncodeSelf(e)
 86260  	}
 86261  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 86262  }
 86263  
 86264  func (x codecSelfer100) decMapstringTaskGroupSummary(v *map[string]TaskGroupSummary, d *codec1978.Decoder) {
 86265  	var h codecSelfer100
 86266  	z, r := codec1978.GenHelperDecoder(d)
 86267  	_, _, _ = h, z, r
 86268  
 86269  	yyv1 := *v
 86270  	yyl1 := r.ReadMapStart()
 86271  	yybh1 := z.DecBasicHandle()
 86272  	if yyv1 == nil {
 86273  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 64)
 86274  		yyv1 = make(map[string]TaskGroupSummary, yyrl1)
 86275  		*v = yyv1
 86276  	}
 86277  	var yymk1 string
 86278  	var yymv1 TaskGroupSummary
 86279  	var yymg1 bool
 86280  	if yybh1.MapValueReset {
 86281  		yymg1 = true
 86282  	}
 86283  	if yyl1 > 0 {
 86284  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 86285  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 86286  			if r.TryDecodeAsNil() {
 86287  				yymk1 = ""
 86288  			} else {
 86289  				yyv2 := &yymk1
 86290  				yym3 := z.DecBinary()
 86291  				_ = yym3
 86292  				if false {
 86293  				} else {
 86294  					*((*string)(yyv2)) = r.DecodeString()
 86295  				}
 86296  			}
 86297  
 86298  			if yymg1 {
 86299  				yymv1 = yyv1[yymk1]
 86300  			} else {
 86301  				yymv1 = TaskGroupSummary{}
 86302  			}
 86303  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 86304  			if r.TryDecodeAsNil() {
 86305  				yymv1 = TaskGroupSummary{}
 86306  			} else {
 86307  				yyv4 := &yymv1
 86308  				yyv4.CodecDecodeSelf(d)
 86309  			}
 86310  
 86311  			if yyv1 != nil {
 86312  				yyv1[yymk1] = yymv1
 86313  			}
 86314  		}
 86315  	} else if yyl1 < 0 {
 86316  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 86317  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 86318  			if r.TryDecodeAsNil() {
 86319  				yymk1 = ""
 86320  			} else {
 86321  				yyv5 := &yymk1
 86322  				yym6 := z.DecBinary()
 86323  				_ = yym6
 86324  				if false {
 86325  				} else {
 86326  					*((*string)(yyv5)) = r.DecodeString()
 86327  				}
 86328  			}
 86329  
 86330  			if yymg1 {
 86331  				yymv1 = yyv1[yymk1]
 86332  			} else {
 86333  				yymv1 = TaskGroupSummary{}
 86334  			}
 86335  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 86336  			if r.TryDecodeAsNil() {
 86337  				yymv1 = TaskGroupSummary{}
 86338  			} else {
 86339  				yyv7 := &yymv1
 86340  				yyv7.CodecDecodeSelf(d)
 86341  			}
 86342  
 86343  			if yyv1 != nil {
 86344  				yyv1[yymk1] = yymv1
 86345  			}
 86346  		}
 86347  	} // else len==0: TODO: Should we clear map entries?
 86348  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 86349  }
 86350  
 86351  func (x codecSelfer100) encSlicePtrtoTask(v []*Task, e *codec1978.Encoder) {
 86352  	var h codecSelfer100
 86353  	z, r := codec1978.GenHelperEncoder(e)
 86354  	_, _, _ = h, z, r
 86355  	r.EncodeArrayStart(len(v))
 86356  	for _, yyv1 := range v {
 86357  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 86358  		if yyv1 == nil {
 86359  			r.EncodeNil()
 86360  		} else {
 86361  			yyv1.CodecEncodeSelf(e)
 86362  		}
 86363  	}
 86364  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 86365  }
 86366  
 86367  func (x codecSelfer100) decSlicePtrtoTask(v *[]*Task, d *codec1978.Decoder) {
 86368  	var h codecSelfer100
 86369  	z, r := codec1978.GenHelperDecoder(d)
 86370  	_, _, _ = h, z, r
 86371  
 86372  	yyv1 := *v
 86373  	yyh1, yyl1 := z.DecSliceHelperStart()
 86374  	var yyc1 bool
 86375  	_ = yyc1
 86376  	if yyl1 == 0 {
 86377  		if yyv1 == nil {
 86378  			yyv1 = []*Task{}
 86379  			yyc1 = true
 86380  		} else if len(yyv1) != 0 {
 86381  			yyv1 = yyv1[:0]
 86382  			yyc1 = true
 86383  		}
 86384  	} else if yyl1 > 0 {
 86385  		var yyrr1, yyrl1 int
 86386  		var yyrt1 bool
 86387  		_, _ = yyrl1, yyrt1
 86388  		yyrr1 = yyl1 // len(yyv1)
 86389  		if yyl1 > cap(yyv1) {
 86390  
 86391  			yyrg1 := len(yyv1) > 0
 86392  			yyv21 := yyv1
 86393  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 86394  			if yyrt1 {
 86395  				if yyrl1 <= cap(yyv1) {
 86396  					yyv1 = yyv1[:yyrl1]
 86397  				} else {
 86398  					yyv1 = make([]*Task, yyrl1)
 86399  				}
 86400  			} else {
 86401  				yyv1 = make([]*Task, yyrl1)
 86402  			}
 86403  			yyc1 = true
 86404  			yyrr1 = len(yyv1)
 86405  			if yyrg1 {
 86406  				copy(yyv1, yyv21)
 86407  			}
 86408  		} else if yyl1 != len(yyv1) {
 86409  			yyv1 = yyv1[:yyl1]
 86410  			yyc1 = true
 86411  		}
 86412  		yyj1 := 0
 86413  		for ; yyj1 < yyrr1; yyj1++ {
 86414  			yyh1.ElemContainerState(yyj1)
 86415  			if r.TryDecodeAsNil() {
 86416  				if yyv1[yyj1] != nil {
 86417  					*yyv1[yyj1] = Task{}
 86418  				}
 86419  			} else {
 86420  				if yyv1[yyj1] == nil {
 86421  					yyv1[yyj1] = new(Task)
 86422  				}
 86423  				yyw2 := yyv1[yyj1]
 86424  				yyw2.CodecDecodeSelf(d)
 86425  			}
 86426  
 86427  		}
 86428  		if yyrt1 {
 86429  			for ; yyj1 < yyl1; yyj1++ {
 86430  				yyv1 = append(yyv1, nil)
 86431  				yyh1.ElemContainerState(yyj1)
 86432  				if r.TryDecodeAsNil() {
 86433  					if yyv1[yyj1] != nil {
 86434  						*yyv1[yyj1] = Task{}
 86435  					}
 86436  				} else {
 86437  					if yyv1[yyj1] == nil {
 86438  						yyv1[yyj1] = new(Task)
 86439  					}
 86440  					yyw3 := yyv1[yyj1]
 86441  					yyw3.CodecDecodeSelf(d)
 86442  				}
 86443  
 86444  			}
 86445  		}
 86446  
 86447  	} else {
 86448  		yyj1 := 0
 86449  		for ; !r.CheckBreak(); yyj1++ {
 86450  
 86451  			if yyj1 >= len(yyv1) {
 86452  				yyv1 = append(yyv1, nil) // var yyz1 *Task
 86453  				yyc1 = true
 86454  			}
 86455  			yyh1.ElemContainerState(yyj1)
 86456  			if yyj1 < len(yyv1) {
 86457  				if r.TryDecodeAsNil() {
 86458  					if yyv1[yyj1] != nil {
 86459  						*yyv1[yyj1] = Task{}
 86460  					}
 86461  				} else {
 86462  					if yyv1[yyj1] == nil {
 86463  						yyv1[yyj1] = new(Task)
 86464  					}
 86465  					yyw4 := yyv1[yyj1]
 86466  					yyw4.CodecDecodeSelf(d)
 86467  				}
 86468  
 86469  			} else {
 86470  				z.DecSwallow()
 86471  			}
 86472  
 86473  		}
 86474  		if yyj1 < len(yyv1) {
 86475  			yyv1 = yyv1[:yyj1]
 86476  			yyc1 = true
 86477  		} else if yyj1 == 0 && yyv1 == nil {
 86478  			yyv1 = []*Task{}
 86479  			yyc1 = true
 86480  		}
 86481  	}
 86482  	yyh1.End()
 86483  	if yyc1 {
 86484  		*v = yyv1
 86485  	}
 86486  }
 86487  
 86488  func (x codecSelfer100) encMapstringSlicestring(v map[string][]string, e *codec1978.Encoder) {
 86489  	var h codecSelfer100
 86490  	z, r := codec1978.GenHelperEncoder(e)
 86491  	_, _, _ = h, z, r
 86492  	r.EncodeMapStart(len(v))
 86493  	for yyk1, yyv1 := range v {
 86494  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 86495  		yym2 := z.EncBinary()
 86496  		_ = yym2
 86497  		if false {
 86498  		} else {
 86499  			r.EncodeString(codecSelferC_UTF8100, string(yyk1))
 86500  		}
 86501  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 86502  		if yyv1 == nil {
 86503  			r.EncodeNil()
 86504  		} else {
 86505  			yym3 := z.EncBinary()
 86506  			_ = yym3
 86507  			if false {
 86508  			} else {
 86509  				z.F.EncSliceStringV(yyv1, false, e)
 86510  			}
 86511  		}
 86512  	}
 86513  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 86514  }
 86515  
 86516  func (x codecSelfer100) decMapstringSlicestring(v *map[string][]string, d *codec1978.Decoder) {
 86517  	var h codecSelfer100
 86518  	z, r := codec1978.GenHelperDecoder(d)
 86519  	_, _, _ = h, z, r
 86520  
 86521  	yyv1 := *v
 86522  	yyl1 := r.ReadMapStart()
 86523  	yybh1 := z.DecBasicHandle()
 86524  	if yyv1 == nil {
 86525  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 40)
 86526  		yyv1 = make(map[string][]string, yyrl1)
 86527  		*v = yyv1
 86528  	}
 86529  	var yymk1 string
 86530  	var yymv1 []string
 86531  	var yymg1 bool
 86532  	if yybh1.MapValueReset {
 86533  		yymg1 = true
 86534  	}
 86535  	if yyl1 > 0 {
 86536  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 86537  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 86538  			if r.TryDecodeAsNil() {
 86539  				yymk1 = ""
 86540  			} else {
 86541  				yyv2 := &yymk1
 86542  				yym3 := z.DecBinary()
 86543  				_ = yym3
 86544  				if false {
 86545  				} else {
 86546  					*((*string)(yyv2)) = r.DecodeString()
 86547  				}
 86548  			}
 86549  
 86550  			if yymg1 {
 86551  				yymv1 = yyv1[yymk1]
 86552  			} else {
 86553  				yymv1 = nil
 86554  			}
 86555  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 86556  			if r.TryDecodeAsNil() {
 86557  				yymv1 = nil
 86558  			} else {
 86559  				yyv4 := &yymv1
 86560  				yym5 := z.DecBinary()
 86561  				_ = yym5
 86562  				if false {
 86563  				} else {
 86564  					z.F.DecSliceStringX(yyv4, false, d)
 86565  				}
 86566  			}
 86567  
 86568  			if yyv1 != nil {
 86569  				yyv1[yymk1] = yymv1
 86570  			}
 86571  		}
 86572  	} else if yyl1 < 0 {
 86573  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 86574  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 86575  			if r.TryDecodeAsNil() {
 86576  				yymk1 = ""
 86577  			} else {
 86578  				yyv6 := &yymk1
 86579  				yym7 := z.DecBinary()
 86580  				_ = yym7
 86581  				if false {
 86582  				} else {
 86583  					*((*string)(yyv6)) = r.DecodeString()
 86584  				}
 86585  			}
 86586  
 86587  			if yymg1 {
 86588  				yymv1 = yyv1[yymk1]
 86589  			} else {
 86590  				yymv1 = nil
 86591  			}
 86592  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 86593  			if r.TryDecodeAsNil() {
 86594  				yymv1 = nil
 86595  			} else {
 86596  				yyv8 := &yymv1
 86597  				yym9 := z.DecBinary()
 86598  				_ = yym9
 86599  				if false {
 86600  				} else {
 86601  					z.F.DecSliceStringX(yyv8, false, d)
 86602  				}
 86603  			}
 86604  
 86605  			if yyv1 != nil {
 86606  				yyv1[yymk1] = yymv1
 86607  			}
 86608  		}
 86609  	} // else len==0: TODO: Should we clear map entries?
 86610  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 86611  }
 86612  
 86613  func (x codecSelfer100) encSlicePtrtoServiceCheck(v []*ServiceCheck, e *codec1978.Encoder) {
 86614  	var h codecSelfer100
 86615  	z, r := codec1978.GenHelperEncoder(e)
 86616  	_, _, _ = h, z, r
 86617  	r.EncodeArrayStart(len(v))
 86618  	for _, yyv1 := range v {
 86619  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 86620  		if yyv1 == nil {
 86621  			r.EncodeNil()
 86622  		} else {
 86623  			yyv1.CodecEncodeSelf(e)
 86624  		}
 86625  	}
 86626  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 86627  }
 86628  
 86629  func (x codecSelfer100) decSlicePtrtoServiceCheck(v *[]*ServiceCheck, d *codec1978.Decoder) {
 86630  	var h codecSelfer100
 86631  	z, r := codec1978.GenHelperDecoder(d)
 86632  	_, _, _ = h, z, r
 86633  
 86634  	yyv1 := *v
 86635  	yyh1, yyl1 := z.DecSliceHelperStart()
 86636  	var yyc1 bool
 86637  	_ = yyc1
 86638  	if yyl1 == 0 {
 86639  		if yyv1 == nil {
 86640  			yyv1 = []*ServiceCheck{}
 86641  			yyc1 = true
 86642  		} else if len(yyv1) != 0 {
 86643  			yyv1 = yyv1[:0]
 86644  			yyc1 = true
 86645  		}
 86646  	} else if yyl1 > 0 {
 86647  		var yyrr1, yyrl1 int
 86648  		var yyrt1 bool
 86649  		_, _ = yyrl1, yyrt1
 86650  		yyrr1 = yyl1 // len(yyv1)
 86651  		if yyl1 > cap(yyv1) {
 86652  
 86653  			yyrg1 := len(yyv1) > 0
 86654  			yyv21 := yyv1
 86655  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 86656  			if yyrt1 {
 86657  				if yyrl1 <= cap(yyv1) {
 86658  					yyv1 = yyv1[:yyrl1]
 86659  				} else {
 86660  					yyv1 = make([]*ServiceCheck, yyrl1)
 86661  				}
 86662  			} else {
 86663  				yyv1 = make([]*ServiceCheck, yyrl1)
 86664  			}
 86665  			yyc1 = true
 86666  			yyrr1 = len(yyv1)
 86667  			if yyrg1 {
 86668  				copy(yyv1, yyv21)
 86669  			}
 86670  		} else if yyl1 != len(yyv1) {
 86671  			yyv1 = yyv1[:yyl1]
 86672  			yyc1 = true
 86673  		}
 86674  		yyj1 := 0
 86675  		for ; yyj1 < yyrr1; yyj1++ {
 86676  			yyh1.ElemContainerState(yyj1)
 86677  			if r.TryDecodeAsNil() {
 86678  				if yyv1[yyj1] != nil {
 86679  					*yyv1[yyj1] = ServiceCheck{}
 86680  				}
 86681  			} else {
 86682  				if yyv1[yyj1] == nil {
 86683  					yyv1[yyj1] = new(ServiceCheck)
 86684  				}
 86685  				yyw2 := yyv1[yyj1]
 86686  				yyw2.CodecDecodeSelf(d)
 86687  			}
 86688  
 86689  		}
 86690  		if yyrt1 {
 86691  			for ; yyj1 < yyl1; yyj1++ {
 86692  				yyv1 = append(yyv1, nil)
 86693  				yyh1.ElemContainerState(yyj1)
 86694  				if r.TryDecodeAsNil() {
 86695  					if yyv1[yyj1] != nil {
 86696  						*yyv1[yyj1] = ServiceCheck{}
 86697  					}
 86698  				} else {
 86699  					if yyv1[yyj1] == nil {
 86700  						yyv1[yyj1] = new(ServiceCheck)
 86701  					}
 86702  					yyw3 := yyv1[yyj1]
 86703  					yyw3.CodecDecodeSelf(d)
 86704  				}
 86705  
 86706  			}
 86707  		}
 86708  
 86709  	} else {
 86710  		yyj1 := 0
 86711  		for ; !r.CheckBreak(); yyj1++ {
 86712  
 86713  			if yyj1 >= len(yyv1) {
 86714  				yyv1 = append(yyv1, nil) // var yyz1 *ServiceCheck
 86715  				yyc1 = true
 86716  			}
 86717  			yyh1.ElemContainerState(yyj1)
 86718  			if yyj1 < len(yyv1) {
 86719  				if r.TryDecodeAsNil() {
 86720  					if yyv1[yyj1] != nil {
 86721  						*yyv1[yyj1] = ServiceCheck{}
 86722  					}
 86723  				} else {
 86724  					if yyv1[yyj1] == nil {
 86725  						yyv1[yyj1] = new(ServiceCheck)
 86726  					}
 86727  					yyw4 := yyv1[yyj1]
 86728  					yyw4.CodecDecodeSelf(d)
 86729  				}
 86730  
 86731  			} else {
 86732  				z.DecSwallow()
 86733  			}
 86734  
 86735  		}
 86736  		if yyj1 < len(yyv1) {
 86737  			yyv1 = yyv1[:yyj1]
 86738  			yyc1 = true
 86739  		} else if yyj1 == 0 && yyv1 == nil {
 86740  			yyv1 = []*ServiceCheck{}
 86741  			yyc1 = true
 86742  		}
 86743  	}
 86744  	yyh1.End()
 86745  	if yyc1 {
 86746  		*v = yyv1
 86747  	}
 86748  }
 86749  
 86750  func (x codecSelfer100) encSlicePtrtoService(v []*Service, e *codec1978.Encoder) {
 86751  	var h codecSelfer100
 86752  	z, r := codec1978.GenHelperEncoder(e)
 86753  	_, _, _ = h, z, r
 86754  	r.EncodeArrayStart(len(v))
 86755  	for _, yyv1 := range v {
 86756  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 86757  		if yyv1 == nil {
 86758  			r.EncodeNil()
 86759  		} else {
 86760  			yyv1.CodecEncodeSelf(e)
 86761  		}
 86762  	}
 86763  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 86764  }
 86765  
 86766  func (x codecSelfer100) decSlicePtrtoService(v *[]*Service, d *codec1978.Decoder) {
 86767  	var h codecSelfer100
 86768  	z, r := codec1978.GenHelperDecoder(d)
 86769  	_, _, _ = h, z, r
 86770  
 86771  	yyv1 := *v
 86772  	yyh1, yyl1 := z.DecSliceHelperStart()
 86773  	var yyc1 bool
 86774  	_ = yyc1
 86775  	if yyl1 == 0 {
 86776  		if yyv1 == nil {
 86777  			yyv1 = []*Service{}
 86778  			yyc1 = true
 86779  		} else if len(yyv1) != 0 {
 86780  			yyv1 = yyv1[:0]
 86781  			yyc1 = true
 86782  		}
 86783  	} else if yyl1 > 0 {
 86784  		var yyrr1, yyrl1 int
 86785  		var yyrt1 bool
 86786  		_, _ = yyrl1, yyrt1
 86787  		yyrr1 = yyl1 // len(yyv1)
 86788  		if yyl1 > cap(yyv1) {
 86789  
 86790  			yyrg1 := len(yyv1) > 0
 86791  			yyv21 := yyv1
 86792  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 86793  			if yyrt1 {
 86794  				if yyrl1 <= cap(yyv1) {
 86795  					yyv1 = yyv1[:yyrl1]
 86796  				} else {
 86797  					yyv1 = make([]*Service, yyrl1)
 86798  				}
 86799  			} else {
 86800  				yyv1 = make([]*Service, yyrl1)
 86801  			}
 86802  			yyc1 = true
 86803  			yyrr1 = len(yyv1)
 86804  			if yyrg1 {
 86805  				copy(yyv1, yyv21)
 86806  			}
 86807  		} else if yyl1 != len(yyv1) {
 86808  			yyv1 = yyv1[:yyl1]
 86809  			yyc1 = true
 86810  		}
 86811  		yyj1 := 0
 86812  		for ; yyj1 < yyrr1; yyj1++ {
 86813  			yyh1.ElemContainerState(yyj1)
 86814  			if r.TryDecodeAsNil() {
 86815  				if yyv1[yyj1] != nil {
 86816  					*yyv1[yyj1] = Service{}
 86817  				}
 86818  			} else {
 86819  				if yyv1[yyj1] == nil {
 86820  					yyv1[yyj1] = new(Service)
 86821  				}
 86822  				yyw2 := yyv1[yyj1]
 86823  				yyw2.CodecDecodeSelf(d)
 86824  			}
 86825  
 86826  		}
 86827  		if yyrt1 {
 86828  			for ; yyj1 < yyl1; yyj1++ {
 86829  				yyv1 = append(yyv1, nil)
 86830  				yyh1.ElemContainerState(yyj1)
 86831  				if r.TryDecodeAsNil() {
 86832  					if yyv1[yyj1] != nil {
 86833  						*yyv1[yyj1] = Service{}
 86834  					}
 86835  				} else {
 86836  					if yyv1[yyj1] == nil {
 86837  						yyv1[yyj1] = new(Service)
 86838  					}
 86839  					yyw3 := yyv1[yyj1]
 86840  					yyw3.CodecDecodeSelf(d)
 86841  				}
 86842  
 86843  			}
 86844  		}
 86845  
 86846  	} else {
 86847  		yyj1 := 0
 86848  		for ; !r.CheckBreak(); yyj1++ {
 86849  
 86850  			if yyj1 >= len(yyv1) {
 86851  				yyv1 = append(yyv1, nil) // var yyz1 *Service
 86852  				yyc1 = true
 86853  			}
 86854  			yyh1.ElemContainerState(yyj1)
 86855  			if yyj1 < len(yyv1) {
 86856  				if r.TryDecodeAsNil() {
 86857  					if yyv1[yyj1] != nil {
 86858  						*yyv1[yyj1] = Service{}
 86859  					}
 86860  				} else {
 86861  					if yyv1[yyj1] == nil {
 86862  						yyv1[yyj1] = new(Service)
 86863  					}
 86864  					yyw4 := yyv1[yyj1]
 86865  					yyw4.CodecDecodeSelf(d)
 86866  				}
 86867  
 86868  			} else {
 86869  				z.DecSwallow()
 86870  			}
 86871  
 86872  		}
 86873  		if yyj1 < len(yyv1) {
 86874  			yyv1 = yyv1[:yyj1]
 86875  			yyc1 = true
 86876  		} else if yyj1 == 0 && yyv1 == nil {
 86877  			yyv1 = []*Service{}
 86878  			yyc1 = true
 86879  		}
 86880  	}
 86881  	yyh1.End()
 86882  	if yyc1 {
 86883  		*v = yyv1
 86884  	}
 86885  }
 86886  
 86887  func (x codecSelfer100) encSlicePtrtoTemplate(v []*Template, e *codec1978.Encoder) {
 86888  	var h codecSelfer100
 86889  	z, r := codec1978.GenHelperEncoder(e)
 86890  	_, _, _ = h, z, r
 86891  	r.EncodeArrayStart(len(v))
 86892  	for _, yyv1 := range v {
 86893  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 86894  		if yyv1 == nil {
 86895  			r.EncodeNil()
 86896  		} else {
 86897  			yyv1.CodecEncodeSelf(e)
 86898  		}
 86899  	}
 86900  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 86901  }
 86902  
 86903  func (x codecSelfer100) decSlicePtrtoTemplate(v *[]*Template, d *codec1978.Decoder) {
 86904  	var h codecSelfer100
 86905  	z, r := codec1978.GenHelperDecoder(d)
 86906  	_, _, _ = h, z, r
 86907  
 86908  	yyv1 := *v
 86909  	yyh1, yyl1 := z.DecSliceHelperStart()
 86910  	var yyc1 bool
 86911  	_ = yyc1
 86912  	if yyl1 == 0 {
 86913  		if yyv1 == nil {
 86914  			yyv1 = []*Template{}
 86915  			yyc1 = true
 86916  		} else if len(yyv1) != 0 {
 86917  			yyv1 = yyv1[:0]
 86918  			yyc1 = true
 86919  		}
 86920  	} else if yyl1 > 0 {
 86921  		var yyrr1, yyrl1 int
 86922  		var yyrt1 bool
 86923  		_, _ = yyrl1, yyrt1
 86924  		yyrr1 = yyl1 // len(yyv1)
 86925  		if yyl1 > cap(yyv1) {
 86926  
 86927  			yyrg1 := len(yyv1) > 0
 86928  			yyv21 := yyv1
 86929  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 86930  			if yyrt1 {
 86931  				if yyrl1 <= cap(yyv1) {
 86932  					yyv1 = yyv1[:yyrl1]
 86933  				} else {
 86934  					yyv1 = make([]*Template, yyrl1)
 86935  				}
 86936  			} else {
 86937  				yyv1 = make([]*Template, yyrl1)
 86938  			}
 86939  			yyc1 = true
 86940  			yyrr1 = len(yyv1)
 86941  			if yyrg1 {
 86942  				copy(yyv1, yyv21)
 86943  			}
 86944  		} else if yyl1 != len(yyv1) {
 86945  			yyv1 = yyv1[:yyl1]
 86946  			yyc1 = true
 86947  		}
 86948  		yyj1 := 0
 86949  		for ; yyj1 < yyrr1; yyj1++ {
 86950  			yyh1.ElemContainerState(yyj1)
 86951  			if r.TryDecodeAsNil() {
 86952  				if yyv1[yyj1] != nil {
 86953  					*yyv1[yyj1] = Template{}
 86954  				}
 86955  			} else {
 86956  				if yyv1[yyj1] == nil {
 86957  					yyv1[yyj1] = new(Template)
 86958  				}
 86959  				yyw2 := yyv1[yyj1]
 86960  				yyw2.CodecDecodeSelf(d)
 86961  			}
 86962  
 86963  		}
 86964  		if yyrt1 {
 86965  			for ; yyj1 < yyl1; yyj1++ {
 86966  				yyv1 = append(yyv1, nil)
 86967  				yyh1.ElemContainerState(yyj1)
 86968  				if r.TryDecodeAsNil() {
 86969  					if yyv1[yyj1] != nil {
 86970  						*yyv1[yyj1] = Template{}
 86971  					}
 86972  				} else {
 86973  					if yyv1[yyj1] == nil {
 86974  						yyv1[yyj1] = new(Template)
 86975  					}
 86976  					yyw3 := yyv1[yyj1]
 86977  					yyw3.CodecDecodeSelf(d)
 86978  				}
 86979  
 86980  			}
 86981  		}
 86982  
 86983  	} else {
 86984  		yyj1 := 0
 86985  		for ; !r.CheckBreak(); yyj1++ {
 86986  
 86987  			if yyj1 >= len(yyv1) {
 86988  				yyv1 = append(yyv1, nil) // var yyz1 *Template
 86989  				yyc1 = true
 86990  			}
 86991  			yyh1.ElemContainerState(yyj1)
 86992  			if yyj1 < len(yyv1) {
 86993  				if r.TryDecodeAsNil() {
 86994  					if yyv1[yyj1] != nil {
 86995  						*yyv1[yyj1] = Template{}
 86996  					}
 86997  				} else {
 86998  					if yyv1[yyj1] == nil {
 86999  						yyv1[yyj1] = new(Template)
 87000  					}
 87001  					yyw4 := yyv1[yyj1]
 87002  					yyw4.CodecDecodeSelf(d)
 87003  				}
 87004  
 87005  			} else {
 87006  				z.DecSwallow()
 87007  			}
 87008  
 87009  		}
 87010  		if yyj1 < len(yyv1) {
 87011  			yyv1 = yyv1[:yyj1]
 87012  			yyc1 = true
 87013  		} else if yyj1 == 0 && yyv1 == nil {
 87014  			yyv1 = []*Template{}
 87015  			yyc1 = true
 87016  		}
 87017  	}
 87018  	yyh1.End()
 87019  	if yyc1 {
 87020  		*v = yyv1
 87021  	}
 87022  }
 87023  
 87024  func (x codecSelfer100) encSlicePtrtoTaskArtifact(v []*TaskArtifact, e *codec1978.Encoder) {
 87025  	var h codecSelfer100
 87026  	z, r := codec1978.GenHelperEncoder(e)
 87027  	_, _, _ = h, z, r
 87028  	r.EncodeArrayStart(len(v))
 87029  	for _, yyv1 := range v {
 87030  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 87031  		if yyv1 == nil {
 87032  			r.EncodeNil()
 87033  		} else {
 87034  			yyv1.CodecEncodeSelf(e)
 87035  		}
 87036  	}
 87037  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 87038  }
 87039  
 87040  func (x codecSelfer100) decSlicePtrtoTaskArtifact(v *[]*TaskArtifact, d *codec1978.Decoder) {
 87041  	var h codecSelfer100
 87042  	z, r := codec1978.GenHelperDecoder(d)
 87043  	_, _, _ = h, z, r
 87044  
 87045  	yyv1 := *v
 87046  	yyh1, yyl1 := z.DecSliceHelperStart()
 87047  	var yyc1 bool
 87048  	_ = yyc1
 87049  	if yyl1 == 0 {
 87050  		if yyv1 == nil {
 87051  			yyv1 = []*TaskArtifact{}
 87052  			yyc1 = true
 87053  		} else if len(yyv1) != 0 {
 87054  			yyv1 = yyv1[:0]
 87055  			yyc1 = true
 87056  		}
 87057  	} else if yyl1 > 0 {
 87058  		var yyrr1, yyrl1 int
 87059  		var yyrt1 bool
 87060  		_, _ = yyrl1, yyrt1
 87061  		yyrr1 = yyl1 // len(yyv1)
 87062  		if yyl1 > cap(yyv1) {
 87063  
 87064  			yyrg1 := len(yyv1) > 0
 87065  			yyv21 := yyv1
 87066  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 87067  			if yyrt1 {
 87068  				if yyrl1 <= cap(yyv1) {
 87069  					yyv1 = yyv1[:yyrl1]
 87070  				} else {
 87071  					yyv1 = make([]*TaskArtifact, yyrl1)
 87072  				}
 87073  			} else {
 87074  				yyv1 = make([]*TaskArtifact, yyrl1)
 87075  			}
 87076  			yyc1 = true
 87077  			yyrr1 = len(yyv1)
 87078  			if yyrg1 {
 87079  				copy(yyv1, yyv21)
 87080  			}
 87081  		} else if yyl1 != len(yyv1) {
 87082  			yyv1 = yyv1[:yyl1]
 87083  			yyc1 = true
 87084  		}
 87085  		yyj1 := 0
 87086  		for ; yyj1 < yyrr1; yyj1++ {
 87087  			yyh1.ElemContainerState(yyj1)
 87088  			if r.TryDecodeAsNil() {
 87089  				if yyv1[yyj1] != nil {
 87090  					*yyv1[yyj1] = TaskArtifact{}
 87091  				}
 87092  			} else {
 87093  				if yyv1[yyj1] == nil {
 87094  					yyv1[yyj1] = new(TaskArtifact)
 87095  				}
 87096  				yyw2 := yyv1[yyj1]
 87097  				yyw2.CodecDecodeSelf(d)
 87098  			}
 87099  
 87100  		}
 87101  		if yyrt1 {
 87102  			for ; yyj1 < yyl1; yyj1++ {
 87103  				yyv1 = append(yyv1, nil)
 87104  				yyh1.ElemContainerState(yyj1)
 87105  				if r.TryDecodeAsNil() {
 87106  					if yyv1[yyj1] != nil {
 87107  						*yyv1[yyj1] = TaskArtifact{}
 87108  					}
 87109  				} else {
 87110  					if yyv1[yyj1] == nil {
 87111  						yyv1[yyj1] = new(TaskArtifact)
 87112  					}
 87113  					yyw3 := yyv1[yyj1]
 87114  					yyw3.CodecDecodeSelf(d)
 87115  				}
 87116  
 87117  			}
 87118  		}
 87119  
 87120  	} else {
 87121  		yyj1 := 0
 87122  		for ; !r.CheckBreak(); yyj1++ {
 87123  
 87124  			if yyj1 >= len(yyv1) {
 87125  				yyv1 = append(yyv1, nil) // var yyz1 *TaskArtifact
 87126  				yyc1 = true
 87127  			}
 87128  			yyh1.ElemContainerState(yyj1)
 87129  			if yyj1 < len(yyv1) {
 87130  				if r.TryDecodeAsNil() {
 87131  					if yyv1[yyj1] != nil {
 87132  						*yyv1[yyj1] = TaskArtifact{}
 87133  					}
 87134  				} else {
 87135  					if yyv1[yyj1] == nil {
 87136  						yyv1[yyj1] = new(TaskArtifact)
 87137  					}
 87138  					yyw4 := yyv1[yyj1]
 87139  					yyw4.CodecDecodeSelf(d)
 87140  				}
 87141  
 87142  			} else {
 87143  				z.DecSwallow()
 87144  			}
 87145  
 87146  		}
 87147  		if yyj1 < len(yyv1) {
 87148  			yyv1 = yyv1[:yyj1]
 87149  			yyc1 = true
 87150  		} else if yyj1 == 0 && yyv1 == nil {
 87151  			yyv1 = []*TaskArtifact{}
 87152  			yyc1 = true
 87153  		}
 87154  	}
 87155  	yyh1.End()
 87156  	if yyc1 {
 87157  		*v = yyv1
 87158  	}
 87159  }
 87160  
 87161  func (x codecSelfer100) encSlicePtrtoTaskEvent(v []*TaskEvent, e *codec1978.Encoder) {
 87162  	var h codecSelfer100
 87163  	z, r := codec1978.GenHelperEncoder(e)
 87164  	_, _, _ = h, z, r
 87165  	r.EncodeArrayStart(len(v))
 87166  	for _, yyv1 := range v {
 87167  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 87168  		if yyv1 == nil {
 87169  			r.EncodeNil()
 87170  		} else {
 87171  			yyv1.CodecEncodeSelf(e)
 87172  		}
 87173  	}
 87174  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 87175  }
 87176  
 87177  func (x codecSelfer100) decSlicePtrtoTaskEvent(v *[]*TaskEvent, d *codec1978.Decoder) {
 87178  	var h codecSelfer100
 87179  	z, r := codec1978.GenHelperDecoder(d)
 87180  	_, _, _ = h, z, r
 87181  
 87182  	yyv1 := *v
 87183  	yyh1, yyl1 := z.DecSliceHelperStart()
 87184  	var yyc1 bool
 87185  	_ = yyc1
 87186  	if yyl1 == 0 {
 87187  		if yyv1 == nil {
 87188  			yyv1 = []*TaskEvent{}
 87189  			yyc1 = true
 87190  		} else if len(yyv1) != 0 {
 87191  			yyv1 = yyv1[:0]
 87192  			yyc1 = true
 87193  		}
 87194  	} else if yyl1 > 0 {
 87195  		var yyrr1, yyrl1 int
 87196  		var yyrt1 bool
 87197  		_, _ = yyrl1, yyrt1
 87198  		yyrr1 = yyl1 // len(yyv1)
 87199  		if yyl1 > cap(yyv1) {
 87200  
 87201  			yyrg1 := len(yyv1) > 0
 87202  			yyv21 := yyv1
 87203  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 87204  			if yyrt1 {
 87205  				if yyrl1 <= cap(yyv1) {
 87206  					yyv1 = yyv1[:yyrl1]
 87207  				} else {
 87208  					yyv1 = make([]*TaskEvent, yyrl1)
 87209  				}
 87210  			} else {
 87211  				yyv1 = make([]*TaskEvent, yyrl1)
 87212  			}
 87213  			yyc1 = true
 87214  			yyrr1 = len(yyv1)
 87215  			if yyrg1 {
 87216  				copy(yyv1, yyv21)
 87217  			}
 87218  		} else if yyl1 != len(yyv1) {
 87219  			yyv1 = yyv1[:yyl1]
 87220  			yyc1 = true
 87221  		}
 87222  		yyj1 := 0
 87223  		for ; yyj1 < yyrr1; yyj1++ {
 87224  			yyh1.ElemContainerState(yyj1)
 87225  			if r.TryDecodeAsNil() {
 87226  				if yyv1[yyj1] != nil {
 87227  					*yyv1[yyj1] = TaskEvent{}
 87228  				}
 87229  			} else {
 87230  				if yyv1[yyj1] == nil {
 87231  					yyv1[yyj1] = new(TaskEvent)
 87232  				}
 87233  				yyw2 := yyv1[yyj1]
 87234  				yyw2.CodecDecodeSelf(d)
 87235  			}
 87236  
 87237  		}
 87238  		if yyrt1 {
 87239  			for ; yyj1 < yyl1; yyj1++ {
 87240  				yyv1 = append(yyv1, nil)
 87241  				yyh1.ElemContainerState(yyj1)
 87242  				if r.TryDecodeAsNil() {
 87243  					if yyv1[yyj1] != nil {
 87244  						*yyv1[yyj1] = TaskEvent{}
 87245  					}
 87246  				} else {
 87247  					if yyv1[yyj1] == nil {
 87248  						yyv1[yyj1] = new(TaskEvent)
 87249  					}
 87250  					yyw3 := yyv1[yyj1]
 87251  					yyw3.CodecDecodeSelf(d)
 87252  				}
 87253  
 87254  			}
 87255  		}
 87256  
 87257  	} else {
 87258  		yyj1 := 0
 87259  		for ; !r.CheckBreak(); yyj1++ {
 87260  
 87261  			if yyj1 >= len(yyv1) {
 87262  				yyv1 = append(yyv1, nil) // var yyz1 *TaskEvent
 87263  				yyc1 = true
 87264  			}
 87265  			yyh1.ElemContainerState(yyj1)
 87266  			if yyj1 < len(yyv1) {
 87267  				if r.TryDecodeAsNil() {
 87268  					if yyv1[yyj1] != nil {
 87269  						*yyv1[yyj1] = TaskEvent{}
 87270  					}
 87271  				} else {
 87272  					if yyv1[yyj1] == nil {
 87273  						yyv1[yyj1] = new(TaskEvent)
 87274  					}
 87275  					yyw4 := yyv1[yyj1]
 87276  					yyw4.CodecDecodeSelf(d)
 87277  				}
 87278  
 87279  			} else {
 87280  				z.DecSwallow()
 87281  			}
 87282  
 87283  		}
 87284  		if yyj1 < len(yyv1) {
 87285  			yyv1 = yyv1[:yyj1]
 87286  			yyc1 = true
 87287  		} else if yyj1 == 0 && yyv1 == nil {
 87288  			yyv1 = []*TaskEvent{}
 87289  			yyc1 = true
 87290  		}
 87291  	}
 87292  	yyh1.End()
 87293  	if yyc1 {
 87294  		*v = yyv1
 87295  	}
 87296  }
 87297  
 87298  func (x codecSelfer100) encMapstringPtrtoDeploymentState(v map[string]*DeploymentState, e *codec1978.Encoder) {
 87299  	var h codecSelfer100
 87300  	z, r := codec1978.GenHelperEncoder(e)
 87301  	_, _, _ = h, z, r
 87302  	r.EncodeMapStart(len(v))
 87303  	for yyk1, yyv1 := range v {
 87304  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 87305  		yym2 := z.EncBinary()
 87306  		_ = yym2
 87307  		if false {
 87308  		} else {
 87309  			r.EncodeString(codecSelferC_UTF8100, string(yyk1))
 87310  		}
 87311  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 87312  		if yyv1 == nil {
 87313  			r.EncodeNil()
 87314  		} else {
 87315  			yyv1.CodecEncodeSelf(e)
 87316  		}
 87317  	}
 87318  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 87319  }
 87320  
 87321  func (x codecSelfer100) decMapstringPtrtoDeploymentState(v *map[string]*DeploymentState, d *codec1978.Decoder) {
 87322  	var h codecSelfer100
 87323  	z, r := codec1978.GenHelperDecoder(d)
 87324  	_, _, _ = h, z, r
 87325  
 87326  	yyv1 := *v
 87327  	yyl1 := r.ReadMapStart()
 87328  	yybh1 := z.DecBasicHandle()
 87329  	if yyv1 == nil {
 87330  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 24)
 87331  		yyv1 = make(map[string]*DeploymentState, yyrl1)
 87332  		*v = yyv1
 87333  	}
 87334  	var yymk1 string
 87335  	var yymv1 *DeploymentState
 87336  	var yymg1, yyms1, yymok1 bool
 87337  	if yybh1.MapValueReset {
 87338  		yymg1 = true
 87339  	}
 87340  	if yyl1 > 0 {
 87341  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 87342  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 87343  			if r.TryDecodeAsNil() {
 87344  				yymk1 = ""
 87345  			} else {
 87346  				yyv2 := &yymk1
 87347  				yym3 := z.DecBinary()
 87348  				_ = yym3
 87349  				if false {
 87350  				} else {
 87351  					*((*string)(yyv2)) = r.DecodeString()
 87352  				}
 87353  			}
 87354  
 87355  			yyms1 = true
 87356  			if yymg1 {
 87357  				yymv1, yymok1 = yyv1[yymk1]
 87358  				if yymok1 {
 87359  					yyms1 = false
 87360  				}
 87361  			} else {
 87362  				yymv1 = nil
 87363  			}
 87364  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 87365  			if r.TryDecodeAsNil() {
 87366  				if yymv1 != nil {
 87367  					*yymv1 = DeploymentState{}
 87368  				}
 87369  			} else {
 87370  				if yymv1 == nil {
 87371  					yymv1 = new(DeploymentState)
 87372  				}
 87373  				yymv1.CodecDecodeSelf(d)
 87374  			}
 87375  
 87376  			if yyms1 && yyv1 != nil {
 87377  				yyv1[yymk1] = yymv1
 87378  			}
 87379  		}
 87380  	} else if yyl1 < 0 {
 87381  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 87382  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 87383  			if r.TryDecodeAsNil() {
 87384  				yymk1 = ""
 87385  			} else {
 87386  				yyv5 := &yymk1
 87387  				yym6 := z.DecBinary()
 87388  				_ = yym6
 87389  				if false {
 87390  				} else {
 87391  					*((*string)(yyv5)) = r.DecodeString()
 87392  				}
 87393  			}
 87394  
 87395  			yyms1 = true
 87396  			if yymg1 {
 87397  				yymv1, yymok1 = yyv1[yymk1]
 87398  				if yymok1 {
 87399  					yyms1 = false
 87400  				}
 87401  			} else {
 87402  				yymv1 = nil
 87403  			}
 87404  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 87405  			if r.TryDecodeAsNil() {
 87406  				if yymv1 != nil {
 87407  					*yymv1 = DeploymentState{}
 87408  				}
 87409  			} else {
 87410  				if yymv1 == nil {
 87411  					yymv1 = new(DeploymentState)
 87412  				}
 87413  				yymv1.CodecDecodeSelf(d)
 87414  			}
 87415  
 87416  			if yyms1 && yyv1 != nil {
 87417  				yyv1[yymk1] = yymv1
 87418  			}
 87419  		}
 87420  	} // else len==0: TODO: Should we clear map entries?
 87421  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 87422  }
 87423  
 87424  func (x codecSelfer100) encSlicePtrtoRescheduleEvent(v []*RescheduleEvent, e *codec1978.Encoder) {
 87425  	var h codecSelfer100
 87426  	z, r := codec1978.GenHelperEncoder(e)
 87427  	_, _, _ = h, z, r
 87428  	r.EncodeArrayStart(len(v))
 87429  	for _, yyv1 := range v {
 87430  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 87431  		if yyv1 == nil {
 87432  			r.EncodeNil()
 87433  		} else {
 87434  			yyv1.CodecEncodeSelf(e)
 87435  		}
 87436  	}
 87437  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 87438  }
 87439  
 87440  func (x codecSelfer100) decSlicePtrtoRescheduleEvent(v *[]*RescheduleEvent, d *codec1978.Decoder) {
 87441  	var h codecSelfer100
 87442  	z, r := codec1978.GenHelperDecoder(d)
 87443  	_, _, _ = h, z, r
 87444  
 87445  	yyv1 := *v
 87446  	yyh1, yyl1 := z.DecSliceHelperStart()
 87447  	var yyc1 bool
 87448  	_ = yyc1
 87449  	if yyl1 == 0 {
 87450  		if yyv1 == nil {
 87451  			yyv1 = []*RescheduleEvent{}
 87452  			yyc1 = true
 87453  		} else if len(yyv1) != 0 {
 87454  			yyv1 = yyv1[:0]
 87455  			yyc1 = true
 87456  		}
 87457  	} else if yyl1 > 0 {
 87458  		var yyrr1, yyrl1 int
 87459  		var yyrt1 bool
 87460  		_, _ = yyrl1, yyrt1
 87461  		yyrr1 = yyl1 // len(yyv1)
 87462  		if yyl1 > cap(yyv1) {
 87463  
 87464  			yyrg1 := len(yyv1) > 0
 87465  			yyv21 := yyv1
 87466  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 87467  			if yyrt1 {
 87468  				if yyrl1 <= cap(yyv1) {
 87469  					yyv1 = yyv1[:yyrl1]
 87470  				} else {
 87471  					yyv1 = make([]*RescheduleEvent, yyrl1)
 87472  				}
 87473  			} else {
 87474  				yyv1 = make([]*RescheduleEvent, yyrl1)
 87475  			}
 87476  			yyc1 = true
 87477  			yyrr1 = len(yyv1)
 87478  			if yyrg1 {
 87479  				copy(yyv1, yyv21)
 87480  			}
 87481  		} else if yyl1 != len(yyv1) {
 87482  			yyv1 = yyv1[:yyl1]
 87483  			yyc1 = true
 87484  		}
 87485  		yyj1 := 0
 87486  		for ; yyj1 < yyrr1; yyj1++ {
 87487  			yyh1.ElemContainerState(yyj1)
 87488  			if r.TryDecodeAsNil() {
 87489  				if yyv1[yyj1] != nil {
 87490  					*yyv1[yyj1] = RescheduleEvent{}
 87491  				}
 87492  			} else {
 87493  				if yyv1[yyj1] == nil {
 87494  					yyv1[yyj1] = new(RescheduleEvent)
 87495  				}
 87496  				yyw2 := yyv1[yyj1]
 87497  				yyw2.CodecDecodeSelf(d)
 87498  			}
 87499  
 87500  		}
 87501  		if yyrt1 {
 87502  			for ; yyj1 < yyl1; yyj1++ {
 87503  				yyv1 = append(yyv1, nil)
 87504  				yyh1.ElemContainerState(yyj1)
 87505  				if r.TryDecodeAsNil() {
 87506  					if yyv1[yyj1] != nil {
 87507  						*yyv1[yyj1] = RescheduleEvent{}
 87508  					}
 87509  				} else {
 87510  					if yyv1[yyj1] == nil {
 87511  						yyv1[yyj1] = new(RescheduleEvent)
 87512  					}
 87513  					yyw3 := yyv1[yyj1]
 87514  					yyw3.CodecDecodeSelf(d)
 87515  				}
 87516  
 87517  			}
 87518  		}
 87519  
 87520  	} else {
 87521  		yyj1 := 0
 87522  		for ; !r.CheckBreak(); yyj1++ {
 87523  
 87524  			if yyj1 >= len(yyv1) {
 87525  				yyv1 = append(yyv1, nil) // var yyz1 *RescheduleEvent
 87526  				yyc1 = true
 87527  			}
 87528  			yyh1.ElemContainerState(yyj1)
 87529  			if yyj1 < len(yyv1) {
 87530  				if r.TryDecodeAsNil() {
 87531  					if yyv1[yyj1] != nil {
 87532  						*yyv1[yyj1] = RescheduleEvent{}
 87533  					}
 87534  				} else {
 87535  					if yyv1[yyj1] == nil {
 87536  						yyv1[yyj1] = new(RescheduleEvent)
 87537  					}
 87538  					yyw4 := yyv1[yyj1]
 87539  					yyw4.CodecDecodeSelf(d)
 87540  				}
 87541  
 87542  			} else {
 87543  				z.DecSwallow()
 87544  			}
 87545  
 87546  		}
 87547  		if yyj1 < len(yyv1) {
 87548  			yyv1 = yyv1[:yyj1]
 87549  			yyc1 = true
 87550  		} else if yyj1 == 0 && yyv1 == nil {
 87551  			yyv1 = []*RescheduleEvent{}
 87552  			yyc1 = true
 87553  		}
 87554  	}
 87555  	yyh1.End()
 87556  	if yyc1 {
 87557  		*v = yyv1
 87558  	}
 87559  }
 87560  
 87561  func (x codecSelfer100) encMapstringPtrtoResources(v map[string]*Resources, e *codec1978.Encoder) {
 87562  	var h codecSelfer100
 87563  	z, r := codec1978.GenHelperEncoder(e)
 87564  	_, _, _ = h, z, r
 87565  	r.EncodeMapStart(len(v))
 87566  	for yyk1, yyv1 := range v {
 87567  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 87568  		yym2 := z.EncBinary()
 87569  		_ = yym2
 87570  		if false {
 87571  		} else {
 87572  			r.EncodeString(codecSelferC_UTF8100, string(yyk1))
 87573  		}
 87574  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 87575  		if yyv1 == nil {
 87576  			r.EncodeNil()
 87577  		} else {
 87578  			yyv1.CodecEncodeSelf(e)
 87579  		}
 87580  	}
 87581  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 87582  }
 87583  
 87584  func (x codecSelfer100) decMapstringPtrtoResources(v *map[string]*Resources, d *codec1978.Decoder) {
 87585  	var h codecSelfer100
 87586  	z, r := codec1978.GenHelperDecoder(d)
 87587  	_, _, _ = h, z, r
 87588  
 87589  	yyv1 := *v
 87590  	yyl1 := r.ReadMapStart()
 87591  	yybh1 := z.DecBasicHandle()
 87592  	if yyv1 == nil {
 87593  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 24)
 87594  		yyv1 = make(map[string]*Resources, yyrl1)
 87595  		*v = yyv1
 87596  	}
 87597  	var yymk1 string
 87598  	var yymv1 *Resources
 87599  	var yymg1, yyms1, yymok1 bool
 87600  	if yybh1.MapValueReset {
 87601  		yymg1 = true
 87602  	}
 87603  	if yyl1 > 0 {
 87604  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 87605  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 87606  			if r.TryDecodeAsNil() {
 87607  				yymk1 = ""
 87608  			} else {
 87609  				yyv2 := &yymk1
 87610  				yym3 := z.DecBinary()
 87611  				_ = yym3
 87612  				if false {
 87613  				} else {
 87614  					*((*string)(yyv2)) = r.DecodeString()
 87615  				}
 87616  			}
 87617  
 87618  			yyms1 = true
 87619  			if yymg1 {
 87620  				yymv1, yymok1 = yyv1[yymk1]
 87621  				if yymok1 {
 87622  					yyms1 = false
 87623  				}
 87624  			} else {
 87625  				yymv1 = nil
 87626  			}
 87627  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 87628  			if r.TryDecodeAsNil() {
 87629  				if yymv1 != nil {
 87630  					*yymv1 = Resources{}
 87631  				}
 87632  			} else {
 87633  				if yymv1 == nil {
 87634  					yymv1 = new(Resources)
 87635  				}
 87636  				yymv1.CodecDecodeSelf(d)
 87637  			}
 87638  
 87639  			if yyms1 && yyv1 != nil {
 87640  				yyv1[yymk1] = yymv1
 87641  			}
 87642  		}
 87643  	} else if yyl1 < 0 {
 87644  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 87645  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 87646  			if r.TryDecodeAsNil() {
 87647  				yymk1 = ""
 87648  			} else {
 87649  				yyv5 := &yymk1
 87650  				yym6 := z.DecBinary()
 87651  				_ = yym6
 87652  				if false {
 87653  				} else {
 87654  					*((*string)(yyv5)) = r.DecodeString()
 87655  				}
 87656  			}
 87657  
 87658  			yyms1 = true
 87659  			if yymg1 {
 87660  				yymv1, yymok1 = yyv1[yymk1]
 87661  				if yymok1 {
 87662  					yyms1 = false
 87663  				}
 87664  			} else {
 87665  				yymv1 = nil
 87666  			}
 87667  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 87668  			if r.TryDecodeAsNil() {
 87669  				if yymv1 != nil {
 87670  					*yymv1 = Resources{}
 87671  				}
 87672  			} else {
 87673  				if yymv1 == nil {
 87674  					yymv1 = new(Resources)
 87675  				}
 87676  				yymv1.CodecDecodeSelf(d)
 87677  			}
 87678  
 87679  			if yyms1 && yyv1 != nil {
 87680  				yyv1[yymk1] = yymv1
 87681  			}
 87682  		}
 87683  	} // else len==0: TODO: Should we clear map entries?
 87684  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 87685  }
 87686  
 87687  func (x codecSelfer100) encMapstringPtrtoTaskState(v map[string]*TaskState, e *codec1978.Encoder) {
 87688  	var h codecSelfer100
 87689  	z, r := codec1978.GenHelperEncoder(e)
 87690  	_, _, _ = h, z, r
 87691  	r.EncodeMapStart(len(v))
 87692  	for yyk1, yyv1 := range v {
 87693  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 87694  		yym2 := z.EncBinary()
 87695  		_ = yym2
 87696  		if false {
 87697  		} else {
 87698  			r.EncodeString(codecSelferC_UTF8100, string(yyk1))
 87699  		}
 87700  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 87701  		if yyv1 == nil {
 87702  			r.EncodeNil()
 87703  		} else {
 87704  			yyv1.CodecEncodeSelf(e)
 87705  		}
 87706  	}
 87707  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 87708  }
 87709  
 87710  func (x codecSelfer100) decMapstringPtrtoTaskState(v *map[string]*TaskState, d *codec1978.Decoder) {
 87711  	var h codecSelfer100
 87712  	z, r := codec1978.GenHelperDecoder(d)
 87713  	_, _, _ = h, z, r
 87714  
 87715  	yyv1 := *v
 87716  	yyl1 := r.ReadMapStart()
 87717  	yybh1 := z.DecBasicHandle()
 87718  	if yyv1 == nil {
 87719  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 24)
 87720  		yyv1 = make(map[string]*TaskState, yyrl1)
 87721  		*v = yyv1
 87722  	}
 87723  	var yymk1 string
 87724  	var yymv1 *TaskState
 87725  	var yymg1, yyms1, yymok1 bool
 87726  	if yybh1.MapValueReset {
 87727  		yymg1 = true
 87728  	}
 87729  	if yyl1 > 0 {
 87730  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 87731  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 87732  			if r.TryDecodeAsNil() {
 87733  				yymk1 = ""
 87734  			} else {
 87735  				yyv2 := &yymk1
 87736  				yym3 := z.DecBinary()
 87737  				_ = yym3
 87738  				if false {
 87739  				} else {
 87740  					*((*string)(yyv2)) = r.DecodeString()
 87741  				}
 87742  			}
 87743  
 87744  			yyms1 = true
 87745  			if yymg1 {
 87746  				yymv1, yymok1 = yyv1[yymk1]
 87747  				if yymok1 {
 87748  					yyms1 = false
 87749  				}
 87750  			} else {
 87751  				yymv1 = nil
 87752  			}
 87753  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 87754  			if r.TryDecodeAsNil() {
 87755  				if yymv1 != nil {
 87756  					*yymv1 = TaskState{}
 87757  				}
 87758  			} else {
 87759  				if yymv1 == nil {
 87760  					yymv1 = new(TaskState)
 87761  				}
 87762  				yymv1.CodecDecodeSelf(d)
 87763  			}
 87764  
 87765  			if yyms1 && yyv1 != nil {
 87766  				yyv1[yymk1] = yymv1
 87767  			}
 87768  		}
 87769  	} else if yyl1 < 0 {
 87770  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 87771  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 87772  			if r.TryDecodeAsNil() {
 87773  				yymk1 = ""
 87774  			} else {
 87775  				yyv5 := &yymk1
 87776  				yym6 := z.DecBinary()
 87777  				_ = yym6
 87778  				if false {
 87779  				} else {
 87780  					*((*string)(yyv5)) = r.DecodeString()
 87781  				}
 87782  			}
 87783  
 87784  			yyms1 = true
 87785  			if yymg1 {
 87786  				yymv1, yymok1 = yyv1[yymk1]
 87787  				if yymok1 {
 87788  					yyms1 = false
 87789  				}
 87790  			} else {
 87791  				yymv1 = nil
 87792  			}
 87793  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 87794  			if r.TryDecodeAsNil() {
 87795  				if yymv1 != nil {
 87796  					*yymv1 = TaskState{}
 87797  				}
 87798  			} else {
 87799  				if yymv1 == nil {
 87800  					yymv1 = new(TaskState)
 87801  				}
 87802  				yymv1.CodecDecodeSelf(d)
 87803  			}
 87804  
 87805  			if yyms1 && yyv1 != nil {
 87806  				yyv1[yymk1] = yymv1
 87807  			}
 87808  		}
 87809  	} // else len==0: TODO: Should we clear map entries?
 87810  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 87811  }
 87812  
 87813  func (x codecSelfer100) encMapstringSlicePtrtoAllocation(v map[string][]*Allocation, e *codec1978.Encoder) {
 87814  	var h codecSelfer100
 87815  	z, r := codec1978.GenHelperEncoder(e)
 87816  	_, _, _ = h, z, r
 87817  	r.EncodeMapStart(len(v))
 87818  	for yyk1, yyv1 := range v {
 87819  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 87820  		yym2 := z.EncBinary()
 87821  		_ = yym2
 87822  		if false {
 87823  		} else {
 87824  			r.EncodeString(codecSelferC_UTF8100, string(yyk1))
 87825  		}
 87826  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 87827  		if yyv1 == nil {
 87828  			r.EncodeNil()
 87829  		} else {
 87830  			yym3 := z.EncBinary()
 87831  			_ = yym3
 87832  			if false {
 87833  			} else {
 87834  				h.encSlicePtrtoAllocation(([]*Allocation)(yyv1), e)
 87835  			}
 87836  		}
 87837  	}
 87838  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 87839  }
 87840  
 87841  func (x codecSelfer100) decMapstringSlicePtrtoAllocation(v *map[string][]*Allocation, d *codec1978.Decoder) {
 87842  	var h codecSelfer100
 87843  	z, r := codec1978.GenHelperDecoder(d)
 87844  	_, _, _ = h, z, r
 87845  
 87846  	yyv1 := *v
 87847  	yyl1 := r.ReadMapStart()
 87848  	yybh1 := z.DecBasicHandle()
 87849  	if yyv1 == nil {
 87850  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 40)
 87851  		yyv1 = make(map[string][]*Allocation, yyrl1)
 87852  		*v = yyv1
 87853  	}
 87854  	var yymk1 string
 87855  	var yymv1 []*Allocation
 87856  	var yymg1 bool
 87857  	if yybh1.MapValueReset {
 87858  		yymg1 = true
 87859  	}
 87860  	if yyl1 > 0 {
 87861  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 87862  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 87863  			if r.TryDecodeAsNil() {
 87864  				yymk1 = ""
 87865  			} else {
 87866  				yyv2 := &yymk1
 87867  				yym3 := z.DecBinary()
 87868  				_ = yym3
 87869  				if false {
 87870  				} else {
 87871  					*((*string)(yyv2)) = r.DecodeString()
 87872  				}
 87873  			}
 87874  
 87875  			if yymg1 {
 87876  				yymv1 = yyv1[yymk1]
 87877  			} else {
 87878  				yymv1 = nil
 87879  			}
 87880  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 87881  			if r.TryDecodeAsNil() {
 87882  				yymv1 = nil
 87883  			} else {
 87884  				yyv4 := &yymv1
 87885  				yym5 := z.DecBinary()
 87886  				_ = yym5
 87887  				if false {
 87888  				} else {
 87889  					h.decSlicePtrtoAllocation((*[]*Allocation)(yyv4), d)
 87890  				}
 87891  			}
 87892  
 87893  			if yyv1 != nil {
 87894  				yyv1[yymk1] = yymv1
 87895  			}
 87896  		}
 87897  	} else if yyl1 < 0 {
 87898  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 87899  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 87900  			if r.TryDecodeAsNil() {
 87901  				yymk1 = ""
 87902  			} else {
 87903  				yyv6 := &yymk1
 87904  				yym7 := z.DecBinary()
 87905  				_ = yym7
 87906  				if false {
 87907  				} else {
 87908  					*((*string)(yyv6)) = r.DecodeString()
 87909  				}
 87910  			}
 87911  
 87912  			if yymg1 {
 87913  				yymv1 = yyv1[yymk1]
 87914  			} else {
 87915  				yymv1 = nil
 87916  			}
 87917  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 87918  			if r.TryDecodeAsNil() {
 87919  				yymv1 = nil
 87920  			} else {
 87921  				yyv8 := &yymv1
 87922  				yym9 := z.DecBinary()
 87923  				_ = yym9
 87924  				if false {
 87925  				} else {
 87926  					h.decSlicePtrtoAllocation((*[]*Allocation)(yyv8), d)
 87927  				}
 87928  			}
 87929  
 87930  			if yyv1 != nil {
 87931  				yyv1[yymk1] = yymv1
 87932  			}
 87933  		}
 87934  	} // else len==0: TODO: Should we clear map entries?
 87935  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 87936  }
 87937  
 87938  func (x codecSelfer100) encMapstringPtrtoDesiredUpdates(v map[string]*DesiredUpdates, e *codec1978.Encoder) {
 87939  	var h codecSelfer100
 87940  	z, r := codec1978.GenHelperEncoder(e)
 87941  	_, _, _ = h, z, r
 87942  	r.EncodeMapStart(len(v))
 87943  	for yyk1, yyv1 := range v {
 87944  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 87945  		yym2 := z.EncBinary()
 87946  		_ = yym2
 87947  		if false {
 87948  		} else {
 87949  			r.EncodeString(codecSelferC_UTF8100, string(yyk1))
 87950  		}
 87951  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 87952  		if yyv1 == nil {
 87953  			r.EncodeNil()
 87954  		} else {
 87955  			yyv1.CodecEncodeSelf(e)
 87956  		}
 87957  	}
 87958  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 87959  }
 87960  
 87961  func (x codecSelfer100) decMapstringPtrtoDesiredUpdates(v *map[string]*DesiredUpdates, d *codec1978.Decoder) {
 87962  	var h codecSelfer100
 87963  	z, r := codec1978.GenHelperDecoder(d)
 87964  	_, _, _ = h, z, r
 87965  
 87966  	yyv1 := *v
 87967  	yyl1 := r.ReadMapStart()
 87968  	yybh1 := z.DecBasicHandle()
 87969  	if yyv1 == nil {
 87970  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 24)
 87971  		yyv1 = make(map[string]*DesiredUpdates, yyrl1)
 87972  		*v = yyv1
 87973  	}
 87974  	var yymk1 string
 87975  	var yymv1 *DesiredUpdates
 87976  	var yymg1, yyms1, yymok1 bool
 87977  	if yybh1.MapValueReset {
 87978  		yymg1 = true
 87979  	}
 87980  	if yyl1 > 0 {
 87981  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 87982  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 87983  			if r.TryDecodeAsNil() {
 87984  				yymk1 = ""
 87985  			} else {
 87986  				yyv2 := &yymk1
 87987  				yym3 := z.DecBinary()
 87988  				_ = yym3
 87989  				if false {
 87990  				} else {
 87991  					*((*string)(yyv2)) = r.DecodeString()
 87992  				}
 87993  			}
 87994  
 87995  			yyms1 = true
 87996  			if yymg1 {
 87997  				yymv1, yymok1 = yyv1[yymk1]
 87998  				if yymok1 {
 87999  					yyms1 = false
 88000  				}
 88001  			} else {
 88002  				yymv1 = nil
 88003  			}
 88004  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 88005  			if r.TryDecodeAsNil() {
 88006  				if yymv1 != nil {
 88007  					*yymv1 = DesiredUpdates{}
 88008  				}
 88009  			} else {
 88010  				if yymv1 == nil {
 88011  					yymv1 = new(DesiredUpdates)
 88012  				}
 88013  				yymv1.CodecDecodeSelf(d)
 88014  			}
 88015  
 88016  			if yyms1 && yyv1 != nil {
 88017  				yyv1[yymk1] = yymv1
 88018  			}
 88019  		}
 88020  	} else if yyl1 < 0 {
 88021  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 88022  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 88023  			if r.TryDecodeAsNil() {
 88024  				yymk1 = ""
 88025  			} else {
 88026  				yyv5 := &yymk1
 88027  				yym6 := z.DecBinary()
 88028  				_ = yym6
 88029  				if false {
 88030  				} else {
 88031  					*((*string)(yyv5)) = r.DecodeString()
 88032  				}
 88033  			}
 88034  
 88035  			yyms1 = true
 88036  			if yymg1 {
 88037  				yymv1, yymok1 = yyv1[yymk1]
 88038  				if yymok1 {
 88039  					yyms1 = false
 88040  				}
 88041  			} else {
 88042  				yymv1 = nil
 88043  			}
 88044  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 88045  			if r.TryDecodeAsNil() {
 88046  				if yymv1 != nil {
 88047  					*yymv1 = DesiredUpdates{}
 88048  				}
 88049  			} else {
 88050  				if yymv1 == nil {
 88051  					yymv1 = new(DesiredUpdates)
 88052  				}
 88053  				yymv1.CodecDecodeSelf(d)
 88054  			}
 88055  
 88056  			if yyms1 && yyv1 != nil {
 88057  				yyv1[yymk1] = yymv1
 88058  			}
 88059  		}
 88060  	} // else len==0: TODO: Should we clear map entries?
 88061  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 88062  }
 88063  
 88064  func (x codecSelfer100) encSlicePtrtoACLPolicyListStub(v []*ACLPolicyListStub, e *codec1978.Encoder) {
 88065  	var h codecSelfer100
 88066  	z, r := codec1978.GenHelperEncoder(e)
 88067  	_, _, _ = h, z, r
 88068  	r.EncodeArrayStart(len(v))
 88069  	for _, yyv1 := range v {
 88070  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 88071  		if yyv1 == nil {
 88072  			r.EncodeNil()
 88073  		} else {
 88074  			yyv1.CodecEncodeSelf(e)
 88075  		}
 88076  	}
 88077  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 88078  }
 88079  
 88080  func (x codecSelfer100) decSlicePtrtoACLPolicyListStub(v *[]*ACLPolicyListStub, d *codec1978.Decoder) {
 88081  	var h codecSelfer100
 88082  	z, r := codec1978.GenHelperDecoder(d)
 88083  	_, _, _ = h, z, r
 88084  
 88085  	yyv1 := *v
 88086  	yyh1, yyl1 := z.DecSliceHelperStart()
 88087  	var yyc1 bool
 88088  	_ = yyc1
 88089  	if yyl1 == 0 {
 88090  		if yyv1 == nil {
 88091  			yyv1 = []*ACLPolicyListStub{}
 88092  			yyc1 = true
 88093  		} else if len(yyv1) != 0 {
 88094  			yyv1 = yyv1[:0]
 88095  			yyc1 = true
 88096  		}
 88097  	} else if yyl1 > 0 {
 88098  		var yyrr1, yyrl1 int
 88099  		var yyrt1 bool
 88100  		_, _ = yyrl1, yyrt1
 88101  		yyrr1 = yyl1 // len(yyv1)
 88102  		if yyl1 > cap(yyv1) {
 88103  
 88104  			yyrg1 := len(yyv1) > 0
 88105  			yyv21 := yyv1
 88106  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 88107  			if yyrt1 {
 88108  				if yyrl1 <= cap(yyv1) {
 88109  					yyv1 = yyv1[:yyrl1]
 88110  				} else {
 88111  					yyv1 = make([]*ACLPolicyListStub, yyrl1)
 88112  				}
 88113  			} else {
 88114  				yyv1 = make([]*ACLPolicyListStub, yyrl1)
 88115  			}
 88116  			yyc1 = true
 88117  			yyrr1 = len(yyv1)
 88118  			if yyrg1 {
 88119  				copy(yyv1, yyv21)
 88120  			}
 88121  		} else if yyl1 != len(yyv1) {
 88122  			yyv1 = yyv1[:yyl1]
 88123  			yyc1 = true
 88124  		}
 88125  		yyj1 := 0
 88126  		for ; yyj1 < yyrr1; yyj1++ {
 88127  			yyh1.ElemContainerState(yyj1)
 88128  			if r.TryDecodeAsNil() {
 88129  				if yyv1[yyj1] != nil {
 88130  					*yyv1[yyj1] = ACLPolicyListStub{}
 88131  				}
 88132  			} else {
 88133  				if yyv1[yyj1] == nil {
 88134  					yyv1[yyj1] = new(ACLPolicyListStub)
 88135  				}
 88136  				yyw2 := yyv1[yyj1]
 88137  				yyw2.CodecDecodeSelf(d)
 88138  			}
 88139  
 88140  		}
 88141  		if yyrt1 {
 88142  			for ; yyj1 < yyl1; yyj1++ {
 88143  				yyv1 = append(yyv1, nil)
 88144  				yyh1.ElemContainerState(yyj1)
 88145  				if r.TryDecodeAsNil() {
 88146  					if yyv1[yyj1] != nil {
 88147  						*yyv1[yyj1] = ACLPolicyListStub{}
 88148  					}
 88149  				} else {
 88150  					if yyv1[yyj1] == nil {
 88151  						yyv1[yyj1] = new(ACLPolicyListStub)
 88152  					}
 88153  					yyw3 := yyv1[yyj1]
 88154  					yyw3.CodecDecodeSelf(d)
 88155  				}
 88156  
 88157  			}
 88158  		}
 88159  
 88160  	} else {
 88161  		yyj1 := 0
 88162  		for ; !r.CheckBreak(); yyj1++ {
 88163  
 88164  			if yyj1 >= len(yyv1) {
 88165  				yyv1 = append(yyv1, nil) // var yyz1 *ACLPolicyListStub
 88166  				yyc1 = true
 88167  			}
 88168  			yyh1.ElemContainerState(yyj1)
 88169  			if yyj1 < len(yyv1) {
 88170  				if r.TryDecodeAsNil() {
 88171  					if yyv1[yyj1] != nil {
 88172  						*yyv1[yyj1] = ACLPolicyListStub{}
 88173  					}
 88174  				} else {
 88175  					if yyv1[yyj1] == nil {
 88176  						yyv1[yyj1] = new(ACLPolicyListStub)
 88177  					}
 88178  					yyw4 := yyv1[yyj1]
 88179  					yyw4.CodecDecodeSelf(d)
 88180  				}
 88181  
 88182  			} else {
 88183  				z.DecSwallow()
 88184  			}
 88185  
 88186  		}
 88187  		if yyj1 < len(yyv1) {
 88188  			yyv1 = yyv1[:yyj1]
 88189  			yyc1 = true
 88190  		} else if yyj1 == 0 && yyv1 == nil {
 88191  			yyv1 = []*ACLPolicyListStub{}
 88192  			yyc1 = true
 88193  		}
 88194  	}
 88195  	yyh1.End()
 88196  	if yyc1 {
 88197  		*v = yyv1
 88198  	}
 88199  }
 88200  
 88201  func (x codecSelfer100) encMapstringPtrtoACLPolicy(v map[string]*ACLPolicy, e *codec1978.Encoder) {
 88202  	var h codecSelfer100
 88203  	z, r := codec1978.GenHelperEncoder(e)
 88204  	_, _, _ = h, z, r
 88205  	r.EncodeMapStart(len(v))
 88206  	for yyk1, yyv1 := range v {
 88207  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 88208  		yym2 := z.EncBinary()
 88209  		_ = yym2
 88210  		if false {
 88211  		} else {
 88212  			r.EncodeString(codecSelferC_UTF8100, string(yyk1))
 88213  		}
 88214  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 88215  		if yyv1 == nil {
 88216  			r.EncodeNil()
 88217  		} else {
 88218  			yyv1.CodecEncodeSelf(e)
 88219  		}
 88220  	}
 88221  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 88222  }
 88223  
 88224  func (x codecSelfer100) decMapstringPtrtoACLPolicy(v *map[string]*ACLPolicy, d *codec1978.Decoder) {
 88225  	var h codecSelfer100
 88226  	z, r := codec1978.GenHelperDecoder(d)
 88227  	_, _, _ = h, z, r
 88228  
 88229  	yyv1 := *v
 88230  	yyl1 := r.ReadMapStart()
 88231  	yybh1 := z.DecBasicHandle()
 88232  	if yyv1 == nil {
 88233  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 24)
 88234  		yyv1 = make(map[string]*ACLPolicy, yyrl1)
 88235  		*v = yyv1
 88236  	}
 88237  	var yymk1 string
 88238  	var yymv1 *ACLPolicy
 88239  	var yymg1, yyms1, yymok1 bool
 88240  	if yybh1.MapValueReset {
 88241  		yymg1 = true
 88242  	}
 88243  	if yyl1 > 0 {
 88244  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 88245  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 88246  			if r.TryDecodeAsNil() {
 88247  				yymk1 = ""
 88248  			} else {
 88249  				yyv2 := &yymk1
 88250  				yym3 := z.DecBinary()
 88251  				_ = yym3
 88252  				if false {
 88253  				} else {
 88254  					*((*string)(yyv2)) = r.DecodeString()
 88255  				}
 88256  			}
 88257  
 88258  			yyms1 = true
 88259  			if yymg1 {
 88260  				yymv1, yymok1 = yyv1[yymk1]
 88261  				if yymok1 {
 88262  					yyms1 = false
 88263  				}
 88264  			} else {
 88265  				yymv1 = nil
 88266  			}
 88267  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 88268  			if r.TryDecodeAsNil() {
 88269  				if yymv1 != nil {
 88270  					*yymv1 = ACLPolicy{}
 88271  				}
 88272  			} else {
 88273  				if yymv1 == nil {
 88274  					yymv1 = new(ACLPolicy)
 88275  				}
 88276  				yymv1.CodecDecodeSelf(d)
 88277  			}
 88278  
 88279  			if yyms1 && yyv1 != nil {
 88280  				yyv1[yymk1] = yymv1
 88281  			}
 88282  		}
 88283  	} else if yyl1 < 0 {
 88284  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 88285  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 88286  			if r.TryDecodeAsNil() {
 88287  				yymk1 = ""
 88288  			} else {
 88289  				yyv5 := &yymk1
 88290  				yym6 := z.DecBinary()
 88291  				_ = yym6
 88292  				if false {
 88293  				} else {
 88294  					*((*string)(yyv5)) = r.DecodeString()
 88295  				}
 88296  			}
 88297  
 88298  			yyms1 = true
 88299  			if yymg1 {
 88300  				yymv1, yymok1 = yyv1[yymk1]
 88301  				if yymok1 {
 88302  					yyms1 = false
 88303  				}
 88304  			} else {
 88305  				yymv1 = nil
 88306  			}
 88307  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 88308  			if r.TryDecodeAsNil() {
 88309  				if yymv1 != nil {
 88310  					*yymv1 = ACLPolicy{}
 88311  				}
 88312  			} else {
 88313  				if yymv1 == nil {
 88314  					yymv1 = new(ACLPolicy)
 88315  				}
 88316  				yymv1.CodecDecodeSelf(d)
 88317  			}
 88318  
 88319  			if yyms1 && yyv1 != nil {
 88320  				yyv1[yymk1] = yymv1
 88321  			}
 88322  		}
 88323  	} // else len==0: TODO: Should we clear map entries?
 88324  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 88325  }
 88326  
 88327  func (x codecSelfer100) encSlicePtrtoACLPolicy(v []*ACLPolicy, e *codec1978.Encoder) {
 88328  	var h codecSelfer100
 88329  	z, r := codec1978.GenHelperEncoder(e)
 88330  	_, _, _ = h, z, r
 88331  	r.EncodeArrayStart(len(v))
 88332  	for _, yyv1 := range v {
 88333  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 88334  		if yyv1 == nil {
 88335  			r.EncodeNil()
 88336  		} else {
 88337  			yyv1.CodecEncodeSelf(e)
 88338  		}
 88339  	}
 88340  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 88341  }
 88342  
 88343  func (x codecSelfer100) decSlicePtrtoACLPolicy(v *[]*ACLPolicy, d *codec1978.Decoder) {
 88344  	var h codecSelfer100
 88345  	z, r := codec1978.GenHelperDecoder(d)
 88346  	_, _, _ = h, z, r
 88347  
 88348  	yyv1 := *v
 88349  	yyh1, yyl1 := z.DecSliceHelperStart()
 88350  	var yyc1 bool
 88351  	_ = yyc1
 88352  	if yyl1 == 0 {
 88353  		if yyv1 == nil {
 88354  			yyv1 = []*ACLPolicy{}
 88355  			yyc1 = true
 88356  		} else if len(yyv1) != 0 {
 88357  			yyv1 = yyv1[:0]
 88358  			yyc1 = true
 88359  		}
 88360  	} else if yyl1 > 0 {
 88361  		var yyrr1, yyrl1 int
 88362  		var yyrt1 bool
 88363  		_, _ = yyrl1, yyrt1
 88364  		yyrr1 = yyl1 // len(yyv1)
 88365  		if yyl1 > cap(yyv1) {
 88366  
 88367  			yyrg1 := len(yyv1) > 0
 88368  			yyv21 := yyv1
 88369  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 88370  			if yyrt1 {
 88371  				if yyrl1 <= cap(yyv1) {
 88372  					yyv1 = yyv1[:yyrl1]
 88373  				} else {
 88374  					yyv1 = make([]*ACLPolicy, yyrl1)
 88375  				}
 88376  			} else {
 88377  				yyv1 = make([]*ACLPolicy, yyrl1)
 88378  			}
 88379  			yyc1 = true
 88380  			yyrr1 = len(yyv1)
 88381  			if yyrg1 {
 88382  				copy(yyv1, yyv21)
 88383  			}
 88384  		} else if yyl1 != len(yyv1) {
 88385  			yyv1 = yyv1[:yyl1]
 88386  			yyc1 = true
 88387  		}
 88388  		yyj1 := 0
 88389  		for ; yyj1 < yyrr1; yyj1++ {
 88390  			yyh1.ElemContainerState(yyj1)
 88391  			if r.TryDecodeAsNil() {
 88392  				if yyv1[yyj1] != nil {
 88393  					*yyv1[yyj1] = ACLPolicy{}
 88394  				}
 88395  			} else {
 88396  				if yyv1[yyj1] == nil {
 88397  					yyv1[yyj1] = new(ACLPolicy)
 88398  				}
 88399  				yyw2 := yyv1[yyj1]
 88400  				yyw2.CodecDecodeSelf(d)
 88401  			}
 88402  
 88403  		}
 88404  		if yyrt1 {
 88405  			for ; yyj1 < yyl1; yyj1++ {
 88406  				yyv1 = append(yyv1, nil)
 88407  				yyh1.ElemContainerState(yyj1)
 88408  				if r.TryDecodeAsNil() {
 88409  					if yyv1[yyj1] != nil {
 88410  						*yyv1[yyj1] = ACLPolicy{}
 88411  					}
 88412  				} else {
 88413  					if yyv1[yyj1] == nil {
 88414  						yyv1[yyj1] = new(ACLPolicy)
 88415  					}
 88416  					yyw3 := yyv1[yyj1]
 88417  					yyw3.CodecDecodeSelf(d)
 88418  				}
 88419  
 88420  			}
 88421  		}
 88422  
 88423  	} else {
 88424  		yyj1 := 0
 88425  		for ; !r.CheckBreak(); yyj1++ {
 88426  
 88427  			if yyj1 >= len(yyv1) {
 88428  				yyv1 = append(yyv1, nil) // var yyz1 *ACLPolicy
 88429  				yyc1 = true
 88430  			}
 88431  			yyh1.ElemContainerState(yyj1)
 88432  			if yyj1 < len(yyv1) {
 88433  				if r.TryDecodeAsNil() {
 88434  					if yyv1[yyj1] != nil {
 88435  						*yyv1[yyj1] = ACLPolicy{}
 88436  					}
 88437  				} else {
 88438  					if yyv1[yyj1] == nil {
 88439  						yyv1[yyj1] = new(ACLPolicy)
 88440  					}
 88441  					yyw4 := yyv1[yyj1]
 88442  					yyw4.CodecDecodeSelf(d)
 88443  				}
 88444  
 88445  			} else {
 88446  				z.DecSwallow()
 88447  			}
 88448  
 88449  		}
 88450  		if yyj1 < len(yyv1) {
 88451  			yyv1 = yyv1[:yyj1]
 88452  			yyc1 = true
 88453  		} else if yyj1 == 0 && yyv1 == nil {
 88454  			yyv1 = []*ACLPolicy{}
 88455  			yyc1 = true
 88456  		}
 88457  	}
 88458  	yyh1.End()
 88459  	if yyc1 {
 88460  		*v = yyv1
 88461  	}
 88462  }
 88463  
 88464  func (x codecSelfer100) encSlicePtrtoACLTokenListStub(v []*ACLTokenListStub, e *codec1978.Encoder) {
 88465  	var h codecSelfer100
 88466  	z, r := codec1978.GenHelperEncoder(e)
 88467  	_, _, _ = h, z, r
 88468  	r.EncodeArrayStart(len(v))
 88469  	for _, yyv1 := range v {
 88470  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 88471  		if yyv1 == nil {
 88472  			r.EncodeNil()
 88473  		} else {
 88474  			yyv1.CodecEncodeSelf(e)
 88475  		}
 88476  	}
 88477  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 88478  }
 88479  
 88480  func (x codecSelfer100) decSlicePtrtoACLTokenListStub(v *[]*ACLTokenListStub, d *codec1978.Decoder) {
 88481  	var h codecSelfer100
 88482  	z, r := codec1978.GenHelperDecoder(d)
 88483  	_, _, _ = h, z, r
 88484  
 88485  	yyv1 := *v
 88486  	yyh1, yyl1 := z.DecSliceHelperStart()
 88487  	var yyc1 bool
 88488  	_ = yyc1
 88489  	if yyl1 == 0 {
 88490  		if yyv1 == nil {
 88491  			yyv1 = []*ACLTokenListStub{}
 88492  			yyc1 = true
 88493  		} else if len(yyv1) != 0 {
 88494  			yyv1 = yyv1[:0]
 88495  			yyc1 = true
 88496  		}
 88497  	} else if yyl1 > 0 {
 88498  		var yyrr1, yyrl1 int
 88499  		var yyrt1 bool
 88500  		_, _ = yyrl1, yyrt1
 88501  		yyrr1 = yyl1 // len(yyv1)
 88502  		if yyl1 > cap(yyv1) {
 88503  
 88504  			yyrg1 := len(yyv1) > 0
 88505  			yyv21 := yyv1
 88506  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 88507  			if yyrt1 {
 88508  				if yyrl1 <= cap(yyv1) {
 88509  					yyv1 = yyv1[:yyrl1]
 88510  				} else {
 88511  					yyv1 = make([]*ACLTokenListStub, yyrl1)
 88512  				}
 88513  			} else {
 88514  				yyv1 = make([]*ACLTokenListStub, yyrl1)
 88515  			}
 88516  			yyc1 = true
 88517  			yyrr1 = len(yyv1)
 88518  			if yyrg1 {
 88519  				copy(yyv1, yyv21)
 88520  			}
 88521  		} else if yyl1 != len(yyv1) {
 88522  			yyv1 = yyv1[:yyl1]
 88523  			yyc1 = true
 88524  		}
 88525  		yyj1 := 0
 88526  		for ; yyj1 < yyrr1; yyj1++ {
 88527  			yyh1.ElemContainerState(yyj1)
 88528  			if r.TryDecodeAsNil() {
 88529  				if yyv1[yyj1] != nil {
 88530  					*yyv1[yyj1] = ACLTokenListStub{}
 88531  				}
 88532  			} else {
 88533  				if yyv1[yyj1] == nil {
 88534  					yyv1[yyj1] = new(ACLTokenListStub)
 88535  				}
 88536  				yyw2 := yyv1[yyj1]
 88537  				yyw2.CodecDecodeSelf(d)
 88538  			}
 88539  
 88540  		}
 88541  		if yyrt1 {
 88542  			for ; yyj1 < yyl1; yyj1++ {
 88543  				yyv1 = append(yyv1, nil)
 88544  				yyh1.ElemContainerState(yyj1)
 88545  				if r.TryDecodeAsNil() {
 88546  					if yyv1[yyj1] != nil {
 88547  						*yyv1[yyj1] = ACLTokenListStub{}
 88548  					}
 88549  				} else {
 88550  					if yyv1[yyj1] == nil {
 88551  						yyv1[yyj1] = new(ACLTokenListStub)
 88552  					}
 88553  					yyw3 := yyv1[yyj1]
 88554  					yyw3.CodecDecodeSelf(d)
 88555  				}
 88556  
 88557  			}
 88558  		}
 88559  
 88560  	} else {
 88561  		yyj1 := 0
 88562  		for ; !r.CheckBreak(); yyj1++ {
 88563  
 88564  			if yyj1 >= len(yyv1) {
 88565  				yyv1 = append(yyv1, nil) // var yyz1 *ACLTokenListStub
 88566  				yyc1 = true
 88567  			}
 88568  			yyh1.ElemContainerState(yyj1)
 88569  			if yyj1 < len(yyv1) {
 88570  				if r.TryDecodeAsNil() {
 88571  					if yyv1[yyj1] != nil {
 88572  						*yyv1[yyj1] = ACLTokenListStub{}
 88573  					}
 88574  				} else {
 88575  					if yyv1[yyj1] == nil {
 88576  						yyv1[yyj1] = new(ACLTokenListStub)
 88577  					}
 88578  					yyw4 := yyv1[yyj1]
 88579  					yyw4.CodecDecodeSelf(d)
 88580  				}
 88581  
 88582  			} else {
 88583  				z.DecSwallow()
 88584  			}
 88585  
 88586  		}
 88587  		if yyj1 < len(yyv1) {
 88588  			yyv1 = yyv1[:yyj1]
 88589  			yyc1 = true
 88590  		} else if yyj1 == 0 && yyv1 == nil {
 88591  			yyv1 = []*ACLTokenListStub{}
 88592  			yyc1 = true
 88593  		}
 88594  	}
 88595  	yyh1.End()
 88596  	if yyc1 {
 88597  		*v = yyv1
 88598  	}
 88599  }
 88600  
 88601  func (x codecSelfer100) encMapstringPtrtoACLToken(v map[string]*ACLToken, e *codec1978.Encoder) {
 88602  	var h codecSelfer100
 88603  	z, r := codec1978.GenHelperEncoder(e)
 88604  	_, _, _ = h, z, r
 88605  	r.EncodeMapStart(len(v))
 88606  	for yyk1, yyv1 := range v {
 88607  		z.EncSendContainerState(codecSelfer_containerMapKey100)
 88608  		yym2 := z.EncBinary()
 88609  		_ = yym2
 88610  		if false {
 88611  		} else {
 88612  			r.EncodeString(codecSelferC_UTF8100, string(yyk1))
 88613  		}
 88614  		z.EncSendContainerState(codecSelfer_containerMapValue100)
 88615  		if yyv1 == nil {
 88616  			r.EncodeNil()
 88617  		} else {
 88618  			yyv1.CodecEncodeSelf(e)
 88619  		}
 88620  	}
 88621  	z.EncSendContainerState(codecSelfer_containerMapEnd100)
 88622  }
 88623  
 88624  func (x codecSelfer100) decMapstringPtrtoACLToken(v *map[string]*ACLToken, d *codec1978.Decoder) {
 88625  	var h codecSelfer100
 88626  	z, r := codec1978.GenHelperDecoder(d)
 88627  	_, _, _ = h, z, r
 88628  
 88629  	yyv1 := *v
 88630  	yyl1 := r.ReadMapStart()
 88631  	yybh1 := z.DecBasicHandle()
 88632  	if yyv1 == nil {
 88633  		yyrl1, _ := z.DecInferLen(yyl1, yybh1.MaxInitLen, 24)
 88634  		yyv1 = make(map[string]*ACLToken, yyrl1)
 88635  		*v = yyv1
 88636  	}
 88637  	var yymk1 string
 88638  	var yymv1 *ACLToken
 88639  	var yymg1, yyms1, yymok1 bool
 88640  	if yybh1.MapValueReset {
 88641  		yymg1 = true
 88642  	}
 88643  	if yyl1 > 0 {
 88644  		for yyj1 := 0; yyj1 < yyl1; yyj1++ {
 88645  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 88646  			if r.TryDecodeAsNil() {
 88647  				yymk1 = ""
 88648  			} else {
 88649  				yyv2 := &yymk1
 88650  				yym3 := z.DecBinary()
 88651  				_ = yym3
 88652  				if false {
 88653  				} else {
 88654  					*((*string)(yyv2)) = r.DecodeString()
 88655  				}
 88656  			}
 88657  
 88658  			yyms1 = true
 88659  			if yymg1 {
 88660  				yymv1, yymok1 = yyv1[yymk1]
 88661  				if yymok1 {
 88662  					yyms1 = false
 88663  				}
 88664  			} else {
 88665  				yymv1 = nil
 88666  			}
 88667  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 88668  			if r.TryDecodeAsNil() {
 88669  				if yymv1 != nil {
 88670  					*yymv1 = ACLToken{}
 88671  				}
 88672  			} else {
 88673  				if yymv1 == nil {
 88674  					yymv1 = new(ACLToken)
 88675  				}
 88676  				yymv1.CodecDecodeSelf(d)
 88677  			}
 88678  
 88679  			if yyms1 && yyv1 != nil {
 88680  				yyv1[yymk1] = yymv1
 88681  			}
 88682  		}
 88683  	} else if yyl1 < 0 {
 88684  		for yyj1 := 0; !r.CheckBreak(); yyj1++ {
 88685  			z.DecSendContainerState(codecSelfer_containerMapKey100)
 88686  			if r.TryDecodeAsNil() {
 88687  				yymk1 = ""
 88688  			} else {
 88689  				yyv5 := &yymk1
 88690  				yym6 := z.DecBinary()
 88691  				_ = yym6
 88692  				if false {
 88693  				} else {
 88694  					*((*string)(yyv5)) = r.DecodeString()
 88695  				}
 88696  			}
 88697  
 88698  			yyms1 = true
 88699  			if yymg1 {
 88700  				yymv1, yymok1 = yyv1[yymk1]
 88701  				if yymok1 {
 88702  					yyms1 = false
 88703  				}
 88704  			} else {
 88705  				yymv1 = nil
 88706  			}
 88707  			z.DecSendContainerState(codecSelfer_containerMapValue100)
 88708  			if r.TryDecodeAsNil() {
 88709  				if yymv1 != nil {
 88710  					*yymv1 = ACLToken{}
 88711  				}
 88712  			} else {
 88713  				if yymv1 == nil {
 88714  					yymv1 = new(ACLToken)
 88715  				}
 88716  				yymv1.CodecDecodeSelf(d)
 88717  			}
 88718  
 88719  			if yyms1 && yyv1 != nil {
 88720  				yyv1[yymk1] = yymv1
 88721  			}
 88722  		}
 88723  	} // else len==0: TODO: Should we clear map entries?
 88724  	z.DecSendContainerState(codecSelfer_containerMapEnd100)
 88725  }
 88726  
 88727  func (x codecSelfer100) encSlicePtrtoACLToken(v []*ACLToken, e *codec1978.Encoder) {
 88728  	var h codecSelfer100
 88729  	z, r := codec1978.GenHelperEncoder(e)
 88730  	_, _, _ = h, z, r
 88731  	r.EncodeArrayStart(len(v))
 88732  	for _, yyv1 := range v {
 88733  		z.EncSendContainerState(codecSelfer_containerArrayElem100)
 88734  		if yyv1 == nil {
 88735  			r.EncodeNil()
 88736  		} else {
 88737  			yyv1.CodecEncodeSelf(e)
 88738  		}
 88739  	}
 88740  	z.EncSendContainerState(codecSelfer_containerArrayEnd100)
 88741  }
 88742  
 88743  func (x codecSelfer100) decSlicePtrtoACLToken(v *[]*ACLToken, d *codec1978.Decoder) {
 88744  	var h codecSelfer100
 88745  	z, r := codec1978.GenHelperDecoder(d)
 88746  	_, _, _ = h, z, r
 88747  
 88748  	yyv1 := *v
 88749  	yyh1, yyl1 := z.DecSliceHelperStart()
 88750  	var yyc1 bool
 88751  	_ = yyc1
 88752  	if yyl1 == 0 {
 88753  		if yyv1 == nil {
 88754  			yyv1 = []*ACLToken{}
 88755  			yyc1 = true
 88756  		} else if len(yyv1) != 0 {
 88757  			yyv1 = yyv1[:0]
 88758  			yyc1 = true
 88759  		}
 88760  	} else if yyl1 > 0 {
 88761  		var yyrr1, yyrl1 int
 88762  		var yyrt1 bool
 88763  		_, _ = yyrl1, yyrt1
 88764  		yyrr1 = yyl1 // len(yyv1)
 88765  		if yyl1 > cap(yyv1) {
 88766  
 88767  			yyrg1 := len(yyv1) > 0
 88768  			yyv21 := yyv1
 88769  			yyrl1, yyrt1 = z.DecInferLen(yyl1, z.DecBasicHandle().MaxInitLen, 8)
 88770  			if yyrt1 {
 88771  				if yyrl1 <= cap(yyv1) {
 88772  					yyv1 = yyv1[:yyrl1]
 88773  				} else {
 88774  					yyv1 = make([]*ACLToken, yyrl1)
 88775  				}
 88776  			} else {
 88777  				yyv1 = make([]*ACLToken, yyrl1)
 88778  			}
 88779  			yyc1 = true
 88780  			yyrr1 = len(yyv1)
 88781  			if yyrg1 {
 88782  				copy(yyv1, yyv21)
 88783  			}
 88784  		} else if yyl1 != len(yyv1) {
 88785  			yyv1 = yyv1[:yyl1]
 88786  			yyc1 = true
 88787  		}
 88788  		yyj1 := 0
 88789  		for ; yyj1 < yyrr1; yyj1++ {
 88790  			yyh1.ElemContainerState(yyj1)
 88791  			if r.TryDecodeAsNil() {
 88792  				if yyv1[yyj1] != nil {
 88793  					*yyv1[yyj1] = ACLToken{}
 88794  				}
 88795  			} else {
 88796  				if yyv1[yyj1] == nil {
 88797  					yyv1[yyj1] = new(ACLToken)
 88798  				}
 88799  				yyw2 := yyv1[yyj1]
 88800  				yyw2.CodecDecodeSelf(d)
 88801  			}
 88802  
 88803  		}
 88804  		if yyrt1 {
 88805  			for ; yyj1 < yyl1; yyj1++ {
 88806  				yyv1 = append(yyv1, nil)
 88807  				yyh1.ElemContainerState(yyj1)
 88808  				if r.TryDecodeAsNil() {
 88809  					if yyv1[yyj1] != nil {
 88810  						*yyv1[yyj1] = ACLToken{}
 88811  					}
 88812  				} else {
 88813  					if yyv1[yyj1] == nil {
 88814  						yyv1[yyj1] = new(ACLToken)
 88815  					}
 88816  					yyw3 := yyv1[yyj1]
 88817  					yyw3.CodecDecodeSelf(d)
 88818  				}
 88819  
 88820  			}
 88821  		}
 88822  
 88823  	} else {
 88824  		yyj1 := 0
 88825  		for ; !r.CheckBreak(); yyj1++ {
 88826  
 88827  			if yyj1 >= len(yyv1) {
 88828  				yyv1 = append(yyv1, nil) // var yyz1 *ACLToken
 88829  				yyc1 = true
 88830  			}
 88831  			yyh1.ElemContainerState(yyj1)
 88832  			if yyj1 < len(yyv1) {
 88833  				if r.TryDecodeAsNil() {
 88834  					if yyv1[yyj1] != nil {
 88835  						*yyv1[yyj1] = ACLToken{}
 88836  					}
 88837  				} else {
 88838  					if yyv1[yyj1] == nil {
 88839  						yyv1[yyj1] = new(ACLToken)
 88840  					}
 88841  					yyw4 := yyv1[yyj1]
 88842  					yyw4.CodecDecodeSelf(d)
 88843  				}
 88844  
 88845  			} else {
 88846  				z.DecSwallow()
 88847  			}
 88848  
 88849  		}
 88850  		if yyj1 < len(yyv1) {
 88851  			yyv1 = yyv1[:yyj1]
 88852  			yyc1 = true
 88853  		} else if yyj1 == 0 && yyv1 == nil {
 88854  			yyv1 = []*ACLToken{}
 88855  			yyc1 = true
 88856  		}
 88857  	}
 88858  	yyh1.End()
 88859  	if yyc1 {
 88860  		*v = yyv1
 88861  	}
 88862  }