github.com/castai/kvisor@v1.7.1-0.20240516114728-b3572a2607b5/pkg/ebpftracer/decoder/args_decoder.go (about)

     1  // Code generated by tools/codegen; DO NOT EDIT.
     2  
     3  package decoder
     4  
     5  import (
     6    "errors"
     7  
     8    "github.com/castai/kvisor/pkg/ebpftracer/events"
     9    "github.com/castai/kvisor/pkg/ebpftracer/types"
    10  )
    11  
    12  var (
    13    ErrUnknownArgsType error = errors.New("unknown args type")
    14  )
    15  
    16  // eventMaxByteSliceBufferSize is used to determine the max slice size allowed for different
    17  // event types. For example, most events have a max size of 4096, but for network related events
    18  // there is no max size (this is represented as -1).
    19  func eventMaxByteSliceBufferSize(id events.ID) int {
    20    // For non network event, we have a max byte slice size of 4096
    21    if id < events.NetPacketBase || id > events.MaxNetID {
    22      return 4096
    23    }
    24  
    25    // Network events do not have a max buffer size.
    26    return -1
    27  }
    28  
    29  func ParseReadArgs(decoder *Decoder) (types.ReadArgs, error) {
    30    var result types.ReadArgs
    31    var err error
    32  
    33    var numArgs uint8
    34    err = decoder.DecodeUint8(&numArgs)
    35    if err != nil {
    36      return types.ReadArgs{}, err
    37    }
    38  
    39    for arg := 0; arg < int(numArgs); arg++ {
    40      var currArg uint8
    41      err = decoder.DecodeUint8(&currArg)
    42      if err != nil {
    43        return types.ReadArgs{}, err
    44      }
    45  
    46      switch currArg {
    47      case 0:
    48        err = decoder.DecodeInt32(&result.Fd)
    49        if err != nil {
    50          return types.ReadArgs{}, err
    51        }
    52      case 1:
    53        var dataBuf uint64
    54        err = decoder.DecodeUint64(&dataBuf)
    55        if err != nil {
    56          return types.ReadArgs{}, err
    57        }
    58        result.Buf = uintptr(dataBuf)
    59      case 2:
    60        err = decoder.DecodeUint64(&result.Count)
    61        if err != nil {
    62          return types.ReadArgs{}, err
    63        }
    64      }
    65    }
    66    return result, nil
    67  }
    68  
    69  func ParseWriteArgs(decoder *Decoder) (types.WriteArgs, error) {
    70    var result types.WriteArgs
    71    var err error
    72  
    73    var numArgs uint8
    74    err = decoder.DecodeUint8(&numArgs)
    75    if err != nil {
    76      return types.WriteArgs{}, err
    77    }
    78  
    79    for arg := 0; arg < int(numArgs); arg++ {
    80      var currArg uint8
    81      err = decoder.DecodeUint8(&currArg)
    82      if err != nil {
    83        return types.WriteArgs{}, err
    84      }
    85  
    86      switch currArg {
    87      case 0:
    88        err = decoder.DecodeInt32(&result.Fd)
    89        if err != nil {
    90          return types.WriteArgs{}, err
    91        }
    92      case 1:
    93        var dataBuf uint64
    94        err = decoder.DecodeUint64(&dataBuf)
    95        if err != nil {
    96          return types.WriteArgs{}, err
    97        }
    98        result.Buf = uintptr(dataBuf)
    99      case 2:
   100        err = decoder.DecodeUint64(&result.Count)
   101        if err != nil {
   102          return types.WriteArgs{}, err
   103        }
   104      }
   105    }
   106    return result, nil
   107  }
   108  
   109  func ParseOpenArgs(decoder *Decoder) (types.OpenArgs, error) {
   110    var result types.OpenArgs
   111    var err error
   112  
   113    var numArgs uint8
   114    err = decoder.DecodeUint8(&numArgs)
   115    if err != nil {
   116      return types.OpenArgs{}, err
   117    }
   118  
   119    for arg := 0; arg < int(numArgs); arg++ {
   120      var currArg uint8
   121      err = decoder.DecodeUint8(&currArg)
   122      if err != nil {
   123        return types.OpenArgs{}, err
   124      }
   125  
   126      switch currArg {
   127      case 0:
   128        result.Pathname, err = decoder.ReadStringFromBuff()
   129        if err != nil {
   130          return types.OpenArgs{}, err
   131        }
   132      case 1:
   133        err = decoder.DecodeInt32(&result.Flags)
   134        if err != nil {
   135          return types.OpenArgs{}, err
   136        }
   137      case 2:
   138        err = decoder.DecodeUint32(&result.Mode)
   139        if err != nil {
   140          return types.OpenArgs{}, err
   141        }
   142      }
   143    }
   144    return result, nil
   145  }
   146  
   147  func ParseCloseArgs(decoder *Decoder) (types.CloseArgs, error) {
   148    var result types.CloseArgs
   149    var err error
   150  
   151    var numArgs uint8
   152    err = decoder.DecodeUint8(&numArgs)
   153    if err != nil {
   154      return types.CloseArgs{}, err
   155    }
   156  
   157    for arg := 0; arg < int(numArgs); arg++ {
   158      var currArg uint8
   159      err = decoder.DecodeUint8(&currArg)
   160      if err != nil {
   161        return types.CloseArgs{}, err
   162      }
   163  
   164      switch currArg {
   165      case 0:
   166        err = decoder.DecodeInt32(&result.Fd)
   167        if err != nil {
   168          return types.CloseArgs{}, err
   169        }
   170      }
   171    }
   172    return result, nil
   173  }
   174  
   175  func ParseStatArgs(decoder *Decoder) (types.StatArgs, error) {
   176    var result types.StatArgs
   177    var err error
   178  
   179    var numArgs uint8
   180    err = decoder.DecodeUint8(&numArgs)
   181    if err != nil {
   182      return types.StatArgs{}, err
   183    }
   184  
   185    for arg := 0; arg < int(numArgs); arg++ {
   186      var currArg uint8
   187      err = decoder.DecodeUint8(&currArg)
   188      if err != nil {
   189        return types.StatArgs{}, err
   190      }
   191  
   192      switch currArg {
   193      case 0:
   194        result.Pathname, err = decoder.ReadStringFromBuff()
   195        if err != nil {
   196          return types.StatArgs{}, err
   197        }
   198      case 1:
   199        var dataStatbuf uint64
   200        err = decoder.DecodeUint64(&dataStatbuf)
   201        if err != nil {
   202          return types.StatArgs{}, err
   203        }
   204        result.Statbuf = uintptr(dataStatbuf)
   205      }
   206    }
   207    return result, nil
   208  }
   209  
   210  func ParseFstatArgs(decoder *Decoder) (types.FstatArgs, error) {
   211    var result types.FstatArgs
   212    var err error
   213  
   214    var numArgs uint8
   215    err = decoder.DecodeUint8(&numArgs)
   216    if err != nil {
   217      return types.FstatArgs{}, err
   218    }
   219  
   220    for arg := 0; arg < int(numArgs); arg++ {
   221      var currArg uint8
   222      err = decoder.DecodeUint8(&currArg)
   223      if err != nil {
   224        return types.FstatArgs{}, err
   225      }
   226  
   227      switch currArg {
   228      case 0:
   229        err = decoder.DecodeInt32(&result.Fd)
   230        if err != nil {
   231          return types.FstatArgs{}, err
   232        }
   233      case 1:
   234        var dataStatbuf uint64
   235        err = decoder.DecodeUint64(&dataStatbuf)
   236        if err != nil {
   237          return types.FstatArgs{}, err
   238        }
   239        result.Statbuf = uintptr(dataStatbuf)
   240      }
   241    }
   242    return result, nil
   243  }
   244  
   245  func ParseLstatArgs(decoder *Decoder) (types.LstatArgs, error) {
   246    var result types.LstatArgs
   247    var err error
   248  
   249    var numArgs uint8
   250    err = decoder.DecodeUint8(&numArgs)
   251    if err != nil {
   252      return types.LstatArgs{}, err
   253    }
   254  
   255    for arg := 0; arg < int(numArgs); arg++ {
   256      var currArg uint8
   257      err = decoder.DecodeUint8(&currArg)
   258      if err != nil {
   259        return types.LstatArgs{}, err
   260      }
   261  
   262      switch currArg {
   263      case 0:
   264        result.Pathname, err = decoder.ReadStringFromBuff()
   265        if err != nil {
   266          return types.LstatArgs{}, err
   267        }
   268      case 1:
   269        var dataStatbuf uint64
   270        err = decoder.DecodeUint64(&dataStatbuf)
   271        if err != nil {
   272          return types.LstatArgs{}, err
   273        }
   274        result.Statbuf = uintptr(dataStatbuf)
   275      }
   276    }
   277    return result, nil
   278  }
   279  
   280  func ParsePollArgs(decoder *Decoder) (types.PollArgs, error) {
   281    var result types.PollArgs
   282    var err error
   283  
   284    var numArgs uint8
   285    err = decoder.DecodeUint8(&numArgs)
   286    if err != nil {
   287      return types.PollArgs{}, err
   288    }
   289  
   290    for arg := 0; arg < int(numArgs); arg++ {
   291      var currArg uint8
   292      err = decoder.DecodeUint8(&currArg)
   293      if err != nil {
   294        return types.PollArgs{}, err
   295      }
   296  
   297      switch currArg {
   298      case 0:
   299        var dataFds uint64
   300        err = decoder.DecodeUint64(&dataFds)
   301        if err != nil {
   302          return types.PollArgs{}, err
   303        }
   304        result.Fds = uintptr(dataFds)
   305      case 1:
   306        err = decoder.DecodeUint32(&result.Nfds)
   307        if err != nil {
   308          return types.PollArgs{}, err
   309        }
   310      case 2:
   311        err = decoder.DecodeInt32(&result.Timeout)
   312        if err != nil {
   313          return types.PollArgs{}, err
   314        }
   315      }
   316    }
   317    return result, nil
   318  }
   319  
   320  func ParseLseekArgs(decoder *Decoder) (types.LseekArgs, error) {
   321    var result types.LseekArgs
   322    var err error
   323  
   324    var numArgs uint8
   325    err = decoder.DecodeUint8(&numArgs)
   326    if err != nil {
   327      return types.LseekArgs{}, err
   328    }
   329  
   330    for arg := 0; arg < int(numArgs); arg++ {
   331      var currArg uint8
   332      err = decoder.DecodeUint8(&currArg)
   333      if err != nil {
   334        return types.LseekArgs{}, err
   335      }
   336  
   337      switch currArg {
   338      case 0:
   339        err = decoder.DecodeInt32(&result.Fd)
   340        if err != nil {
   341          return types.LseekArgs{}, err
   342        }
   343      case 1:
   344        err = decoder.DecodeUint64(&result.Offset)
   345        if err != nil {
   346          return types.LseekArgs{}, err
   347        }
   348      case 2:
   349        err = decoder.DecodeUint32(&result.Whence)
   350        if err != nil {
   351          return types.LseekArgs{}, err
   352        }
   353      }
   354    }
   355    return result, nil
   356  }
   357  
   358  func ParseMmapArgs(decoder *Decoder) (types.MmapArgs, error) {
   359    var result types.MmapArgs
   360    var err error
   361  
   362    var numArgs uint8
   363    err = decoder.DecodeUint8(&numArgs)
   364    if err != nil {
   365      return types.MmapArgs{}, err
   366    }
   367  
   368    for arg := 0; arg < int(numArgs); arg++ {
   369      var currArg uint8
   370      err = decoder.DecodeUint8(&currArg)
   371      if err != nil {
   372        return types.MmapArgs{}, err
   373      }
   374  
   375      switch currArg {
   376      case 0:
   377        var dataAddr uint64
   378        err = decoder.DecodeUint64(&dataAddr)
   379        if err != nil {
   380          return types.MmapArgs{}, err
   381        }
   382        result.Addr = uintptr(dataAddr)
   383      case 1:
   384        err = decoder.DecodeUint64(&result.Length)
   385        if err != nil {
   386          return types.MmapArgs{}, err
   387        }
   388      case 2:
   389        err = decoder.DecodeInt32(&result.Prot)
   390        if err != nil {
   391          return types.MmapArgs{}, err
   392        }
   393      case 3:
   394        err = decoder.DecodeInt32(&result.Flags)
   395        if err != nil {
   396          return types.MmapArgs{}, err
   397        }
   398      case 4:
   399        err = decoder.DecodeInt32(&result.Fd)
   400        if err != nil {
   401          return types.MmapArgs{}, err
   402        }
   403      case 5:
   404        err = decoder.DecodeUint64(&result.Off)
   405        if err != nil {
   406          return types.MmapArgs{}, err
   407        }
   408      }
   409    }
   410    return result, nil
   411  }
   412  
   413  func ParseMprotectArgs(decoder *Decoder) (types.MprotectArgs, error) {
   414    var result types.MprotectArgs
   415    var err error
   416  
   417    var numArgs uint8
   418    err = decoder.DecodeUint8(&numArgs)
   419    if err != nil {
   420      return types.MprotectArgs{}, err
   421    }
   422  
   423    for arg := 0; arg < int(numArgs); arg++ {
   424      var currArg uint8
   425      err = decoder.DecodeUint8(&currArg)
   426      if err != nil {
   427        return types.MprotectArgs{}, err
   428      }
   429  
   430      switch currArg {
   431      case 0:
   432        var dataAddr uint64
   433        err = decoder.DecodeUint64(&dataAddr)
   434        if err != nil {
   435          return types.MprotectArgs{}, err
   436        }
   437        result.Addr = uintptr(dataAddr)
   438      case 1:
   439        err = decoder.DecodeUint64(&result.Len)
   440        if err != nil {
   441          return types.MprotectArgs{}, err
   442        }
   443      case 2:
   444        err = decoder.DecodeInt32(&result.Prot)
   445        if err != nil {
   446          return types.MprotectArgs{}, err
   447        }
   448      }
   449    }
   450    return result, nil
   451  }
   452  
   453  func ParseMunmapArgs(decoder *Decoder) (types.MunmapArgs, error) {
   454    var result types.MunmapArgs
   455    var err error
   456  
   457    var numArgs uint8
   458    err = decoder.DecodeUint8(&numArgs)
   459    if err != nil {
   460      return types.MunmapArgs{}, err
   461    }
   462  
   463    for arg := 0; arg < int(numArgs); arg++ {
   464      var currArg uint8
   465      err = decoder.DecodeUint8(&currArg)
   466      if err != nil {
   467        return types.MunmapArgs{}, err
   468      }
   469  
   470      switch currArg {
   471      case 0:
   472        var dataAddr uint64
   473        err = decoder.DecodeUint64(&dataAddr)
   474        if err != nil {
   475          return types.MunmapArgs{}, err
   476        }
   477        result.Addr = uintptr(dataAddr)
   478      case 1:
   479        err = decoder.DecodeUint64(&result.Length)
   480        if err != nil {
   481          return types.MunmapArgs{}, err
   482        }
   483      }
   484    }
   485    return result, nil
   486  }
   487  
   488  func ParseBrkArgs(decoder *Decoder) (types.BrkArgs, error) {
   489    var result types.BrkArgs
   490    var err error
   491  
   492    var numArgs uint8
   493    err = decoder.DecodeUint8(&numArgs)
   494    if err != nil {
   495      return types.BrkArgs{}, err
   496    }
   497  
   498    for arg := 0; arg < int(numArgs); arg++ {
   499      var currArg uint8
   500      err = decoder.DecodeUint8(&currArg)
   501      if err != nil {
   502        return types.BrkArgs{}, err
   503      }
   504  
   505      switch currArg {
   506      case 0:
   507        var dataAddr uint64
   508        err = decoder.DecodeUint64(&dataAddr)
   509        if err != nil {
   510          return types.BrkArgs{}, err
   511        }
   512        result.Addr = uintptr(dataAddr)
   513      }
   514    }
   515    return result, nil
   516  }
   517  
   518  func ParseRtSigactionArgs(decoder *Decoder) (types.RtSigactionArgs, error) {
   519    var result types.RtSigactionArgs
   520    var err error
   521  
   522    var numArgs uint8
   523    err = decoder.DecodeUint8(&numArgs)
   524    if err != nil {
   525      return types.RtSigactionArgs{}, err
   526    }
   527  
   528    for arg := 0; arg < int(numArgs); arg++ {
   529      var currArg uint8
   530      err = decoder.DecodeUint8(&currArg)
   531      if err != nil {
   532        return types.RtSigactionArgs{}, err
   533      }
   534  
   535      switch currArg {
   536      case 0:
   537        err = decoder.DecodeInt32(&result.Signum)
   538        if err != nil {
   539          return types.RtSigactionArgs{}, err
   540        }
   541      case 1:
   542        var dataAct uint64
   543        err = decoder.DecodeUint64(&dataAct)
   544        if err != nil {
   545          return types.RtSigactionArgs{}, err
   546        }
   547        result.Act = uintptr(dataAct)
   548      case 2:
   549        var dataOldact uint64
   550        err = decoder.DecodeUint64(&dataOldact)
   551        if err != nil {
   552          return types.RtSigactionArgs{}, err
   553        }
   554        result.Oldact = uintptr(dataOldact)
   555      case 3:
   556        err = decoder.DecodeUint64(&result.Sigsetsize)
   557        if err != nil {
   558          return types.RtSigactionArgs{}, err
   559        }
   560      }
   561    }
   562    return result, nil
   563  }
   564  
   565  func ParseRtSigprocmaskArgs(decoder *Decoder) (types.RtSigprocmaskArgs, error) {
   566    var result types.RtSigprocmaskArgs
   567    var err error
   568  
   569    var numArgs uint8
   570    err = decoder.DecodeUint8(&numArgs)
   571    if err != nil {
   572      return types.RtSigprocmaskArgs{}, err
   573    }
   574  
   575    for arg := 0; arg < int(numArgs); arg++ {
   576      var currArg uint8
   577      err = decoder.DecodeUint8(&currArg)
   578      if err != nil {
   579        return types.RtSigprocmaskArgs{}, err
   580      }
   581  
   582      switch currArg {
   583      case 0:
   584        err = decoder.DecodeInt32(&result.How)
   585        if err != nil {
   586          return types.RtSigprocmaskArgs{}, err
   587        }
   588      case 1:
   589        var dataSet uint64
   590        err = decoder.DecodeUint64(&dataSet)
   591        if err != nil {
   592          return types.RtSigprocmaskArgs{}, err
   593        }
   594        result.Set = uintptr(dataSet)
   595      case 2:
   596        var dataOldset uint64
   597        err = decoder.DecodeUint64(&dataOldset)
   598        if err != nil {
   599          return types.RtSigprocmaskArgs{}, err
   600        }
   601        result.Oldset = uintptr(dataOldset)
   602      case 3:
   603        err = decoder.DecodeUint64(&result.Sigsetsize)
   604        if err != nil {
   605          return types.RtSigprocmaskArgs{}, err
   606        }
   607      }
   608    }
   609    return result, nil
   610  }
   611  
   612  func ParseRtSigreturnArgs(decoder *Decoder) (types.RtSigreturnArgs, error) {
   613    return types.RtSigreturnArgs{}, nil
   614  }
   615  
   616  func ParseIoctlArgs(decoder *Decoder) (types.IoctlArgs, error) {
   617    var result types.IoctlArgs
   618    var err error
   619  
   620    var numArgs uint8
   621    err = decoder.DecodeUint8(&numArgs)
   622    if err != nil {
   623      return types.IoctlArgs{}, err
   624    }
   625  
   626    for arg := 0; arg < int(numArgs); arg++ {
   627      var currArg uint8
   628      err = decoder.DecodeUint8(&currArg)
   629      if err != nil {
   630        return types.IoctlArgs{}, err
   631      }
   632  
   633      switch currArg {
   634      case 0:
   635        err = decoder.DecodeInt32(&result.Fd)
   636        if err != nil {
   637          return types.IoctlArgs{}, err
   638        }
   639      case 1:
   640        err = decoder.DecodeUint64(&result.Request)
   641        if err != nil {
   642          return types.IoctlArgs{}, err
   643        }
   644      case 2:
   645        err = decoder.DecodeUint64(&result.Arg)
   646        if err != nil {
   647          return types.IoctlArgs{}, err
   648        }
   649      }
   650    }
   651    return result, nil
   652  }
   653  
   654  func ParsePread64Args(decoder *Decoder) (types.Pread64Args, error) {
   655    var result types.Pread64Args
   656    var err error
   657  
   658    var numArgs uint8
   659    err = decoder.DecodeUint8(&numArgs)
   660    if err != nil {
   661      return types.Pread64Args{}, err
   662    }
   663  
   664    for arg := 0; arg < int(numArgs); arg++ {
   665      var currArg uint8
   666      err = decoder.DecodeUint8(&currArg)
   667      if err != nil {
   668        return types.Pread64Args{}, err
   669      }
   670  
   671      switch currArg {
   672      case 0:
   673        err = decoder.DecodeInt32(&result.Fd)
   674        if err != nil {
   675          return types.Pread64Args{}, err
   676        }
   677      case 1:
   678        var dataBuf uint64
   679        err = decoder.DecodeUint64(&dataBuf)
   680        if err != nil {
   681          return types.Pread64Args{}, err
   682        }
   683        result.Buf = uintptr(dataBuf)
   684      case 2:
   685        err = decoder.DecodeUint64(&result.Count)
   686        if err != nil {
   687          return types.Pread64Args{}, err
   688        }
   689      case 3:
   690        err = decoder.DecodeUint64(&result.Offset)
   691        if err != nil {
   692          return types.Pread64Args{}, err
   693        }
   694      }
   695    }
   696    return result, nil
   697  }
   698  
   699  func ParsePwrite64Args(decoder *Decoder) (types.Pwrite64Args, error) {
   700    var result types.Pwrite64Args
   701    var err error
   702  
   703    var numArgs uint8
   704    err = decoder.DecodeUint8(&numArgs)
   705    if err != nil {
   706      return types.Pwrite64Args{}, err
   707    }
   708  
   709    for arg := 0; arg < int(numArgs); arg++ {
   710      var currArg uint8
   711      err = decoder.DecodeUint8(&currArg)
   712      if err != nil {
   713        return types.Pwrite64Args{}, err
   714      }
   715  
   716      switch currArg {
   717      case 0:
   718        err = decoder.DecodeInt32(&result.Fd)
   719        if err != nil {
   720          return types.Pwrite64Args{}, err
   721        }
   722      case 1:
   723        var dataBuf uint64
   724        err = decoder.DecodeUint64(&dataBuf)
   725        if err != nil {
   726          return types.Pwrite64Args{}, err
   727        }
   728        result.Buf = uintptr(dataBuf)
   729      case 2:
   730        err = decoder.DecodeUint64(&result.Count)
   731        if err != nil {
   732          return types.Pwrite64Args{}, err
   733        }
   734      case 3:
   735        err = decoder.DecodeUint64(&result.Offset)
   736        if err != nil {
   737          return types.Pwrite64Args{}, err
   738        }
   739      }
   740    }
   741    return result, nil
   742  }
   743  
   744  func ParseReadvArgs(decoder *Decoder) (types.ReadvArgs, error) {
   745    var result types.ReadvArgs
   746    var err error
   747  
   748    var numArgs uint8
   749    err = decoder.DecodeUint8(&numArgs)
   750    if err != nil {
   751      return types.ReadvArgs{}, err
   752    }
   753  
   754    for arg := 0; arg < int(numArgs); arg++ {
   755      var currArg uint8
   756      err = decoder.DecodeUint8(&currArg)
   757      if err != nil {
   758        return types.ReadvArgs{}, err
   759      }
   760  
   761      switch currArg {
   762      case 0:
   763        err = decoder.DecodeInt32(&result.Fd)
   764        if err != nil {
   765          return types.ReadvArgs{}, err
   766        }
   767      case 1:
   768        var dataIov uint64
   769        err = decoder.DecodeUint64(&dataIov)
   770        if err != nil {
   771          return types.ReadvArgs{}, err
   772        }
   773        result.Iov = uintptr(dataIov)
   774      case 2:
   775        err = decoder.DecodeInt32(&result.Iovcnt)
   776        if err != nil {
   777          return types.ReadvArgs{}, err
   778        }
   779      }
   780    }
   781    return result, nil
   782  }
   783  
   784  func ParseWritevArgs(decoder *Decoder) (types.WritevArgs, error) {
   785    var result types.WritevArgs
   786    var err error
   787  
   788    var numArgs uint8
   789    err = decoder.DecodeUint8(&numArgs)
   790    if err != nil {
   791      return types.WritevArgs{}, err
   792    }
   793  
   794    for arg := 0; arg < int(numArgs); arg++ {
   795      var currArg uint8
   796      err = decoder.DecodeUint8(&currArg)
   797      if err != nil {
   798        return types.WritevArgs{}, err
   799      }
   800  
   801      switch currArg {
   802      case 0:
   803        err = decoder.DecodeInt32(&result.Fd)
   804        if err != nil {
   805          return types.WritevArgs{}, err
   806        }
   807      case 1:
   808        var dataIov uint64
   809        err = decoder.DecodeUint64(&dataIov)
   810        if err != nil {
   811          return types.WritevArgs{}, err
   812        }
   813        result.Iov = uintptr(dataIov)
   814      case 2:
   815        err = decoder.DecodeInt32(&result.Iovcnt)
   816        if err != nil {
   817          return types.WritevArgs{}, err
   818        }
   819      }
   820    }
   821    return result, nil
   822  }
   823  
   824  func ParseAccessArgs(decoder *Decoder) (types.AccessArgs, error) {
   825    var result types.AccessArgs
   826    var err error
   827  
   828    var numArgs uint8
   829    err = decoder.DecodeUint8(&numArgs)
   830    if err != nil {
   831      return types.AccessArgs{}, err
   832    }
   833  
   834    for arg := 0; arg < int(numArgs); arg++ {
   835      var currArg uint8
   836      err = decoder.DecodeUint8(&currArg)
   837      if err != nil {
   838        return types.AccessArgs{}, err
   839      }
   840  
   841      switch currArg {
   842      case 0:
   843        result.Pathname, err = decoder.ReadStringFromBuff()
   844        if err != nil {
   845          return types.AccessArgs{}, err
   846        }
   847      case 1:
   848        err = decoder.DecodeInt32(&result.Mode)
   849        if err != nil {
   850          return types.AccessArgs{}, err
   851        }
   852      }
   853    }
   854    return result, nil
   855  }
   856  
   857  func ParsePipeArgs(decoder *Decoder) (types.PipeArgs, error) {
   858    var result types.PipeArgs
   859    var err error
   860  
   861    var numArgs uint8
   862    err = decoder.DecodeUint8(&numArgs)
   863    if err != nil {
   864      return types.PipeArgs{}, err
   865    }
   866  
   867    for arg := 0; arg < int(numArgs); arg++ {
   868      var currArg uint8
   869      err = decoder.DecodeUint8(&currArg)
   870      if err != nil {
   871        return types.PipeArgs{}, err
   872      }
   873  
   874      switch currArg {
   875      case 0:
   876        err = decoder.DecodeIntArray(result.Pipefd[:], 2)
   877        if err != nil {
   878          return types.PipeArgs{}, err
   879        }
   880      }
   881    }
   882    return result, nil
   883  }
   884  
   885  func ParseSelectArgs(decoder *Decoder) (types.SelectArgs, error) {
   886    var result types.SelectArgs
   887    var err error
   888  
   889    var numArgs uint8
   890    err = decoder.DecodeUint8(&numArgs)
   891    if err != nil {
   892      return types.SelectArgs{}, err
   893    }
   894  
   895    for arg := 0; arg < int(numArgs); arg++ {
   896      var currArg uint8
   897      err = decoder.DecodeUint8(&currArg)
   898      if err != nil {
   899        return types.SelectArgs{}, err
   900      }
   901  
   902      switch currArg {
   903      case 0:
   904        err = decoder.DecodeInt32(&result.Nfds)
   905        if err != nil {
   906          return types.SelectArgs{}, err
   907        }
   908      case 1:
   909        var dataReadfds uint64
   910        err = decoder.DecodeUint64(&dataReadfds)
   911        if err != nil {
   912          return types.SelectArgs{}, err
   913        }
   914        result.Readfds = uintptr(dataReadfds)
   915      case 2:
   916        var dataWritefds uint64
   917        err = decoder.DecodeUint64(&dataWritefds)
   918        if err != nil {
   919          return types.SelectArgs{}, err
   920        }
   921        result.Writefds = uintptr(dataWritefds)
   922      case 3:
   923        var dataExceptfds uint64
   924        err = decoder.DecodeUint64(&dataExceptfds)
   925        if err != nil {
   926          return types.SelectArgs{}, err
   927        }
   928        result.Exceptfds = uintptr(dataExceptfds)
   929      case 4:
   930        var dataTimeout uint64
   931        err = decoder.DecodeUint64(&dataTimeout)
   932        if err != nil {
   933          return types.SelectArgs{}, err
   934        }
   935        result.Timeout = uintptr(dataTimeout)
   936      }
   937    }
   938    return result, nil
   939  }
   940  
   941  func ParseSchedYieldArgs(decoder *Decoder) (types.SchedYieldArgs, error) {
   942    return types.SchedYieldArgs{}, nil
   943  }
   944  
   945  func ParseMremapArgs(decoder *Decoder) (types.MremapArgs, error) {
   946    var result types.MremapArgs
   947    var err error
   948  
   949    var numArgs uint8
   950    err = decoder.DecodeUint8(&numArgs)
   951    if err != nil {
   952      return types.MremapArgs{}, err
   953    }
   954  
   955    for arg := 0; arg < int(numArgs); arg++ {
   956      var currArg uint8
   957      err = decoder.DecodeUint8(&currArg)
   958      if err != nil {
   959        return types.MremapArgs{}, err
   960      }
   961  
   962      switch currArg {
   963      case 0:
   964        var dataOldAddress uint64
   965        err = decoder.DecodeUint64(&dataOldAddress)
   966        if err != nil {
   967          return types.MremapArgs{}, err
   968        }
   969        result.OldAddress = uintptr(dataOldAddress)
   970      case 1:
   971        err = decoder.DecodeUint64(&result.OldSize)
   972        if err != nil {
   973          return types.MremapArgs{}, err
   974        }
   975      case 2:
   976        err = decoder.DecodeUint64(&result.NewSize)
   977        if err != nil {
   978          return types.MremapArgs{}, err
   979        }
   980      case 3:
   981        err = decoder.DecodeInt32(&result.Flags)
   982        if err != nil {
   983          return types.MremapArgs{}, err
   984        }
   985      case 4:
   986        var dataNewAddress uint64
   987        err = decoder.DecodeUint64(&dataNewAddress)
   988        if err != nil {
   989          return types.MremapArgs{}, err
   990        }
   991        result.NewAddress = uintptr(dataNewAddress)
   992      }
   993    }
   994    return result, nil
   995  }
   996  
   997  func ParseMsyncArgs(decoder *Decoder) (types.MsyncArgs, error) {
   998    var result types.MsyncArgs
   999    var err error
  1000  
  1001    var numArgs uint8
  1002    err = decoder.DecodeUint8(&numArgs)
  1003    if err != nil {
  1004      return types.MsyncArgs{}, err
  1005    }
  1006  
  1007    for arg := 0; arg < int(numArgs); arg++ {
  1008      var currArg uint8
  1009      err = decoder.DecodeUint8(&currArg)
  1010      if err != nil {
  1011        return types.MsyncArgs{}, err
  1012      }
  1013  
  1014      switch currArg {
  1015      case 0:
  1016        var dataAddr uint64
  1017        err = decoder.DecodeUint64(&dataAddr)
  1018        if err != nil {
  1019          return types.MsyncArgs{}, err
  1020        }
  1021        result.Addr = uintptr(dataAddr)
  1022      case 1:
  1023        err = decoder.DecodeUint64(&result.Length)
  1024        if err != nil {
  1025          return types.MsyncArgs{}, err
  1026        }
  1027      case 2:
  1028        err = decoder.DecodeInt32(&result.Flags)
  1029        if err != nil {
  1030          return types.MsyncArgs{}, err
  1031        }
  1032      }
  1033    }
  1034    return result, nil
  1035  }
  1036  
  1037  func ParseMincoreArgs(decoder *Decoder) (types.MincoreArgs, error) {
  1038    var result types.MincoreArgs
  1039    var err error
  1040  
  1041    var numArgs uint8
  1042    err = decoder.DecodeUint8(&numArgs)
  1043    if err != nil {
  1044      return types.MincoreArgs{}, err
  1045    }
  1046  
  1047    for arg := 0; arg < int(numArgs); arg++ {
  1048      var currArg uint8
  1049      err = decoder.DecodeUint8(&currArg)
  1050      if err != nil {
  1051        return types.MincoreArgs{}, err
  1052      }
  1053  
  1054      switch currArg {
  1055      case 0:
  1056        var dataAddr uint64
  1057        err = decoder.DecodeUint64(&dataAddr)
  1058        if err != nil {
  1059          return types.MincoreArgs{}, err
  1060        }
  1061        result.Addr = uintptr(dataAddr)
  1062      case 1:
  1063        err = decoder.DecodeUint64(&result.Length)
  1064        if err != nil {
  1065          return types.MincoreArgs{}, err
  1066        }
  1067      case 2:
  1068        var dataVec uint64
  1069        err = decoder.DecodeUint64(&dataVec)
  1070        if err != nil {
  1071          return types.MincoreArgs{}, err
  1072        }
  1073        result.Vec = uintptr(dataVec)
  1074      }
  1075    }
  1076    return result, nil
  1077  }
  1078  
  1079  func ParseMadviseArgs(decoder *Decoder) (types.MadviseArgs, error) {
  1080    var result types.MadviseArgs
  1081    var err error
  1082  
  1083    var numArgs uint8
  1084    err = decoder.DecodeUint8(&numArgs)
  1085    if err != nil {
  1086      return types.MadviseArgs{}, err
  1087    }
  1088  
  1089    for arg := 0; arg < int(numArgs); arg++ {
  1090      var currArg uint8
  1091      err = decoder.DecodeUint8(&currArg)
  1092      if err != nil {
  1093        return types.MadviseArgs{}, err
  1094      }
  1095  
  1096      switch currArg {
  1097      case 0:
  1098        var dataAddr uint64
  1099        err = decoder.DecodeUint64(&dataAddr)
  1100        if err != nil {
  1101          return types.MadviseArgs{}, err
  1102        }
  1103        result.Addr = uintptr(dataAddr)
  1104      case 1:
  1105        err = decoder.DecodeUint64(&result.Length)
  1106        if err != nil {
  1107          return types.MadviseArgs{}, err
  1108        }
  1109      case 2:
  1110        err = decoder.DecodeInt32(&result.Advice)
  1111        if err != nil {
  1112          return types.MadviseArgs{}, err
  1113        }
  1114      }
  1115    }
  1116    return result, nil
  1117  }
  1118  
  1119  func ParseShmgetArgs(decoder *Decoder) (types.ShmgetArgs, error) {
  1120    var result types.ShmgetArgs
  1121    var err error
  1122  
  1123    var numArgs uint8
  1124    err = decoder.DecodeUint8(&numArgs)
  1125    if err != nil {
  1126      return types.ShmgetArgs{}, err
  1127    }
  1128  
  1129    for arg := 0; arg < int(numArgs); arg++ {
  1130      var currArg uint8
  1131      err = decoder.DecodeUint8(&currArg)
  1132      if err != nil {
  1133        return types.ShmgetArgs{}, err
  1134      }
  1135  
  1136      switch currArg {
  1137      case 0:
  1138        err = decoder.DecodeInt32(&result.Key)
  1139        if err != nil {
  1140          return types.ShmgetArgs{}, err
  1141        }
  1142      case 1:
  1143        err = decoder.DecodeUint64(&result.Size)
  1144        if err != nil {
  1145          return types.ShmgetArgs{}, err
  1146        }
  1147      case 2:
  1148        err = decoder.DecodeInt32(&result.Shmflg)
  1149        if err != nil {
  1150          return types.ShmgetArgs{}, err
  1151        }
  1152      }
  1153    }
  1154    return result, nil
  1155  }
  1156  
  1157  func ParseShmatArgs(decoder *Decoder) (types.ShmatArgs, error) {
  1158    var result types.ShmatArgs
  1159    var err error
  1160  
  1161    var numArgs uint8
  1162    err = decoder.DecodeUint8(&numArgs)
  1163    if err != nil {
  1164      return types.ShmatArgs{}, err
  1165    }
  1166  
  1167    for arg := 0; arg < int(numArgs); arg++ {
  1168      var currArg uint8
  1169      err = decoder.DecodeUint8(&currArg)
  1170      if err != nil {
  1171        return types.ShmatArgs{}, err
  1172      }
  1173  
  1174      switch currArg {
  1175      case 0:
  1176        err = decoder.DecodeInt32(&result.Shmid)
  1177        if err != nil {
  1178          return types.ShmatArgs{}, err
  1179        }
  1180      case 1:
  1181        var dataShmaddr uint64
  1182        err = decoder.DecodeUint64(&dataShmaddr)
  1183        if err != nil {
  1184          return types.ShmatArgs{}, err
  1185        }
  1186        result.Shmaddr = uintptr(dataShmaddr)
  1187      case 2:
  1188        err = decoder.DecodeInt32(&result.Shmflg)
  1189        if err != nil {
  1190          return types.ShmatArgs{}, err
  1191        }
  1192      }
  1193    }
  1194    return result, nil
  1195  }
  1196  
  1197  func ParseShmctlArgs(decoder *Decoder) (types.ShmctlArgs, error) {
  1198    var result types.ShmctlArgs
  1199    var err error
  1200  
  1201    var numArgs uint8
  1202    err = decoder.DecodeUint8(&numArgs)
  1203    if err != nil {
  1204      return types.ShmctlArgs{}, err
  1205    }
  1206  
  1207    for arg := 0; arg < int(numArgs); arg++ {
  1208      var currArg uint8
  1209      err = decoder.DecodeUint8(&currArg)
  1210      if err != nil {
  1211        return types.ShmctlArgs{}, err
  1212      }
  1213  
  1214      switch currArg {
  1215      case 0:
  1216        err = decoder.DecodeInt32(&result.Shmid)
  1217        if err != nil {
  1218          return types.ShmctlArgs{}, err
  1219        }
  1220      case 1:
  1221        err = decoder.DecodeInt32(&result.Cmd)
  1222        if err != nil {
  1223          return types.ShmctlArgs{}, err
  1224        }
  1225      case 2:
  1226        var dataBuf uint64
  1227        err = decoder.DecodeUint64(&dataBuf)
  1228        if err != nil {
  1229          return types.ShmctlArgs{}, err
  1230        }
  1231        result.Buf = uintptr(dataBuf)
  1232      }
  1233    }
  1234    return result, nil
  1235  }
  1236  
  1237  func ParseDupArgs(decoder *Decoder) (types.DupArgs, error) {
  1238    var result types.DupArgs
  1239    var err error
  1240  
  1241    var numArgs uint8
  1242    err = decoder.DecodeUint8(&numArgs)
  1243    if err != nil {
  1244      return types.DupArgs{}, err
  1245    }
  1246  
  1247    for arg := 0; arg < int(numArgs); arg++ {
  1248      var currArg uint8
  1249      err = decoder.DecodeUint8(&currArg)
  1250      if err != nil {
  1251        return types.DupArgs{}, err
  1252      }
  1253  
  1254      switch currArg {
  1255      case 0:
  1256        err = decoder.DecodeInt32(&result.Oldfd)
  1257        if err != nil {
  1258          return types.DupArgs{}, err
  1259        }
  1260      }
  1261    }
  1262    return result, nil
  1263  }
  1264  
  1265  func ParseDup2Args(decoder *Decoder) (types.Dup2Args, error) {
  1266    var result types.Dup2Args
  1267    var err error
  1268  
  1269    var numArgs uint8
  1270    err = decoder.DecodeUint8(&numArgs)
  1271    if err != nil {
  1272      return types.Dup2Args{}, err
  1273    }
  1274  
  1275    for arg := 0; arg < int(numArgs); arg++ {
  1276      var currArg uint8
  1277      err = decoder.DecodeUint8(&currArg)
  1278      if err != nil {
  1279        return types.Dup2Args{}, err
  1280      }
  1281  
  1282      switch currArg {
  1283      case 0:
  1284        err = decoder.DecodeInt32(&result.Oldfd)
  1285        if err != nil {
  1286          return types.Dup2Args{}, err
  1287        }
  1288      case 1:
  1289        err = decoder.DecodeInt32(&result.Newfd)
  1290        if err != nil {
  1291          return types.Dup2Args{}, err
  1292        }
  1293      }
  1294    }
  1295    return result, nil
  1296  }
  1297  
  1298  func ParsePauseArgs(decoder *Decoder) (types.PauseArgs, error) {
  1299    return types.PauseArgs{}, nil
  1300  }
  1301  
  1302  func ParseNanosleepArgs(decoder *Decoder) (types.NanosleepArgs, error) {
  1303    var result types.NanosleepArgs
  1304    var err error
  1305  
  1306    var numArgs uint8
  1307    err = decoder.DecodeUint8(&numArgs)
  1308    if err != nil {
  1309      return types.NanosleepArgs{}, err
  1310    }
  1311  
  1312    for arg := 0; arg < int(numArgs); arg++ {
  1313      var currArg uint8
  1314      err = decoder.DecodeUint8(&currArg)
  1315      if err != nil {
  1316        return types.NanosleepArgs{}, err
  1317      }
  1318  
  1319      switch currArg {
  1320      case 0:
  1321        result.Req, err = decoder.ReadTimespec()
  1322        if err != nil {
  1323          return types.NanosleepArgs{}, err
  1324        }
  1325      case 1:
  1326        result.Rem, err = decoder.ReadTimespec()
  1327        if err != nil {
  1328          return types.NanosleepArgs{}, err
  1329        }
  1330      }
  1331    }
  1332    return result, nil
  1333  }
  1334  
  1335  func ParseGetitimerArgs(decoder *Decoder) (types.GetitimerArgs, error) {
  1336    var result types.GetitimerArgs
  1337    var err error
  1338  
  1339    var numArgs uint8
  1340    err = decoder.DecodeUint8(&numArgs)
  1341    if err != nil {
  1342      return types.GetitimerArgs{}, err
  1343    }
  1344  
  1345    for arg := 0; arg < int(numArgs); arg++ {
  1346      var currArg uint8
  1347      err = decoder.DecodeUint8(&currArg)
  1348      if err != nil {
  1349        return types.GetitimerArgs{}, err
  1350      }
  1351  
  1352      switch currArg {
  1353      case 0:
  1354        err = decoder.DecodeInt32(&result.Which)
  1355        if err != nil {
  1356          return types.GetitimerArgs{}, err
  1357        }
  1358      case 1:
  1359        var dataCurrValue uint64
  1360        err = decoder.DecodeUint64(&dataCurrValue)
  1361        if err != nil {
  1362          return types.GetitimerArgs{}, err
  1363        }
  1364        result.CurrValue = uintptr(dataCurrValue)
  1365      }
  1366    }
  1367    return result, nil
  1368  }
  1369  
  1370  func ParseAlarmArgs(decoder *Decoder) (types.AlarmArgs, error) {
  1371    var result types.AlarmArgs
  1372    var err error
  1373  
  1374    var numArgs uint8
  1375    err = decoder.DecodeUint8(&numArgs)
  1376    if err != nil {
  1377      return types.AlarmArgs{}, err
  1378    }
  1379  
  1380    for arg := 0; arg < int(numArgs); arg++ {
  1381      var currArg uint8
  1382      err = decoder.DecodeUint8(&currArg)
  1383      if err != nil {
  1384        return types.AlarmArgs{}, err
  1385      }
  1386  
  1387      switch currArg {
  1388      case 0:
  1389        err = decoder.DecodeUint32(&result.Seconds)
  1390        if err != nil {
  1391          return types.AlarmArgs{}, err
  1392        }
  1393      }
  1394    }
  1395    return result, nil
  1396  }
  1397  
  1398  func ParseSetitimerArgs(decoder *Decoder) (types.SetitimerArgs, error) {
  1399    var result types.SetitimerArgs
  1400    var err error
  1401  
  1402    var numArgs uint8
  1403    err = decoder.DecodeUint8(&numArgs)
  1404    if err != nil {
  1405      return types.SetitimerArgs{}, err
  1406    }
  1407  
  1408    for arg := 0; arg < int(numArgs); arg++ {
  1409      var currArg uint8
  1410      err = decoder.DecodeUint8(&currArg)
  1411      if err != nil {
  1412        return types.SetitimerArgs{}, err
  1413      }
  1414  
  1415      switch currArg {
  1416      case 0:
  1417        err = decoder.DecodeInt32(&result.Which)
  1418        if err != nil {
  1419          return types.SetitimerArgs{}, err
  1420        }
  1421      case 1:
  1422        var dataNewValue uint64
  1423        err = decoder.DecodeUint64(&dataNewValue)
  1424        if err != nil {
  1425          return types.SetitimerArgs{}, err
  1426        }
  1427        result.NewValue = uintptr(dataNewValue)
  1428      case 2:
  1429        var dataOldValue uint64
  1430        err = decoder.DecodeUint64(&dataOldValue)
  1431        if err != nil {
  1432          return types.SetitimerArgs{}, err
  1433        }
  1434        result.OldValue = uintptr(dataOldValue)
  1435      }
  1436    }
  1437    return result, nil
  1438  }
  1439  
  1440  func ParseGetpidArgs(decoder *Decoder) (types.GetpidArgs, error) {
  1441    return types.GetpidArgs{}, nil
  1442  }
  1443  
  1444  func ParseSendfileArgs(decoder *Decoder) (types.SendfileArgs, error) {
  1445    var result types.SendfileArgs
  1446    var err error
  1447  
  1448    var numArgs uint8
  1449    err = decoder.DecodeUint8(&numArgs)
  1450    if err != nil {
  1451      return types.SendfileArgs{}, err
  1452    }
  1453  
  1454    for arg := 0; arg < int(numArgs); arg++ {
  1455      var currArg uint8
  1456      err = decoder.DecodeUint8(&currArg)
  1457      if err != nil {
  1458        return types.SendfileArgs{}, err
  1459      }
  1460  
  1461      switch currArg {
  1462      case 0:
  1463        err = decoder.DecodeInt32(&result.OutFd)
  1464        if err != nil {
  1465          return types.SendfileArgs{}, err
  1466        }
  1467      case 1:
  1468        err = decoder.DecodeInt32(&result.InFd)
  1469        if err != nil {
  1470          return types.SendfileArgs{}, err
  1471        }
  1472      case 2:
  1473        var dataOffset uint64
  1474        err = decoder.DecodeUint64(&dataOffset)
  1475        if err != nil {
  1476          return types.SendfileArgs{}, err
  1477        }
  1478        result.Offset = uintptr(dataOffset)
  1479      case 3:
  1480        err = decoder.DecodeUint64(&result.Count)
  1481        if err != nil {
  1482          return types.SendfileArgs{}, err
  1483        }
  1484      }
  1485    }
  1486    return result, nil
  1487  }
  1488  
  1489  func ParseSocketArgs(decoder *Decoder) (types.SocketArgs, error) {
  1490    var result types.SocketArgs
  1491    var err error
  1492  
  1493    var numArgs uint8
  1494    err = decoder.DecodeUint8(&numArgs)
  1495    if err != nil {
  1496      return types.SocketArgs{}, err
  1497    }
  1498  
  1499    for arg := 0; arg < int(numArgs); arg++ {
  1500      var currArg uint8
  1501      err = decoder.DecodeUint8(&currArg)
  1502      if err != nil {
  1503        return types.SocketArgs{}, err
  1504      }
  1505  
  1506      switch currArg {
  1507      case 0:
  1508        err = decoder.DecodeInt32(&result.Domain)
  1509        if err != nil {
  1510          return types.SocketArgs{}, err
  1511        }
  1512      case 1:
  1513        err = decoder.DecodeInt32(&result.Type)
  1514        if err != nil {
  1515          return types.SocketArgs{}, err
  1516        }
  1517      case 2:
  1518        err = decoder.DecodeInt32(&result.Protocol)
  1519        if err != nil {
  1520          return types.SocketArgs{}, err
  1521        }
  1522      }
  1523    }
  1524    return result, nil
  1525  }
  1526  
  1527  func ParseConnectArgs(decoder *Decoder) (types.ConnectArgs, error) {
  1528    var result types.ConnectArgs
  1529    var err error
  1530  
  1531    var numArgs uint8
  1532    err = decoder.DecodeUint8(&numArgs)
  1533    if err != nil {
  1534      return types.ConnectArgs{}, err
  1535    }
  1536  
  1537    for arg := 0; arg < int(numArgs); arg++ {
  1538      var currArg uint8
  1539      err = decoder.DecodeUint8(&currArg)
  1540      if err != nil {
  1541        return types.ConnectArgs{}, err
  1542      }
  1543  
  1544      switch currArg {
  1545      case 0:
  1546        err = decoder.DecodeInt32(&result.Sockfd)
  1547        if err != nil {
  1548          return types.ConnectArgs{}, err
  1549        }
  1550      case 1:
  1551        result.Addr, err = decoder.ReadSockaddrFromBuff()
  1552        if err != nil {
  1553          return types.ConnectArgs{}, err
  1554        }
  1555      case 2:
  1556        err = decoder.DecodeInt32(&result.Addrlen)
  1557        if err != nil {
  1558          return types.ConnectArgs{}, err
  1559        }
  1560      }
  1561    }
  1562    return result, nil
  1563  }
  1564  
  1565  func ParseAcceptArgs(decoder *Decoder) (types.AcceptArgs, error) {
  1566    var result types.AcceptArgs
  1567    var err error
  1568  
  1569    var numArgs uint8
  1570    err = decoder.DecodeUint8(&numArgs)
  1571    if err != nil {
  1572      return types.AcceptArgs{}, err
  1573    }
  1574  
  1575    for arg := 0; arg < int(numArgs); arg++ {
  1576      var currArg uint8
  1577      err = decoder.DecodeUint8(&currArg)
  1578      if err != nil {
  1579        return types.AcceptArgs{}, err
  1580      }
  1581  
  1582      switch currArg {
  1583      case 0:
  1584        err = decoder.DecodeInt32(&result.Sockfd)
  1585        if err != nil {
  1586          return types.AcceptArgs{}, err
  1587        }
  1588      case 1:
  1589        result.Addr, err = decoder.ReadSockaddrFromBuff()
  1590        if err != nil {
  1591          return types.AcceptArgs{}, err
  1592        }
  1593      case 2:
  1594        var dataAddrlen uint64
  1595        err = decoder.DecodeUint64(&dataAddrlen)
  1596        if err != nil {
  1597          return types.AcceptArgs{}, err
  1598        }
  1599        result.Addrlen = uintptr(dataAddrlen)
  1600      }
  1601    }
  1602    return result, nil
  1603  }
  1604  
  1605  func ParseSendtoArgs(decoder *Decoder) (types.SendtoArgs, error) {
  1606    var result types.SendtoArgs
  1607    var err error
  1608  
  1609    var numArgs uint8
  1610    err = decoder.DecodeUint8(&numArgs)
  1611    if err != nil {
  1612      return types.SendtoArgs{}, err
  1613    }
  1614  
  1615    for arg := 0; arg < int(numArgs); arg++ {
  1616      var currArg uint8
  1617      err = decoder.DecodeUint8(&currArg)
  1618      if err != nil {
  1619        return types.SendtoArgs{}, err
  1620      }
  1621  
  1622      switch currArg {
  1623      case 0:
  1624        err = decoder.DecodeInt32(&result.Sockfd)
  1625        if err != nil {
  1626          return types.SendtoArgs{}, err
  1627        }
  1628      case 1:
  1629        var dataBuf uint64
  1630        err = decoder.DecodeUint64(&dataBuf)
  1631        if err != nil {
  1632          return types.SendtoArgs{}, err
  1633        }
  1634        result.Buf = uintptr(dataBuf)
  1635      case 2:
  1636        err = decoder.DecodeUint64(&result.Len)
  1637        if err != nil {
  1638          return types.SendtoArgs{}, err
  1639        }
  1640      case 3:
  1641        err = decoder.DecodeInt32(&result.Flags)
  1642        if err != nil {
  1643          return types.SendtoArgs{}, err
  1644        }
  1645      case 4:
  1646        result.DestAddr, err = decoder.ReadSockaddrFromBuff()
  1647        if err != nil {
  1648          return types.SendtoArgs{}, err
  1649        }
  1650      case 5:
  1651        err = decoder.DecodeInt32(&result.Addrlen)
  1652        if err != nil {
  1653          return types.SendtoArgs{}, err
  1654        }
  1655      }
  1656    }
  1657    return result, nil
  1658  }
  1659  
  1660  func ParseRecvfromArgs(decoder *Decoder) (types.RecvfromArgs, error) {
  1661    var result types.RecvfromArgs
  1662    var err error
  1663  
  1664    var numArgs uint8
  1665    err = decoder.DecodeUint8(&numArgs)
  1666    if err != nil {
  1667      return types.RecvfromArgs{}, err
  1668    }
  1669  
  1670    for arg := 0; arg < int(numArgs); arg++ {
  1671      var currArg uint8
  1672      err = decoder.DecodeUint8(&currArg)
  1673      if err != nil {
  1674        return types.RecvfromArgs{}, err
  1675      }
  1676  
  1677      switch currArg {
  1678      case 0:
  1679        err = decoder.DecodeInt32(&result.Sockfd)
  1680        if err != nil {
  1681          return types.RecvfromArgs{}, err
  1682        }
  1683      case 1:
  1684        var dataBuf uint64
  1685        err = decoder.DecodeUint64(&dataBuf)
  1686        if err != nil {
  1687          return types.RecvfromArgs{}, err
  1688        }
  1689        result.Buf = uintptr(dataBuf)
  1690      case 2:
  1691        err = decoder.DecodeUint64(&result.Len)
  1692        if err != nil {
  1693          return types.RecvfromArgs{}, err
  1694        }
  1695      case 3:
  1696        err = decoder.DecodeInt32(&result.Flags)
  1697        if err != nil {
  1698          return types.RecvfromArgs{}, err
  1699        }
  1700      case 4:
  1701        result.SrcAddr, err = decoder.ReadSockaddrFromBuff()
  1702        if err != nil {
  1703          return types.RecvfromArgs{}, err
  1704        }
  1705      case 5:
  1706        var dataAddrlen uint64
  1707        err = decoder.DecodeUint64(&dataAddrlen)
  1708        if err != nil {
  1709          return types.RecvfromArgs{}, err
  1710        }
  1711        result.Addrlen = uintptr(dataAddrlen)
  1712      }
  1713    }
  1714    return result, nil
  1715  }
  1716  
  1717  func ParseSendmsgArgs(decoder *Decoder) (types.SendmsgArgs, error) {
  1718    var result types.SendmsgArgs
  1719    var err error
  1720  
  1721    var numArgs uint8
  1722    err = decoder.DecodeUint8(&numArgs)
  1723    if err != nil {
  1724      return types.SendmsgArgs{}, err
  1725    }
  1726  
  1727    for arg := 0; arg < int(numArgs); arg++ {
  1728      var currArg uint8
  1729      err = decoder.DecodeUint8(&currArg)
  1730      if err != nil {
  1731        return types.SendmsgArgs{}, err
  1732      }
  1733  
  1734      switch currArg {
  1735      case 0:
  1736        err = decoder.DecodeInt32(&result.Sockfd)
  1737        if err != nil {
  1738          return types.SendmsgArgs{}, err
  1739        }
  1740      case 1:
  1741        var dataMsg uint64
  1742        err = decoder.DecodeUint64(&dataMsg)
  1743        if err != nil {
  1744          return types.SendmsgArgs{}, err
  1745        }
  1746        result.Msg = uintptr(dataMsg)
  1747      case 2:
  1748        err = decoder.DecodeInt32(&result.Flags)
  1749        if err != nil {
  1750          return types.SendmsgArgs{}, err
  1751        }
  1752      }
  1753    }
  1754    return result, nil
  1755  }
  1756  
  1757  func ParseRecvmsgArgs(decoder *Decoder) (types.RecvmsgArgs, error) {
  1758    var result types.RecvmsgArgs
  1759    var err error
  1760  
  1761    var numArgs uint8
  1762    err = decoder.DecodeUint8(&numArgs)
  1763    if err != nil {
  1764      return types.RecvmsgArgs{}, err
  1765    }
  1766  
  1767    for arg := 0; arg < int(numArgs); arg++ {
  1768      var currArg uint8
  1769      err = decoder.DecodeUint8(&currArg)
  1770      if err != nil {
  1771        return types.RecvmsgArgs{}, err
  1772      }
  1773  
  1774      switch currArg {
  1775      case 0:
  1776        err = decoder.DecodeInt32(&result.Sockfd)
  1777        if err != nil {
  1778          return types.RecvmsgArgs{}, err
  1779        }
  1780      case 1:
  1781        var dataMsg uint64
  1782        err = decoder.DecodeUint64(&dataMsg)
  1783        if err != nil {
  1784          return types.RecvmsgArgs{}, err
  1785        }
  1786        result.Msg = uintptr(dataMsg)
  1787      case 2:
  1788        err = decoder.DecodeInt32(&result.Flags)
  1789        if err != nil {
  1790          return types.RecvmsgArgs{}, err
  1791        }
  1792      }
  1793    }
  1794    return result, nil
  1795  }
  1796  
  1797  func ParseShutdownArgs(decoder *Decoder) (types.ShutdownArgs, error) {
  1798    var result types.ShutdownArgs
  1799    var err error
  1800  
  1801    var numArgs uint8
  1802    err = decoder.DecodeUint8(&numArgs)
  1803    if err != nil {
  1804      return types.ShutdownArgs{}, err
  1805    }
  1806  
  1807    for arg := 0; arg < int(numArgs); arg++ {
  1808      var currArg uint8
  1809      err = decoder.DecodeUint8(&currArg)
  1810      if err != nil {
  1811        return types.ShutdownArgs{}, err
  1812      }
  1813  
  1814      switch currArg {
  1815      case 0:
  1816        err = decoder.DecodeInt32(&result.Sockfd)
  1817        if err != nil {
  1818          return types.ShutdownArgs{}, err
  1819        }
  1820      case 1:
  1821        err = decoder.DecodeInt32(&result.How)
  1822        if err != nil {
  1823          return types.ShutdownArgs{}, err
  1824        }
  1825      }
  1826    }
  1827    return result, nil
  1828  }
  1829  
  1830  func ParseBindArgs(decoder *Decoder) (types.BindArgs, error) {
  1831    var result types.BindArgs
  1832    var err error
  1833  
  1834    var numArgs uint8
  1835    err = decoder.DecodeUint8(&numArgs)
  1836    if err != nil {
  1837      return types.BindArgs{}, err
  1838    }
  1839  
  1840    for arg := 0; arg < int(numArgs); arg++ {
  1841      var currArg uint8
  1842      err = decoder.DecodeUint8(&currArg)
  1843      if err != nil {
  1844        return types.BindArgs{}, err
  1845      }
  1846  
  1847      switch currArg {
  1848      case 0:
  1849        err = decoder.DecodeInt32(&result.Sockfd)
  1850        if err != nil {
  1851          return types.BindArgs{}, err
  1852        }
  1853      case 1:
  1854        result.Addr, err = decoder.ReadSockaddrFromBuff()
  1855        if err != nil {
  1856          return types.BindArgs{}, err
  1857        }
  1858      case 2:
  1859        err = decoder.DecodeInt32(&result.Addrlen)
  1860        if err != nil {
  1861          return types.BindArgs{}, err
  1862        }
  1863      }
  1864    }
  1865    return result, nil
  1866  }
  1867  
  1868  func ParseListenArgs(decoder *Decoder) (types.ListenArgs, error) {
  1869    var result types.ListenArgs
  1870    var err error
  1871  
  1872    var numArgs uint8
  1873    err = decoder.DecodeUint8(&numArgs)
  1874    if err != nil {
  1875      return types.ListenArgs{}, err
  1876    }
  1877  
  1878    for arg := 0; arg < int(numArgs); arg++ {
  1879      var currArg uint8
  1880      err = decoder.DecodeUint8(&currArg)
  1881      if err != nil {
  1882        return types.ListenArgs{}, err
  1883      }
  1884  
  1885      switch currArg {
  1886      case 0:
  1887        err = decoder.DecodeInt32(&result.Sockfd)
  1888        if err != nil {
  1889          return types.ListenArgs{}, err
  1890        }
  1891      case 1:
  1892        err = decoder.DecodeInt32(&result.Backlog)
  1893        if err != nil {
  1894          return types.ListenArgs{}, err
  1895        }
  1896      }
  1897    }
  1898    return result, nil
  1899  }
  1900  
  1901  func ParseGetsocknameArgs(decoder *Decoder) (types.GetsocknameArgs, error) {
  1902    var result types.GetsocknameArgs
  1903    var err error
  1904  
  1905    var numArgs uint8
  1906    err = decoder.DecodeUint8(&numArgs)
  1907    if err != nil {
  1908      return types.GetsocknameArgs{}, err
  1909    }
  1910  
  1911    for arg := 0; arg < int(numArgs); arg++ {
  1912      var currArg uint8
  1913      err = decoder.DecodeUint8(&currArg)
  1914      if err != nil {
  1915        return types.GetsocknameArgs{}, err
  1916      }
  1917  
  1918      switch currArg {
  1919      case 0:
  1920        err = decoder.DecodeInt32(&result.Sockfd)
  1921        if err != nil {
  1922          return types.GetsocknameArgs{}, err
  1923        }
  1924      case 1:
  1925        result.Addr, err = decoder.ReadSockaddrFromBuff()
  1926        if err != nil {
  1927          return types.GetsocknameArgs{}, err
  1928        }
  1929      case 2:
  1930        var dataAddrlen uint64
  1931        err = decoder.DecodeUint64(&dataAddrlen)
  1932        if err != nil {
  1933          return types.GetsocknameArgs{}, err
  1934        }
  1935        result.Addrlen = uintptr(dataAddrlen)
  1936      }
  1937    }
  1938    return result, nil
  1939  }
  1940  
  1941  func ParseGetpeernameArgs(decoder *Decoder) (types.GetpeernameArgs, error) {
  1942    var result types.GetpeernameArgs
  1943    var err error
  1944  
  1945    var numArgs uint8
  1946    err = decoder.DecodeUint8(&numArgs)
  1947    if err != nil {
  1948      return types.GetpeernameArgs{}, err
  1949    }
  1950  
  1951    for arg := 0; arg < int(numArgs); arg++ {
  1952      var currArg uint8
  1953      err = decoder.DecodeUint8(&currArg)
  1954      if err != nil {
  1955        return types.GetpeernameArgs{}, err
  1956      }
  1957  
  1958      switch currArg {
  1959      case 0:
  1960        err = decoder.DecodeInt32(&result.Sockfd)
  1961        if err != nil {
  1962          return types.GetpeernameArgs{}, err
  1963        }
  1964      case 1:
  1965        result.Addr, err = decoder.ReadSockaddrFromBuff()
  1966        if err != nil {
  1967          return types.GetpeernameArgs{}, err
  1968        }
  1969      case 2:
  1970        var dataAddrlen uint64
  1971        err = decoder.DecodeUint64(&dataAddrlen)
  1972        if err != nil {
  1973          return types.GetpeernameArgs{}, err
  1974        }
  1975        result.Addrlen = uintptr(dataAddrlen)
  1976      }
  1977    }
  1978    return result, nil
  1979  }
  1980  
  1981  func ParseSocketpairArgs(decoder *Decoder) (types.SocketpairArgs, error) {
  1982    var result types.SocketpairArgs
  1983    var err error
  1984  
  1985    var numArgs uint8
  1986    err = decoder.DecodeUint8(&numArgs)
  1987    if err != nil {
  1988      return types.SocketpairArgs{}, err
  1989    }
  1990  
  1991    for arg := 0; arg < int(numArgs); arg++ {
  1992      var currArg uint8
  1993      err = decoder.DecodeUint8(&currArg)
  1994      if err != nil {
  1995        return types.SocketpairArgs{}, err
  1996      }
  1997  
  1998      switch currArg {
  1999      case 0:
  2000        err = decoder.DecodeInt32(&result.Domain)
  2001        if err != nil {
  2002          return types.SocketpairArgs{}, err
  2003        }
  2004      case 1:
  2005        err = decoder.DecodeInt32(&result.Type)
  2006        if err != nil {
  2007          return types.SocketpairArgs{}, err
  2008        }
  2009      case 2:
  2010        err = decoder.DecodeInt32(&result.Protocol)
  2011        if err != nil {
  2012          return types.SocketpairArgs{}, err
  2013        }
  2014      case 3:
  2015        err = decoder.DecodeIntArray(result.Sv[:], 2)
  2016        if err != nil {
  2017          return types.SocketpairArgs{}, err
  2018        }
  2019      }
  2020    }
  2021    return result, nil
  2022  }
  2023  
  2024  func ParseSetsockoptArgs(decoder *Decoder) (types.SetsockoptArgs, error) {
  2025    var result types.SetsockoptArgs
  2026    var err error
  2027  
  2028    var numArgs uint8
  2029    err = decoder.DecodeUint8(&numArgs)
  2030    if err != nil {
  2031      return types.SetsockoptArgs{}, err
  2032    }
  2033  
  2034    for arg := 0; arg < int(numArgs); arg++ {
  2035      var currArg uint8
  2036      err = decoder.DecodeUint8(&currArg)
  2037      if err != nil {
  2038        return types.SetsockoptArgs{}, err
  2039      }
  2040  
  2041      switch currArg {
  2042      case 0:
  2043        err = decoder.DecodeInt32(&result.Sockfd)
  2044        if err != nil {
  2045          return types.SetsockoptArgs{}, err
  2046        }
  2047      case 1:
  2048        err = decoder.DecodeInt32(&result.Level)
  2049        if err != nil {
  2050          return types.SetsockoptArgs{}, err
  2051        }
  2052      case 2:
  2053        err = decoder.DecodeInt32(&result.Optname)
  2054        if err != nil {
  2055          return types.SetsockoptArgs{}, err
  2056        }
  2057      case 3:
  2058        var dataOptval uint64
  2059        err = decoder.DecodeUint64(&dataOptval)
  2060        if err != nil {
  2061          return types.SetsockoptArgs{}, err
  2062        }
  2063        result.Optval = uintptr(dataOptval)
  2064      case 4:
  2065        err = decoder.DecodeInt32(&result.Optlen)
  2066        if err != nil {
  2067          return types.SetsockoptArgs{}, err
  2068        }
  2069      }
  2070    }
  2071    return result, nil
  2072  }
  2073  
  2074  func ParseGetsockoptArgs(decoder *Decoder) (types.GetsockoptArgs, error) {
  2075    var result types.GetsockoptArgs
  2076    var err error
  2077  
  2078    var numArgs uint8
  2079    err = decoder.DecodeUint8(&numArgs)
  2080    if err != nil {
  2081      return types.GetsockoptArgs{}, err
  2082    }
  2083  
  2084    for arg := 0; arg < int(numArgs); arg++ {
  2085      var currArg uint8
  2086      err = decoder.DecodeUint8(&currArg)
  2087      if err != nil {
  2088        return types.GetsockoptArgs{}, err
  2089      }
  2090  
  2091      switch currArg {
  2092      case 0:
  2093        err = decoder.DecodeInt32(&result.Sockfd)
  2094        if err != nil {
  2095          return types.GetsockoptArgs{}, err
  2096        }
  2097      case 1:
  2098        err = decoder.DecodeInt32(&result.Level)
  2099        if err != nil {
  2100          return types.GetsockoptArgs{}, err
  2101        }
  2102      case 2:
  2103        err = decoder.DecodeInt32(&result.Optname)
  2104        if err != nil {
  2105          return types.GetsockoptArgs{}, err
  2106        }
  2107      case 3:
  2108        var dataOptval uint64
  2109        err = decoder.DecodeUint64(&dataOptval)
  2110        if err != nil {
  2111          return types.GetsockoptArgs{}, err
  2112        }
  2113        result.Optval = uintptr(dataOptval)
  2114      case 4:
  2115        var dataOptlen uint64
  2116        err = decoder.DecodeUint64(&dataOptlen)
  2117        if err != nil {
  2118          return types.GetsockoptArgs{}, err
  2119        }
  2120        result.Optlen = uintptr(dataOptlen)
  2121      }
  2122    }
  2123    return result, nil
  2124  }
  2125  
  2126  func ParseCloneArgs(decoder *Decoder) (types.CloneArgs, error) {
  2127    var result types.CloneArgs
  2128    var err error
  2129  
  2130    var numArgs uint8
  2131    err = decoder.DecodeUint8(&numArgs)
  2132    if err != nil {
  2133      return types.CloneArgs{}, err
  2134    }
  2135  
  2136    for arg := 0; arg < int(numArgs); arg++ {
  2137      var currArg uint8
  2138      err = decoder.DecodeUint8(&currArg)
  2139      if err != nil {
  2140        return types.CloneArgs{}, err
  2141      }
  2142  
  2143      switch currArg {
  2144      case 0:
  2145        err = decoder.DecodeUint64(&result.Flags)
  2146        if err != nil {
  2147          return types.CloneArgs{}, err
  2148        }
  2149      case 1:
  2150        var dataStack uint64
  2151        err = decoder.DecodeUint64(&dataStack)
  2152        if err != nil {
  2153          return types.CloneArgs{}, err
  2154        }
  2155        result.Stack = uintptr(dataStack)
  2156      case 2:
  2157        var dataParentTid uint64
  2158        err = decoder.DecodeUint64(&dataParentTid)
  2159        if err != nil {
  2160          return types.CloneArgs{}, err
  2161        }
  2162        result.ParentTid = uintptr(dataParentTid)
  2163      case 3:
  2164        var dataChildTid uint64
  2165        err = decoder.DecodeUint64(&dataChildTid)
  2166        if err != nil {
  2167          return types.CloneArgs{}, err
  2168        }
  2169        result.ChildTid = uintptr(dataChildTid)
  2170      case 4:
  2171        err = decoder.DecodeUint64(&result.Tls)
  2172        if err != nil {
  2173          return types.CloneArgs{}, err
  2174        }
  2175      }
  2176    }
  2177    return result, nil
  2178  }
  2179  
  2180  func ParseForkArgs(decoder *Decoder) (types.ForkArgs, error) {
  2181    return types.ForkArgs{}, nil
  2182  }
  2183  
  2184  func ParseVforkArgs(decoder *Decoder) (types.VforkArgs, error) {
  2185    return types.VforkArgs{}, nil
  2186  }
  2187  
  2188  func ParseExecveArgs(decoder *Decoder) (types.ExecveArgs, error) {
  2189    var result types.ExecveArgs
  2190    var err error
  2191  
  2192    var numArgs uint8
  2193    err = decoder.DecodeUint8(&numArgs)
  2194    if err != nil {
  2195      return types.ExecveArgs{}, err
  2196    }
  2197  
  2198    for arg := 0; arg < int(numArgs); arg++ {
  2199      var currArg uint8
  2200      err = decoder.DecodeUint8(&currArg)
  2201      if err != nil {
  2202        return types.ExecveArgs{}, err
  2203      }
  2204  
  2205      switch currArg {
  2206      case 0:
  2207        result.Pathname, err = decoder.ReadStringFromBuff()
  2208        if err != nil {
  2209          return types.ExecveArgs{}, err
  2210        }
  2211      case 1:
  2212        result.Argv, err = decoder.ReadStringArrayFromBuff()
  2213        if err != nil {
  2214          return types.ExecveArgs{}, err
  2215        }
  2216      case 2:
  2217        result.Envp, err = decoder.ReadStringArrayFromBuff()
  2218        if err != nil {
  2219          return types.ExecveArgs{}, err
  2220        }
  2221      }
  2222    }
  2223    return result, nil
  2224  }
  2225  
  2226  func ParseExitArgs(decoder *Decoder) (types.ExitArgs, error) {
  2227    var result types.ExitArgs
  2228    var err error
  2229  
  2230    var numArgs uint8
  2231    err = decoder.DecodeUint8(&numArgs)
  2232    if err != nil {
  2233      return types.ExitArgs{}, err
  2234    }
  2235  
  2236    for arg := 0; arg < int(numArgs); arg++ {
  2237      var currArg uint8
  2238      err = decoder.DecodeUint8(&currArg)
  2239      if err != nil {
  2240        return types.ExitArgs{}, err
  2241      }
  2242  
  2243      switch currArg {
  2244      case 0:
  2245        err = decoder.DecodeInt32(&result.Status)
  2246        if err != nil {
  2247          return types.ExitArgs{}, err
  2248        }
  2249      }
  2250    }
  2251    return result, nil
  2252  }
  2253  
  2254  func ParseWait4Args(decoder *Decoder) (types.Wait4Args, error) {
  2255    var result types.Wait4Args
  2256    var err error
  2257  
  2258    var numArgs uint8
  2259    err = decoder.DecodeUint8(&numArgs)
  2260    if err != nil {
  2261      return types.Wait4Args{}, err
  2262    }
  2263  
  2264    for arg := 0; arg < int(numArgs); arg++ {
  2265      var currArg uint8
  2266      err = decoder.DecodeUint8(&currArg)
  2267      if err != nil {
  2268        return types.Wait4Args{}, err
  2269      }
  2270  
  2271      switch currArg {
  2272      case 0:
  2273        err = decoder.DecodeInt32(&result.Pid)
  2274        if err != nil {
  2275          return types.Wait4Args{}, err
  2276        }
  2277      case 1:
  2278        var dataWstatus uint64
  2279        err = decoder.DecodeUint64(&dataWstatus)
  2280        if err != nil {
  2281          return types.Wait4Args{}, err
  2282        }
  2283        result.Wstatus = uintptr(dataWstatus)
  2284      case 2:
  2285        err = decoder.DecodeInt32(&result.Options)
  2286        if err != nil {
  2287          return types.Wait4Args{}, err
  2288        }
  2289      case 3:
  2290        var dataRusage uint64
  2291        err = decoder.DecodeUint64(&dataRusage)
  2292        if err != nil {
  2293          return types.Wait4Args{}, err
  2294        }
  2295        result.Rusage = uintptr(dataRusage)
  2296      }
  2297    }
  2298    return result, nil
  2299  }
  2300  
  2301  func ParseKillArgs(decoder *Decoder) (types.KillArgs, error) {
  2302    var result types.KillArgs
  2303    var err error
  2304  
  2305    var numArgs uint8
  2306    err = decoder.DecodeUint8(&numArgs)
  2307    if err != nil {
  2308      return types.KillArgs{}, err
  2309    }
  2310  
  2311    for arg := 0; arg < int(numArgs); arg++ {
  2312      var currArg uint8
  2313      err = decoder.DecodeUint8(&currArg)
  2314      if err != nil {
  2315        return types.KillArgs{}, err
  2316      }
  2317  
  2318      switch currArg {
  2319      case 0:
  2320        err = decoder.DecodeInt32(&result.Pid)
  2321        if err != nil {
  2322          return types.KillArgs{}, err
  2323        }
  2324      case 1:
  2325        err = decoder.DecodeInt32(&result.Sig)
  2326        if err != nil {
  2327          return types.KillArgs{}, err
  2328        }
  2329      }
  2330    }
  2331    return result, nil
  2332  }
  2333  
  2334  func ParseUnameArgs(decoder *Decoder) (types.UnameArgs, error) {
  2335    var result types.UnameArgs
  2336    var err error
  2337  
  2338    var numArgs uint8
  2339    err = decoder.DecodeUint8(&numArgs)
  2340    if err != nil {
  2341      return types.UnameArgs{}, err
  2342    }
  2343  
  2344    for arg := 0; arg < int(numArgs); arg++ {
  2345      var currArg uint8
  2346      err = decoder.DecodeUint8(&currArg)
  2347      if err != nil {
  2348        return types.UnameArgs{}, err
  2349      }
  2350  
  2351      switch currArg {
  2352      case 0:
  2353        var dataBuf uint64
  2354        err = decoder.DecodeUint64(&dataBuf)
  2355        if err != nil {
  2356          return types.UnameArgs{}, err
  2357        }
  2358        result.Buf = uintptr(dataBuf)
  2359      }
  2360    }
  2361    return result, nil
  2362  }
  2363  
  2364  func ParseSemgetArgs(decoder *Decoder) (types.SemgetArgs, error) {
  2365    var result types.SemgetArgs
  2366    var err error
  2367  
  2368    var numArgs uint8
  2369    err = decoder.DecodeUint8(&numArgs)
  2370    if err != nil {
  2371      return types.SemgetArgs{}, err
  2372    }
  2373  
  2374    for arg := 0; arg < int(numArgs); arg++ {
  2375      var currArg uint8
  2376      err = decoder.DecodeUint8(&currArg)
  2377      if err != nil {
  2378        return types.SemgetArgs{}, err
  2379      }
  2380  
  2381      switch currArg {
  2382      case 0:
  2383        err = decoder.DecodeInt32(&result.Key)
  2384        if err != nil {
  2385          return types.SemgetArgs{}, err
  2386        }
  2387      case 1:
  2388        err = decoder.DecodeInt32(&result.Nsems)
  2389        if err != nil {
  2390          return types.SemgetArgs{}, err
  2391        }
  2392      case 2:
  2393        err = decoder.DecodeInt32(&result.Semflg)
  2394        if err != nil {
  2395          return types.SemgetArgs{}, err
  2396        }
  2397      }
  2398    }
  2399    return result, nil
  2400  }
  2401  
  2402  func ParseSemopArgs(decoder *Decoder) (types.SemopArgs, error) {
  2403    var result types.SemopArgs
  2404    var err error
  2405  
  2406    var numArgs uint8
  2407    err = decoder.DecodeUint8(&numArgs)
  2408    if err != nil {
  2409      return types.SemopArgs{}, err
  2410    }
  2411  
  2412    for arg := 0; arg < int(numArgs); arg++ {
  2413      var currArg uint8
  2414      err = decoder.DecodeUint8(&currArg)
  2415      if err != nil {
  2416        return types.SemopArgs{}, err
  2417      }
  2418  
  2419      switch currArg {
  2420      case 0:
  2421        err = decoder.DecodeInt32(&result.Semid)
  2422        if err != nil {
  2423          return types.SemopArgs{}, err
  2424        }
  2425      case 1:
  2426        var dataSops uint64
  2427        err = decoder.DecodeUint64(&dataSops)
  2428        if err != nil {
  2429          return types.SemopArgs{}, err
  2430        }
  2431        result.Sops = uintptr(dataSops)
  2432      case 2:
  2433        err = decoder.DecodeUint64(&result.Nsops)
  2434        if err != nil {
  2435          return types.SemopArgs{}, err
  2436        }
  2437      }
  2438    }
  2439    return result, nil
  2440  }
  2441  
  2442  func ParseSemctlArgs(decoder *Decoder) (types.SemctlArgs, error) {
  2443    var result types.SemctlArgs
  2444    var err error
  2445  
  2446    var numArgs uint8
  2447    err = decoder.DecodeUint8(&numArgs)
  2448    if err != nil {
  2449      return types.SemctlArgs{}, err
  2450    }
  2451  
  2452    for arg := 0; arg < int(numArgs); arg++ {
  2453      var currArg uint8
  2454      err = decoder.DecodeUint8(&currArg)
  2455      if err != nil {
  2456        return types.SemctlArgs{}, err
  2457      }
  2458  
  2459      switch currArg {
  2460      case 0:
  2461        err = decoder.DecodeInt32(&result.Semid)
  2462        if err != nil {
  2463          return types.SemctlArgs{}, err
  2464        }
  2465      case 1:
  2466        err = decoder.DecodeInt32(&result.Semnum)
  2467        if err != nil {
  2468          return types.SemctlArgs{}, err
  2469        }
  2470      case 2:
  2471        err = decoder.DecodeInt32(&result.Cmd)
  2472        if err != nil {
  2473          return types.SemctlArgs{}, err
  2474        }
  2475      case 3:
  2476        err = decoder.DecodeUint64(&result.Arg)
  2477        if err != nil {
  2478          return types.SemctlArgs{}, err
  2479        }
  2480      }
  2481    }
  2482    return result, nil
  2483  }
  2484  
  2485  func ParseShmdtArgs(decoder *Decoder) (types.ShmdtArgs, error) {
  2486    var result types.ShmdtArgs
  2487    var err error
  2488  
  2489    var numArgs uint8
  2490    err = decoder.DecodeUint8(&numArgs)
  2491    if err != nil {
  2492      return types.ShmdtArgs{}, err
  2493    }
  2494  
  2495    for arg := 0; arg < int(numArgs); arg++ {
  2496      var currArg uint8
  2497      err = decoder.DecodeUint8(&currArg)
  2498      if err != nil {
  2499        return types.ShmdtArgs{}, err
  2500      }
  2501  
  2502      switch currArg {
  2503      case 0:
  2504        var dataShmaddr uint64
  2505        err = decoder.DecodeUint64(&dataShmaddr)
  2506        if err != nil {
  2507          return types.ShmdtArgs{}, err
  2508        }
  2509        result.Shmaddr = uintptr(dataShmaddr)
  2510      }
  2511    }
  2512    return result, nil
  2513  }
  2514  
  2515  func ParseMsggetArgs(decoder *Decoder) (types.MsggetArgs, error) {
  2516    var result types.MsggetArgs
  2517    var err error
  2518  
  2519    var numArgs uint8
  2520    err = decoder.DecodeUint8(&numArgs)
  2521    if err != nil {
  2522      return types.MsggetArgs{}, err
  2523    }
  2524  
  2525    for arg := 0; arg < int(numArgs); arg++ {
  2526      var currArg uint8
  2527      err = decoder.DecodeUint8(&currArg)
  2528      if err != nil {
  2529        return types.MsggetArgs{}, err
  2530      }
  2531  
  2532      switch currArg {
  2533      case 0:
  2534        err = decoder.DecodeInt32(&result.Key)
  2535        if err != nil {
  2536          return types.MsggetArgs{}, err
  2537        }
  2538      case 1:
  2539        err = decoder.DecodeInt32(&result.Msgflg)
  2540        if err != nil {
  2541          return types.MsggetArgs{}, err
  2542        }
  2543      }
  2544    }
  2545    return result, nil
  2546  }
  2547  
  2548  func ParseMsgsndArgs(decoder *Decoder) (types.MsgsndArgs, error) {
  2549    var result types.MsgsndArgs
  2550    var err error
  2551  
  2552    var numArgs uint8
  2553    err = decoder.DecodeUint8(&numArgs)
  2554    if err != nil {
  2555      return types.MsgsndArgs{}, err
  2556    }
  2557  
  2558    for arg := 0; arg < int(numArgs); arg++ {
  2559      var currArg uint8
  2560      err = decoder.DecodeUint8(&currArg)
  2561      if err != nil {
  2562        return types.MsgsndArgs{}, err
  2563      }
  2564  
  2565      switch currArg {
  2566      case 0:
  2567        err = decoder.DecodeInt32(&result.Msqid)
  2568        if err != nil {
  2569          return types.MsgsndArgs{}, err
  2570        }
  2571      case 1:
  2572        var dataMsgp uint64
  2573        err = decoder.DecodeUint64(&dataMsgp)
  2574        if err != nil {
  2575          return types.MsgsndArgs{}, err
  2576        }
  2577        result.Msgp = uintptr(dataMsgp)
  2578      case 2:
  2579        err = decoder.DecodeUint64(&result.Msgsz)
  2580        if err != nil {
  2581          return types.MsgsndArgs{}, err
  2582        }
  2583      case 3:
  2584        err = decoder.DecodeInt32(&result.Msgflg)
  2585        if err != nil {
  2586          return types.MsgsndArgs{}, err
  2587        }
  2588      }
  2589    }
  2590    return result, nil
  2591  }
  2592  
  2593  func ParseMsgrcvArgs(decoder *Decoder) (types.MsgrcvArgs, error) {
  2594    var result types.MsgrcvArgs
  2595    var err error
  2596  
  2597    var numArgs uint8
  2598    err = decoder.DecodeUint8(&numArgs)
  2599    if err != nil {
  2600      return types.MsgrcvArgs{}, err
  2601    }
  2602  
  2603    for arg := 0; arg < int(numArgs); arg++ {
  2604      var currArg uint8
  2605      err = decoder.DecodeUint8(&currArg)
  2606      if err != nil {
  2607        return types.MsgrcvArgs{}, err
  2608      }
  2609  
  2610      switch currArg {
  2611      case 0:
  2612        err = decoder.DecodeInt32(&result.Msqid)
  2613        if err != nil {
  2614          return types.MsgrcvArgs{}, err
  2615        }
  2616      case 1:
  2617        var dataMsgp uint64
  2618        err = decoder.DecodeUint64(&dataMsgp)
  2619        if err != nil {
  2620          return types.MsgrcvArgs{}, err
  2621        }
  2622        result.Msgp = uintptr(dataMsgp)
  2623      case 2:
  2624        err = decoder.DecodeUint64(&result.Msgsz)
  2625        if err != nil {
  2626          return types.MsgrcvArgs{}, err
  2627        }
  2628      case 3:
  2629        err = decoder.DecodeInt64(&result.Msgtyp)
  2630        if err != nil {
  2631          return types.MsgrcvArgs{}, err
  2632        }
  2633      case 4:
  2634        err = decoder.DecodeInt32(&result.Msgflg)
  2635        if err != nil {
  2636          return types.MsgrcvArgs{}, err
  2637        }
  2638      }
  2639    }
  2640    return result, nil
  2641  }
  2642  
  2643  func ParseMsgctlArgs(decoder *Decoder) (types.MsgctlArgs, error) {
  2644    var result types.MsgctlArgs
  2645    var err error
  2646  
  2647    var numArgs uint8
  2648    err = decoder.DecodeUint8(&numArgs)
  2649    if err != nil {
  2650      return types.MsgctlArgs{}, err
  2651    }
  2652  
  2653    for arg := 0; arg < int(numArgs); arg++ {
  2654      var currArg uint8
  2655      err = decoder.DecodeUint8(&currArg)
  2656      if err != nil {
  2657        return types.MsgctlArgs{}, err
  2658      }
  2659  
  2660      switch currArg {
  2661      case 0:
  2662        err = decoder.DecodeInt32(&result.Msqid)
  2663        if err != nil {
  2664          return types.MsgctlArgs{}, err
  2665        }
  2666      case 1:
  2667        err = decoder.DecodeInt32(&result.Cmd)
  2668        if err != nil {
  2669          return types.MsgctlArgs{}, err
  2670        }
  2671      case 2:
  2672        var dataBuf uint64
  2673        err = decoder.DecodeUint64(&dataBuf)
  2674        if err != nil {
  2675          return types.MsgctlArgs{}, err
  2676        }
  2677        result.Buf = uintptr(dataBuf)
  2678      }
  2679    }
  2680    return result, nil
  2681  }
  2682  
  2683  func ParseFcntlArgs(decoder *Decoder) (types.FcntlArgs, error) {
  2684    var result types.FcntlArgs
  2685    var err error
  2686  
  2687    var numArgs uint8
  2688    err = decoder.DecodeUint8(&numArgs)
  2689    if err != nil {
  2690      return types.FcntlArgs{}, err
  2691    }
  2692  
  2693    for arg := 0; arg < int(numArgs); arg++ {
  2694      var currArg uint8
  2695      err = decoder.DecodeUint8(&currArg)
  2696      if err != nil {
  2697        return types.FcntlArgs{}, err
  2698      }
  2699  
  2700      switch currArg {
  2701      case 0:
  2702        err = decoder.DecodeInt32(&result.Fd)
  2703        if err != nil {
  2704          return types.FcntlArgs{}, err
  2705        }
  2706      case 1:
  2707        err = decoder.DecodeInt32(&result.Cmd)
  2708        if err != nil {
  2709          return types.FcntlArgs{}, err
  2710        }
  2711      case 2:
  2712        err = decoder.DecodeUint64(&result.Arg)
  2713        if err != nil {
  2714          return types.FcntlArgs{}, err
  2715        }
  2716      }
  2717    }
  2718    return result, nil
  2719  }
  2720  
  2721  func ParseFlockArgs(decoder *Decoder) (types.FlockArgs, error) {
  2722    var result types.FlockArgs
  2723    var err error
  2724  
  2725    var numArgs uint8
  2726    err = decoder.DecodeUint8(&numArgs)
  2727    if err != nil {
  2728      return types.FlockArgs{}, err
  2729    }
  2730  
  2731    for arg := 0; arg < int(numArgs); arg++ {
  2732      var currArg uint8
  2733      err = decoder.DecodeUint8(&currArg)
  2734      if err != nil {
  2735        return types.FlockArgs{}, err
  2736      }
  2737  
  2738      switch currArg {
  2739      case 0:
  2740        err = decoder.DecodeInt32(&result.Fd)
  2741        if err != nil {
  2742          return types.FlockArgs{}, err
  2743        }
  2744      case 1:
  2745        err = decoder.DecodeInt32(&result.Operation)
  2746        if err != nil {
  2747          return types.FlockArgs{}, err
  2748        }
  2749      }
  2750    }
  2751    return result, nil
  2752  }
  2753  
  2754  func ParseFsyncArgs(decoder *Decoder) (types.FsyncArgs, error) {
  2755    var result types.FsyncArgs
  2756    var err error
  2757  
  2758    var numArgs uint8
  2759    err = decoder.DecodeUint8(&numArgs)
  2760    if err != nil {
  2761      return types.FsyncArgs{}, err
  2762    }
  2763  
  2764    for arg := 0; arg < int(numArgs); arg++ {
  2765      var currArg uint8
  2766      err = decoder.DecodeUint8(&currArg)
  2767      if err != nil {
  2768        return types.FsyncArgs{}, err
  2769      }
  2770  
  2771      switch currArg {
  2772      case 0:
  2773        err = decoder.DecodeInt32(&result.Fd)
  2774        if err != nil {
  2775          return types.FsyncArgs{}, err
  2776        }
  2777      }
  2778    }
  2779    return result, nil
  2780  }
  2781  
  2782  func ParseFdatasyncArgs(decoder *Decoder) (types.FdatasyncArgs, error) {
  2783    var result types.FdatasyncArgs
  2784    var err error
  2785  
  2786    var numArgs uint8
  2787    err = decoder.DecodeUint8(&numArgs)
  2788    if err != nil {
  2789      return types.FdatasyncArgs{}, err
  2790    }
  2791  
  2792    for arg := 0; arg < int(numArgs); arg++ {
  2793      var currArg uint8
  2794      err = decoder.DecodeUint8(&currArg)
  2795      if err != nil {
  2796        return types.FdatasyncArgs{}, err
  2797      }
  2798  
  2799      switch currArg {
  2800      case 0:
  2801        err = decoder.DecodeInt32(&result.Fd)
  2802        if err != nil {
  2803          return types.FdatasyncArgs{}, err
  2804        }
  2805      }
  2806    }
  2807    return result, nil
  2808  }
  2809  
  2810  func ParseTruncateArgs(decoder *Decoder) (types.TruncateArgs, error) {
  2811    var result types.TruncateArgs
  2812    var err error
  2813  
  2814    var numArgs uint8
  2815    err = decoder.DecodeUint8(&numArgs)
  2816    if err != nil {
  2817      return types.TruncateArgs{}, err
  2818    }
  2819  
  2820    for arg := 0; arg < int(numArgs); arg++ {
  2821      var currArg uint8
  2822      err = decoder.DecodeUint8(&currArg)
  2823      if err != nil {
  2824        return types.TruncateArgs{}, err
  2825      }
  2826  
  2827      switch currArg {
  2828      case 0:
  2829        result.Path, err = decoder.ReadStringFromBuff()
  2830        if err != nil {
  2831          return types.TruncateArgs{}, err
  2832        }
  2833      case 1:
  2834        err = decoder.DecodeUint64(&result.Length)
  2835        if err != nil {
  2836          return types.TruncateArgs{}, err
  2837        }
  2838      }
  2839    }
  2840    return result, nil
  2841  }
  2842  
  2843  func ParseFtruncateArgs(decoder *Decoder) (types.FtruncateArgs, error) {
  2844    var result types.FtruncateArgs
  2845    var err error
  2846  
  2847    var numArgs uint8
  2848    err = decoder.DecodeUint8(&numArgs)
  2849    if err != nil {
  2850      return types.FtruncateArgs{}, err
  2851    }
  2852  
  2853    for arg := 0; arg < int(numArgs); arg++ {
  2854      var currArg uint8
  2855      err = decoder.DecodeUint8(&currArg)
  2856      if err != nil {
  2857        return types.FtruncateArgs{}, err
  2858      }
  2859  
  2860      switch currArg {
  2861      case 0:
  2862        err = decoder.DecodeInt32(&result.Fd)
  2863        if err != nil {
  2864          return types.FtruncateArgs{}, err
  2865        }
  2866      case 1:
  2867        err = decoder.DecodeUint64(&result.Length)
  2868        if err != nil {
  2869          return types.FtruncateArgs{}, err
  2870        }
  2871      }
  2872    }
  2873    return result, nil
  2874  }
  2875  
  2876  func ParseGetdentsArgs(decoder *Decoder) (types.GetdentsArgs, error) {
  2877    var result types.GetdentsArgs
  2878    var err error
  2879  
  2880    var numArgs uint8
  2881    err = decoder.DecodeUint8(&numArgs)
  2882    if err != nil {
  2883      return types.GetdentsArgs{}, err
  2884    }
  2885  
  2886    for arg := 0; arg < int(numArgs); arg++ {
  2887      var currArg uint8
  2888      err = decoder.DecodeUint8(&currArg)
  2889      if err != nil {
  2890        return types.GetdentsArgs{}, err
  2891      }
  2892  
  2893      switch currArg {
  2894      case 0:
  2895        err = decoder.DecodeInt32(&result.Fd)
  2896        if err != nil {
  2897          return types.GetdentsArgs{}, err
  2898        }
  2899      case 1:
  2900        var dataDirp uint64
  2901        err = decoder.DecodeUint64(&dataDirp)
  2902        if err != nil {
  2903          return types.GetdentsArgs{}, err
  2904        }
  2905        result.Dirp = uintptr(dataDirp)
  2906      case 2:
  2907        err = decoder.DecodeUint32(&result.Count)
  2908        if err != nil {
  2909          return types.GetdentsArgs{}, err
  2910        }
  2911      }
  2912    }
  2913    return result, nil
  2914  }
  2915  
  2916  func ParseGetcwdArgs(decoder *Decoder) (types.GetcwdArgs, error) {
  2917    var result types.GetcwdArgs
  2918    var err error
  2919  
  2920    var numArgs uint8
  2921    err = decoder.DecodeUint8(&numArgs)
  2922    if err != nil {
  2923      return types.GetcwdArgs{}, err
  2924    }
  2925  
  2926    for arg := 0; arg < int(numArgs); arg++ {
  2927      var currArg uint8
  2928      err = decoder.DecodeUint8(&currArg)
  2929      if err != nil {
  2930        return types.GetcwdArgs{}, err
  2931      }
  2932  
  2933      switch currArg {
  2934      case 0:
  2935        result.Buf, err = decoder.ReadStringFromBuff()
  2936        if err != nil {
  2937          return types.GetcwdArgs{}, err
  2938        }
  2939      case 1:
  2940        err = decoder.DecodeUint64(&result.Size)
  2941        if err != nil {
  2942          return types.GetcwdArgs{}, err
  2943        }
  2944      }
  2945    }
  2946    return result, nil
  2947  }
  2948  
  2949  func ParseChdirArgs(decoder *Decoder) (types.ChdirArgs, error) {
  2950    var result types.ChdirArgs
  2951    var err error
  2952  
  2953    var numArgs uint8
  2954    err = decoder.DecodeUint8(&numArgs)
  2955    if err != nil {
  2956      return types.ChdirArgs{}, err
  2957    }
  2958  
  2959    for arg := 0; arg < int(numArgs); arg++ {
  2960      var currArg uint8
  2961      err = decoder.DecodeUint8(&currArg)
  2962      if err != nil {
  2963        return types.ChdirArgs{}, err
  2964      }
  2965  
  2966      switch currArg {
  2967      case 0:
  2968        result.Path, err = decoder.ReadStringFromBuff()
  2969        if err != nil {
  2970          return types.ChdirArgs{}, err
  2971        }
  2972      }
  2973    }
  2974    return result, nil
  2975  }
  2976  
  2977  func ParseFchdirArgs(decoder *Decoder) (types.FchdirArgs, error) {
  2978    var result types.FchdirArgs
  2979    var err error
  2980  
  2981    var numArgs uint8
  2982    err = decoder.DecodeUint8(&numArgs)
  2983    if err != nil {
  2984      return types.FchdirArgs{}, err
  2985    }
  2986  
  2987    for arg := 0; arg < int(numArgs); arg++ {
  2988      var currArg uint8
  2989      err = decoder.DecodeUint8(&currArg)
  2990      if err != nil {
  2991        return types.FchdirArgs{}, err
  2992      }
  2993  
  2994      switch currArg {
  2995      case 0:
  2996        err = decoder.DecodeInt32(&result.Fd)
  2997        if err != nil {
  2998          return types.FchdirArgs{}, err
  2999        }
  3000      }
  3001    }
  3002    return result, nil
  3003  }
  3004  
  3005  func ParseRenameArgs(decoder *Decoder) (types.RenameArgs, error) {
  3006    var result types.RenameArgs
  3007    var err error
  3008  
  3009    var numArgs uint8
  3010    err = decoder.DecodeUint8(&numArgs)
  3011    if err != nil {
  3012      return types.RenameArgs{}, err
  3013    }
  3014  
  3015    for arg := 0; arg < int(numArgs); arg++ {
  3016      var currArg uint8
  3017      err = decoder.DecodeUint8(&currArg)
  3018      if err != nil {
  3019        return types.RenameArgs{}, err
  3020      }
  3021  
  3022      switch currArg {
  3023      case 0:
  3024        result.Oldpath, err = decoder.ReadStringFromBuff()
  3025        if err != nil {
  3026          return types.RenameArgs{}, err
  3027        }
  3028      case 1:
  3029        result.Newpath, err = decoder.ReadStringFromBuff()
  3030        if err != nil {
  3031          return types.RenameArgs{}, err
  3032        }
  3033      }
  3034    }
  3035    return result, nil
  3036  }
  3037  
  3038  func ParseMkdirArgs(decoder *Decoder) (types.MkdirArgs, error) {
  3039    var result types.MkdirArgs
  3040    var err error
  3041  
  3042    var numArgs uint8
  3043    err = decoder.DecodeUint8(&numArgs)
  3044    if err != nil {
  3045      return types.MkdirArgs{}, err
  3046    }
  3047  
  3048    for arg := 0; arg < int(numArgs); arg++ {
  3049      var currArg uint8
  3050      err = decoder.DecodeUint8(&currArg)
  3051      if err != nil {
  3052        return types.MkdirArgs{}, err
  3053      }
  3054  
  3055      switch currArg {
  3056      case 0:
  3057        result.Pathname, err = decoder.ReadStringFromBuff()
  3058        if err != nil {
  3059          return types.MkdirArgs{}, err
  3060        }
  3061      case 1:
  3062        err = decoder.DecodeUint32(&result.Mode)
  3063        if err != nil {
  3064          return types.MkdirArgs{}, err
  3065        }
  3066      }
  3067    }
  3068    return result, nil
  3069  }
  3070  
  3071  func ParseRmdirArgs(decoder *Decoder) (types.RmdirArgs, error) {
  3072    var result types.RmdirArgs
  3073    var err error
  3074  
  3075    var numArgs uint8
  3076    err = decoder.DecodeUint8(&numArgs)
  3077    if err != nil {
  3078      return types.RmdirArgs{}, err
  3079    }
  3080  
  3081    for arg := 0; arg < int(numArgs); arg++ {
  3082      var currArg uint8
  3083      err = decoder.DecodeUint8(&currArg)
  3084      if err != nil {
  3085        return types.RmdirArgs{}, err
  3086      }
  3087  
  3088      switch currArg {
  3089      case 0:
  3090        result.Pathname, err = decoder.ReadStringFromBuff()
  3091        if err != nil {
  3092          return types.RmdirArgs{}, err
  3093        }
  3094      }
  3095    }
  3096    return result, nil
  3097  }
  3098  
  3099  func ParseCreatArgs(decoder *Decoder) (types.CreatArgs, error) {
  3100    var result types.CreatArgs
  3101    var err error
  3102  
  3103    var numArgs uint8
  3104    err = decoder.DecodeUint8(&numArgs)
  3105    if err != nil {
  3106      return types.CreatArgs{}, err
  3107    }
  3108  
  3109    for arg := 0; arg < int(numArgs); arg++ {
  3110      var currArg uint8
  3111      err = decoder.DecodeUint8(&currArg)
  3112      if err != nil {
  3113        return types.CreatArgs{}, err
  3114      }
  3115  
  3116      switch currArg {
  3117      case 0:
  3118        result.Pathname, err = decoder.ReadStringFromBuff()
  3119        if err != nil {
  3120          return types.CreatArgs{}, err
  3121        }
  3122      case 1:
  3123        err = decoder.DecodeUint32(&result.Mode)
  3124        if err != nil {
  3125          return types.CreatArgs{}, err
  3126        }
  3127      }
  3128    }
  3129    return result, nil
  3130  }
  3131  
  3132  func ParseLinkArgs(decoder *Decoder) (types.LinkArgs, error) {
  3133    var result types.LinkArgs
  3134    var err error
  3135  
  3136    var numArgs uint8
  3137    err = decoder.DecodeUint8(&numArgs)
  3138    if err != nil {
  3139      return types.LinkArgs{}, err
  3140    }
  3141  
  3142    for arg := 0; arg < int(numArgs); arg++ {
  3143      var currArg uint8
  3144      err = decoder.DecodeUint8(&currArg)
  3145      if err != nil {
  3146        return types.LinkArgs{}, err
  3147      }
  3148  
  3149      switch currArg {
  3150      case 0:
  3151        result.Oldpath, err = decoder.ReadStringFromBuff()
  3152        if err != nil {
  3153          return types.LinkArgs{}, err
  3154        }
  3155      case 1:
  3156        result.Newpath, err = decoder.ReadStringFromBuff()
  3157        if err != nil {
  3158          return types.LinkArgs{}, err
  3159        }
  3160      }
  3161    }
  3162    return result, nil
  3163  }
  3164  
  3165  func ParseUnlinkArgs(decoder *Decoder) (types.UnlinkArgs, error) {
  3166    var result types.UnlinkArgs
  3167    var err error
  3168  
  3169    var numArgs uint8
  3170    err = decoder.DecodeUint8(&numArgs)
  3171    if err != nil {
  3172      return types.UnlinkArgs{}, err
  3173    }
  3174  
  3175    for arg := 0; arg < int(numArgs); arg++ {
  3176      var currArg uint8
  3177      err = decoder.DecodeUint8(&currArg)
  3178      if err != nil {
  3179        return types.UnlinkArgs{}, err
  3180      }
  3181  
  3182      switch currArg {
  3183      case 0:
  3184        result.Pathname, err = decoder.ReadStringFromBuff()
  3185        if err != nil {
  3186          return types.UnlinkArgs{}, err
  3187        }
  3188      }
  3189    }
  3190    return result, nil
  3191  }
  3192  
  3193  func ParseSymlinkArgs(decoder *Decoder) (types.SymlinkArgs, error) {
  3194    var result types.SymlinkArgs
  3195    var err error
  3196  
  3197    var numArgs uint8
  3198    err = decoder.DecodeUint8(&numArgs)
  3199    if err != nil {
  3200      return types.SymlinkArgs{}, err
  3201    }
  3202  
  3203    for arg := 0; arg < int(numArgs); arg++ {
  3204      var currArg uint8
  3205      err = decoder.DecodeUint8(&currArg)
  3206      if err != nil {
  3207        return types.SymlinkArgs{}, err
  3208      }
  3209  
  3210      switch currArg {
  3211      case 0:
  3212        result.Target, err = decoder.ReadStringFromBuff()
  3213        if err != nil {
  3214          return types.SymlinkArgs{}, err
  3215        }
  3216      case 1:
  3217        result.Linkpath, err = decoder.ReadStringFromBuff()
  3218        if err != nil {
  3219          return types.SymlinkArgs{}, err
  3220        }
  3221      }
  3222    }
  3223    return result, nil
  3224  }
  3225  
  3226  func ParseReadlinkArgs(decoder *Decoder) (types.ReadlinkArgs, error) {
  3227    var result types.ReadlinkArgs
  3228    var err error
  3229  
  3230    var numArgs uint8
  3231    err = decoder.DecodeUint8(&numArgs)
  3232    if err != nil {
  3233      return types.ReadlinkArgs{}, err
  3234    }
  3235  
  3236    for arg := 0; arg < int(numArgs); arg++ {
  3237      var currArg uint8
  3238      err = decoder.DecodeUint8(&currArg)
  3239      if err != nil {
  3240        return types.ReadlinkArgs{}, err
  3241      }
  3242  
  3243      switch currArg {
  3244      case 0:
  3245        result.Pathname, err = decoder.ReadStringFromBuff()
  3246        if err != nil {
  3247          return types.ReadlinkArgs{}, err
  3248        }
  3249      case 1:
  3250        result.Buf, err = decoder.ReadStringFromBuff()
  3251        if err != nil {
  3252          return types.ReadlinkArgs{}, err
  3253        }
  3254      case 2:
  3255        err = decoder.DecodeUint64(&result.Bufsiz)
  3256        if err != nil {
  3257          return types.ReadlinkArgs{}, err
  3258        }
  3259      }
  3260    }
  3261    return result, nil
  3262  }
  3263  
  3264  func ParseChmodArgs(decoder *Decoder) (types.ChmodArgs, error) {
  3265    var result types.ChmodArgs
  3266    var err error
  3267  
  3268    var numArgs uint8
  3269    err = decoder.DecodeUint8(&numArgs)
  3270    if err != nil {
  3271      return types.ChmodArgs{}, err
  3272    }
  3273  
  3274    for arg := 0; arg < int(numArgs); arg++ {
  3275      var currArg uint8
  3276      err = decoder.DecodeUint8(&currArg)
  3277      if err != nil {
  3278        return types.ChmodArgs{}, err
  3279      }
  3280  
  3281      switch currArg {
  3282      case 0:
  3283        result.Pathname, err = decoder.ReadStringFromBuff()
  3284        if err != nil {
  3285          return types.ChmodArgs{}, err
  3286        }
  3287      case 1:
  3288        err = decoder.DecodeUint32(&result.Mode)
  3289        if err != nil {
  3290          return types.ChmodArgs{}, err
  3291        }
  3292      }
  3293    }
  3294    return result, nil
  3295  }
  3296  
  3297  func ParseFchmodArgs(decoder *Decoder) (types.FchmodArgs, error) {
  3298    var result types.FchmodArgs
  3299    var err error
  3300  
  3301    var numArgs uint8
  3302    err = decoder.DecodeUint8(&numArgs)
  3303    if err != nil {
  3304      return types.FchmodArgs{}, err
  3305    }
  3306  
  3307    for arg := 0; arg < int(numArgs); arg++ {
  3308      var currArg uint8
  3309      err = decoder.DecodeUint8(&currArg)
  3310      if err != nil {
  3311        return types.FchmodArgs{}, err
  3312      }
  3313  
  3314      switch currArg {
  3315      case 0:
  3316        err = decoder.DecodeInt32(&result.Fd)
  3317        if err != nil {
  3318          return types.FchmodArgs{}, err
  3319        }
  3320      case 1:
  3321        err = decoder.DecodeUint32(&result.Mode)
  3322        if err != nil {
  3323          return types.FchmodArgs{}, err
  3324        }
  3325      }
  3326    }
  3327    return result, nil
  3328  }
  3329  
  3330  func ParseChownArgs(decoder *Decoder) (types.ChownArgs, error) {
  3331    var result types.ChownArgs
  3332    var err error
  3333  
  3334    var numArgs uint8
  3335    err = decoder.DecodeUint8(&numArgs)
  3336    if err != nil {
  3337      return types.ChownArgs{}, err
  3338    }
  3339  
  3340    for arg := 0; arg < int(numArgs); arg++ {
  3341      var currArg uint8
  3342      err = decoder.DecodeUint8(&currArg)
  3343      if err != nil {
  3344        return types.ChownArgs{}, err
  3345      }
  3346  
  3347      switch currArg {
  3348      case 0:
  3349        result.Pathname, err = decoder.ReadStringFromBuff()
  3350        if err != nil {
  3351          return types.ChownArgs{}, err
  3352        }
  3353      case 1:
  3354        err = decoder.DecodeInt32(&result.Owner)
  3355        if err != nil {
  3356          return types.ChownArgs{}, err
  3357        }
  3358      case 2:
  3359        err = decoder.DecodeInt32(&result.Group)
  3360        if err != nil {
  3361          return types.ChownArgs{}, err
  3362        }
  3363      }
  3364    }
  3365    return result, nil
  3366  }
  3367  
  3368  func ParseFchownArgs(decoder *Decoder) (types.FchownArgs, error) {
  3369    var result types.FchownArgs
  3370    var err error
  3371  
  3372    var numArgs uint8
  3373    err = decoder.DecodeUint8(&numArgs)
  3374    if err != nil {
  3375      return types.FchownArgs{}, err
  3376    }
  3377  
  3378    for arg := 0; arg < int(numArgs); arg++ {
  3379      var currArg uint8
  3380      err = decoder.DecodeUint8(&currArg)
  3381      if err != nil {
  3382        return types.FchownArgs{}, err
  3383      }
  3384  
  3385      switch currArg {
  3386      case 0:
  3387        err = decoder.DecodeInt32(&result.Fd)
  3388        if err != nil {
  3389          return types.FchownArgs{}, err
  3390        }
  3391      case 1:
  3392        err = decoder.DecodeInt32(&result.Owner)
  3393        if err != nil {
  3394          return types.FchownArgs{}, err
  3395        }
  3396      case 2:
  3397        err = decoder.DecodeInt32(&result.Group)
  3398        if err != nil {
  3399          return types.FchownArgs{}, err
  3400        }
  3401      }
  3402    }
  3403    return result, nil
  3404  }
  3405  
  3406  func ParseLchownArgs(decoder *Decoder) (types.LchownArgs, error) {
  3407    var result types.LchownArgs
  3408    var err error
  3409  
  3410    var numArgs uint8
  3411    err = decoder.DecodeUint8(&numArgs)
  3412    if err != nil {
  3413      return types.LchownArgs{}, err
  3414    }
  3415  
  3416    for arg := 0; arg < int(numArgs); arg++ {
  3417      var currArg uint8
  3418      err = decoder.DecodeUint8(&currArg)
  3419      if err != nil {
  3420        return types.LchownArgs{}, err
  3421      }
  3422  
  3423      switch currArg {
  3424      case 0:
  3425        result.Pathname, err = decoder.ReadStringFromBuff()
  3426        if err != nil {
  3427          return types.LchownArgs{}, err
  3428        }
  3429      case 1:
  3430        err = decoder.DecodeInt32(&result.Owner)
  3431        if err != nil {
  3432          return types.LchownArgs{}, err
  3433        }
  3434      case 2:
  3435        err = decoder.DecodeInt32(&result.Group)
  3436        if err != nil {
  3437          return types.LchownArgs{}, err
  3438        }
  3439      }
  3440    }
  3441    return result, nil
  3442  }
  3443  
  3444  func ParseUmaskArgs(decoder *Decoder) (types.UmaskArgs, error) {
  3445    var result types.UmaskArgs
  3446    var err error
  3447  
  3448    var numArgs uint8
  3449    err = decoder.DecodeUint8(&numArgs)
  3450    if err != nil {
  3451      return types.UmaskArgs{}, err
  3452    }
  3453  
  3454    for arg := 0; arg < int(numArgs); arg++ {
  3455      var currArg uint8
  3456      err = decoder.DecodeUint8(&currArg)
  3457      if err != nil {
  3458        return types.UmaskArgs{}, err
  3459      }
  3460  
  3461      switch currArg {
  3462      case 0:
  3463        err = decoder.DecodeUint32(&result.Mask)
  3464        if err != nil {
  3465          return types.UmaskArgs{}, err
  3466        }
  3467      }
  3468    }
  3469    return result, nil
  3470  }
  3471  
  3472  func ParseGettimeofdayArgs(decoder *Decoder) (types.GettimeofdayArgs, error) {
  3473    var result types.GettimeofdayArgs
  3474    var err error
  3475  
  3476    var numArgs uint8
  3477    err = decoder.DecodeUint8(&numArgs)
  3478    if err != nil {
  3479      return types.GettimeofdayArgs{}, err
  3480    }
  3481  
  3482    for arg := 0; arg < int(numArgs); arg++ {
  3483      var currArg uint8
  3484      err = decoder.DecodeUint8(&currArg)
  3485      if err != nil {
  3486        return types.GettimeofdayArgs{}, err
  3487      }
  3488  
  3489      switch currArg {
  3490      case 0:
  3491        var dataTv uint64
  3492        err = decoder.DecodeUint64(&dataTv)
  3493        if err != nil {
  3494          return types.GettimeofdayArgs{}, err
  3495        }
  3496        result.Tv = uintptr(dataTv)
  3497      case 1:
  3498        var dataTz uint64
  3499        err = decoder.DecodeUint64(&dataTz)
  3500        if err != nil {
  3501          return types.GettimeofdayArgs{}, err
  3502        }
  3503        result.Tz = uintptr(dataTz)
  3504      }
  3505    }
  3506    return result, nil
  3507  }
  3508  
  3509  func ParseGetrlimitArgs(decoder *Decoder) (types.GetrlimitArgs, error) {
  3510    var result types.GetrlimitArgs
  3511    var err error
  3512  
  3513    var numArgs uint8
  3514    err = decoder.DecodeUint8(&numArgs)
  3515    if err != nil {
  3516      return types.GetrlimitArgs{}, err
  3517    }
  3518  
  3519    for arg := 0; arg < int(numArgs); arg++ {
  3520      var currArg uint8
  3521      err = decoder.DecodeUint8(&currArg)
  3522      if err != nil {
  3523        return types.GetrlimitArgs{}, err
  3524      }
  3525  
  3526      switch currArg {
  3527      case 0:
  3528        err = decoder.DecodeInt32(&result.Resource)
  3529        if err != nil {
  3530          return types.GetrlimitArgs{}, err
  3531        }
  3532      case 1:
  3533        var dataRlim uint64
  3534        err = decoder.DecodeUint64(&dataRlim)
  3535        if err != nil {
  3536          return types.GetrlimitArgs{}, err
  3537        }
  3538        result.Rlim = uintptr(dataRlim)
  3539      }
  3540    }
  3541    return result, nil
  3542  }
  3543  
  3544  func ParseGetrusageArgs(decoder *Decoder) (types.GetrusageArgs, error) {
  3545    var result types.GetrusageArgs
  3546    var err error
  3547  
  3548    var numArgs uint8
  3549    err = decoder.DecodeUint8(&numArgs)
  3550    if err != nil {
  3551      return types.GetrusageArgs{}, err
  3552    }
  3553  
  3554    for arg := 0; arg < int(numArgs); arg++ {
  3555      var currArg uint8
  3556      err = decoder.DecodeUint8(&currArg)
  3557      if err != nil {
  3558        return types.GetrusageArgs{}, err
  3559      }
  3560  
  3561      switch currArg {
  3562      case 0:
  3563        err = decoder.DecodeInt32(&result.Who)
  3564        if err != nil {
  3565          return types.GetrusageArgs{}, err
  3566        }
  3567      case 1:
  3568        var dataUsage uint64
  3569        err = decoder.DecodeUint64(&dataUsage)
  3570        if err != nil {
  3571          return types.GetrusageArgs{}, err
  3572        }
  3573        result.Usage = uintptr(dataUsage)
  3574      }
  3575    }
  3576    return result, nil
  3577  }
  3578  
  3579  func ParseSysinfoArgs(decoder *Decoder) (types.SysinfoArgs, error) {
  3580    var result types.SysinfoArgs
  3581    var err error
  3582  
  3583    var numArgs uint8
  3584    err = decoder.DecodeUint8(&numArgs)
  3585    if err != nil {
  3586      return types.SysinfoArgs{}, err
  3587    }
  3588  
  3589    for arg := 0; arg < int(numArgs); arg++ {
  3590      var currArg uint8
  3591      err = decoder.DecodeUint8(&currArg)
  3592      if err != nil {
  3593        return types.SysinfoArgs{}, err
  3594      }
  3595  
  3596      switch currArg {
  3597      case 0:
  3598        var dataInfo uint64
  3599        err = decoder.DecodeUint64(&dataInfo)
  3600        if err != nil {
  3601          return types.SysinfoArgs{}, err
  3602        }
  3603        result.Info = uintptr(dataInfo)
  3604      }
  3605    }
  3606    return result, nil
  3607  }
  3608  
  3609  func ParseTimesArgs(decoder *Decoder) (types.TimesArgs, error) {
  3610    var result types.TimesArgs
  3611    var err error
  3612  
  3613    var numArgs uint8
  3614    err = decoder.DecodeUint8(&numArgs)
  3615    if err != nil {
  3616      return types.TimesArgs{}, err
  3617    }
  3618  
  3619    for arg := 0; arg < int(numArgs); arg++ {
  3620      var currArg uint8
  3621      err = decoder.DecodeUint8(&currArg)
  3622      if err != nil {
  3623        return types.TimesArgs{}, err
  3624      }
  3625  
  3626      switch currArg {
  3627      case 0:
  3628        var dataBuf uint64
  3629        err = decoder.DecodeUint64(&dataBuf)
  3630        if err != nil {
  3631          return types.TimesArgs{}, err
  3632        }
  3633        result.Buf = uintptr(dataBuf)
  3634      }
  3635    }
  3636    return result, nil
  3637  }
  3638  
  3639  func ParsePtraceArgs(decoder *Decoder) (types.PtraceArgs, error) {
  3640    var result types.PtraceArgs
  3641    var err error
  3642  
  3643    var numArgs uint8
  3644    err = decoder.DecodeUint8(&numArgs)
  3645    if err != nil {
  3646      return types.PtraceArgs{}, err
  3647    }
  3648  
  3649    for arg := 0; arg < int(numArgs); arg++ {
  3650      var currArg uint8
  3651      err = decoder.DecodeUint8(&currArg)
  3652      if err != nil {
  3653        return types.PtraceArgs{}, err
  3654      }
  3655  
  3656      switch currArg {
  3657      case 0:
  3658        err = decoder.DecodeInt64(&result.Request)
  3659        if err != nil {
  3660          return types.PtraceArgs{}, err
  3661        }
  3662      case 1:
  3663        err = decoder.DecodeInt32(&result.Pid)
  3664        if err != nil {
  3665          return types.PtraceArgs{}, err
  3666        }
  3667      case 2:
  3668        var dataAddr uint64
  3669        err = decoder.DecodeUint64(&dataAddr)
  3670        if err != nil {
  3671          return types.PtraceArgs{}, err
  3672        }
  3673        result.Addr = uintptr(dataAddr)
  3674      case 3:
  3675        var dataData uint64
  3676        err = decoder.DecodeUint64(&dataData)
  3677        if err != nil {
  3678          return types.PtraceArgs{}, err
  3679        }
  3680        result.Data = uintptr(dataData)
  3681      }
  3682    }
  3683    return result, nil
  3684  }
  3685  
  3686  func ParseGetuidArgs(decoder *Decoder) (types.GetuidArgs, error) {
  3687    return types.GetuidArgs{}, nil
  3688  }
  3689  
  3690  func ParseSyslogArgs(decoder *Decoder) (types.SyslogArgs, error) {
  3691    var result types.SyslogArgs
  3692    var err error
  3693  
  3694    var numArgs uint8
  3695    err = decoder.DecodeUint8(&numArgs)
  3696    if err != nil {
  3697      return types.SyslogArgs{}, err
  3698    }
  3699  
  3700    for arg := 0; arg < int(numArgs); arg++ {
  3701      var currArg uint8
  3702      err = decoder.DecodeUint8(&currArg)
  3703      if err != nil {
  3704        return types.SyslogArgs{}, err
  3705      }
  3706  
  3707      switch currArg {
  3708      case 0:
  3709        err = decoder.DecodeInt32(&result.Type)
  3710        if err != nil {
  3711          return types.SyslogArgs{}, err
  3712        }
  3713      case 1:
  3714        result.Bufp, err = decoder.ReadStringFromBuff()
  3715        if err != nil {
  3716          return types.SyslogArgs{}, err
  3717        }
  3718      case 2:
  3719        err = decoder.DecodeInt32(&result.Len)
  3720        if err != nil {
  3721          return types.SyslogArgs{}, err
  3722        }
  3723      }
  3724    }
  3725    return result, nil
  3726  }
  3727  
  3728  func ParseGetgidArgs(decoder *Decoder) (types.GetgidArgs, error) {
  3729    return types.GetgidArgs{}, nil
  3730  }
  3731  
  3732  func ParseSetuidArgs(decoder *Decoder) (types.SetuidArgs, error) {
  3733    var result types.SetuidArgs
  3734    var err error
  3735  
  3736    var numArgs uint8
  3737    err = decoder.DecodeUint8(&numArgs)
  3738    if err != nil {
  3739      return types.SetuidArgs{}, err
  3740    }
  3741  
  3742    for arg := 0; arg < int(numArgs); arg++ {
  3743      var currArg uint8
  3744      err = decoder.DecodeUint8(&currArg)
  3745      if err != nil {
  3746        return types.SetuidArgs{}, err
  3747      }
  3748  
  3749      switch currArg {
  3750      case 0:
  3751        err = decoder.DecodeInt32(&result.Uid)
  3752        if err != nil {
  3753          return types.SetuidArgs{}, err
  3754        }
  3755      }
  3756    }
  3757    return result, nil
  3758  }
  3759  
  3760  func ParseSetgidArgs(decoder *Decoder) (types.SetgidArgs, error) {
  3761    var result types.SetgidArgs
  3762    var err error
  3763  
  3764    var numArgs uint8
  3765    err = decoder.DecodeUint8(&numArgs)
  3766    if err != nil {
  3767      return types.SetgidArgs{}, err
  3768    }
  3769  
  3770    for arg := 0; arg < int(numArgs); arg++ {
  3771      var currArg uint8
  3772      err = decoder.DecodeUint8(&currArg)
  3773      if err != nil {
  3774        return types.SetgidArgs{}, err
  3775      }
  3776  
  3777      switch currArg {
  3778      case 0:
  3779        err = decoder.DecodeInt32(&result.Gid)
  3780        if err != nil {
  3781          return types.SetgidArgs{}, err
  3782        }
  3783      }
  3784    }
  3785    return result, nil
  3786  }
  3787  
  3788  func ParseGeteuidArgs(decoder *Decoder) (types.GeteuidArgs, error) {
  3789    return types.GeteuidArgs{}, nil
  3790  }
  3791  
  3792  func ParseGetegidArgs(decoder *Decoder) (types.GetegidArgs, error) {
  3793    return types.GetegidArgs{}, nil
  3794  }
  3795  
  3796  func ParseSetpgidArgs(decoder *Decoder) (types.SetpgidArgs, error) {
  3797    var result types.SetpgidArgs
  3798    var err error
  3799  
  3800    var numArgs uint8
  3801    err = decoder.DecodeUint8(&numArgs)
  3802    if err != nil {
  3803      return types.SetpgidArgs{}, err
  3804    }
  3805  
  3806    for arg := 0; arg < int(numArgs); arg++ {
  3807      var currArg uint8
  3808      err = decoder.DecodeUint8(&currArg)
  3809      if err != nil {
  3810        return types.SetpgidArgs{}, err
  3811      }
  3812  
  3813      switch currArg {
  3814      case 0:
  3815        err = decoder.DecodeInt32(&result.Pid)
  3816        if err != nil {
  3817          return types.SetpgidArgs{}, err
  3818        }
  3819      case 1:
  3820        err = decoder.DecodeInt32(&result.Pgid)
  3821        if err != nil {
  3822          return types.SetpgidArgs{}, err
  3823        }
  3824      }
  3825    }
  3826    return result, nil
  3827  }
  3828  
  3829  func ParseGetppidArgs(decoder *Decoder) (types.GetppidArgs, error) {
  3830    return types.GetppidArgs{}, nil
  3831  }
  3832  
  3833  func ParseGetpgrpArgs(decoder *Decoder) (types.GetpgrpArgs, error) {
  3834    return types.GetpgrpArgs{}, nil
  3835  }
  3836  
  3837  func ParseSetsidArgs(decoder *Decoder) (types.SetsidArgs, error) {
  3838    return types.SetsidArgs{}, nil
  3839  }
  3840  
  3841  func ParseSetreuidArgs(decoder *Decoder) (types.SetreuidArgs, error) {
  3842    var result types.SetreuidArgs
  3843    var err error
  3844  
  3845    var numArgs uint8
  3846    err = decoder.DecodeUint8(&numArgs)
  3847    if err != nil {
  3848      return types.SetreuidArgs{}, err
  3849    }
  3850  
  3851    for arg := 0; arg < int(numArgs); arg++ {
  3852      var currArg uint8
  3853      err = decoder.DecodeUint8(&currArg)
  3854      if err != nil {
  3855        return types.SetreuidArgs{}, err
  3856      }
  3857  
  3858      switch currArg {
  3859      case 0:
  3860        err = decoder.DecodeInt32(&result.Ruid)
  3861        if err != nil {
  3862          return types.SetreuidArgs{}, err
  3863        }
  3864      case 1:
  3865        err = decoder.DecodeInt32(&result.Euid)
  3866        if err != nil {
  3867          return types.SetreuidArgs{}, err
  3868        }
  3869      }
  3870    }
  3871    return result, nil
  3872  }
  3873  
  3874  func ParseSetregidArgs(decoder *Decoder) (types.SetregidArgs, error) {
  3875    var result types.SetregidArgs
  3876    var err error
  3877  
  3878    var numArgs uint8
  3879    err = decoder.DecodeUint8(&numArgs)
  3880    if err != nil {
  3881      return types.SetregidArgs{}, err
  3882    }
  3883  
  3884    for arg := 0; arg < int(numArgs); arg++ {
  3885      var currArg uint8
  3886      err = decoder.DecodeUint8(&currArg)
  3887      if err != nil {
  3888        return types.SetregidArgs{}, err
  3889      }
  3890  
  3891      switch currArg {
  3892      case 0:
  3893        err = decoder.DecodeInt32(&result.Rgid)
  3894        if err != nil {
  3895          return types.SetregidArgs{}, err
  3896        }
  3897      case 1:
  3898        err = decoder.DecodeInt32(&result.Egid)
  3899        if err != nil {
  3900          return types.SetregidArgs{}, err
  3901        }
  3902      }
  3903    }
  3904    return result, nil
  3905  }
  3906  
  3907  func ParseGetgroupsArgs(decoder *Decoder) (types.GetgroupsArgs, error) {
  3908    var result types.GetgroupsArgs
  3909    var err error
  3910  
  3911    var numArgs uint8
  3912    err = decoder.DecodeUint8(&numArgs)
  3913    if err != nil {
  3914      return types.GetgroupsArgs{}, err
  3915    }
  3916  
  3917    for arg := 0; arg < int(numArgs); arg++ {
  3918      var currArg uint8
  3919      err = decoder.DecodeUint8(&currArg)
  3920      if err != nil {
  3921        return types.GetgroupsArgs{}, err
  3922      }
  3923  
  3924      switch currArg {
  3925      case 0:
  3926        err = decoder.DecodeInt32(&result.Size)
  3927        if err != nil {
  3928          return types.GetgroupsArgs{}, err
  3929        }
  3930      case 1:
  3931        var dataList uint64
  3932        err = decoder.DecodeUint64(&dataList)
  3933        if err != nil {
  3934          return types.GetgroupsArgs{}, err
  3935        }
  3936        result.List = uintptr(dataList)
  3937      }
  3938    }
  3939    return result, nil
  3940  }
  3941  
  3942  func ParseSetgroupsArgs(decoder *Decoder) (types.SetgroupsArgs, error) {
  3943    var result types.SetgroupsArgs
  3944    var err error
  3945  
  3946    var numArgs uint8
  3947    err = decoder.DecodeUint8(&numArgs)
  3948    if err != nil {
  3949      return types.SetgroupsArgs{}, err
  3950    }
  3951  
  3952    for arg := 0; arg < int(numArgs); arg++ {
  3953      var currArg uint8
  3954      err = decoder.DecodeUint8(&currArg)
  3955      if err != nil {
  3956        return types.SetgroupsArgs{}, err
  3957      }
  3958  
  3959      switch currArg {
  3960      case 0:
  3961        err = decoder.DecodeInt32(&result.Size)
  3962        if err != nil {
  3963          return types.SetgroupsArgs{}, err
  3964        }
  3965      case 1:
  3966        var dataList uint64
  3967        err = decoder.DecodeUint64(&dataList)
  3968        if err != nil {
  3969          return types.SetgroupsArgs{}, err
  3970        }
  3971        result.List = uintptr(dataList)
  3972      }
  3973    }
  3974    return result, nil
  3975  }
  3976  
  3977  func ParseSetresuidArgs(decoder *Decoder) (types.SetresuidArgs, error) {
  3978    var result types.SetresuidArgs
  3979    var err error
  3980  
  3981    var numArgs uint8
  3982    err = decoder.DecodeUint8(&numArgs)
  3983    if err != nil {
  3984      return types.SetresuidArgs{}, err
  3985    }
  3986  
  3987    for arg := 0; arg < int(numArgs); arg++ {
  3988      var currArg uint8
  3989      err = decoder.DecodeUint8(&currArg)
  3990      if err != nil {
  3991        return types.SetresuidArgs{}, err
  3992      }
  3993  
  3994      switch currArg {
  3995      case 0:
  3996        err = decoder.DecodeInt32(&result.Ruid)
  3997        if err != nil {
  3998          return types.SetresuidArgs{}, err
  3999        }
  4000      case 1:
  4001        err = decoder.DecodeInt32(&result.Euid)
  4002        if err != nil {
  4003          return types.SetresuidArgs{}, err
  4004        }
  4005      case 2:
  4006        err = decoder.DecodeInt32(&result.Suid)
  4007        if err != nil {
  4008          return types.SetresuidArgs{}, err
  4009        }
  4010      }
  4011    }
  4012    return result, nil
  4013  }
  4014  
  4015  func ParseGetresuidArgs(decoder *Decoder) (types.GetresuidArgs, error) {
  4016    var result types.GetresuidArgs
  4017    var err error
  4018  
  4019    var numArgs uint8
  4020    err = decoder.DecodeUint8(&numArgs)
  4021    if err != nil {
  4022      return types.GetresuidArgs{}, err
  4023    }
  4024  
  4025    for arg := 0; arg < int(numArgs); arg++ {
  4026      var currArg uint8
  4027      err = decoder.DecodeUint8(&currArg)
  4028      if err != nil {
  4029        return types.GetresuidArgs{}, err
  4030      }
  4031  
  4032      switch currArg {
  4033      case 0:
  4034        var dataRuid uint64
  4035        err = decoder.DecodeUint64(&dataRuid)
  4036        if err != nil {
  4037          return types.GetresuidArgs{}, err
  4038        }
  4039        result.Ruid = uintptr(dataRuid)
  4040      case 1:
  4041        var dataEuid uint64
  4042        err = decoder.DecodeUint64(&dataEuid)
  4043        if err != nil {
  4044          return types.GetresuidArgs{}, err
  4045        }
  4046        result.Euid = uintptr(dataEuid)
  4047      case 2:
  4048        var dataSuid uint64
  4049        err = decoder.DecodeUint64(&dataSuid)
  4050        if err != nil {
  4051          return types.GetresuidArgs{}, err
  4052        }
  4053        result.Suid = uintptr(dataSuid)
  4054      }
  4055    }
  4056    return result, nil
  4057  }
  4058  
  4059  func ParseSetresgidArgs(decoder *Decoder) (types.SetresgidArgs, error) {
  4060    var result types.SetresgidArgs
  4061    var err error
  4062  
  4063    var numArgs uint8
  4064    err = decoder.DecodeUint8(&numArgs)
  4065    if err != nil {
  4066      return types.SetresgidArgs{}, err
  4067    }
  4068  
  4069    for arg := 0; arg < int(numArgs); arg++ {
  4070      var currArg uint8
  4071      err = decoder.DecodeUint8(&currArg)
  4072      if err != nil {
  4073        return types.SetresgidArgs{}, err
  4074      }
  4075  
  4076      switch currArg {
  4077      case 0:
  4078        err = decoder.DecodeInt32(&result.Rgid)
  4079        if err != nil {
  4080          return types.SetresgidArgs{}, err
  4081        }
  4082      case 1:
  4083        err = decoder.DecodeInt32(&result.Egid)
  4084        if err != nil {
  4085          return types.SetresgidArgs{}, err
  4086        }
  4087      case 2:
  4088        err = decoder.DecodeInt32(&result.Sgid)
  4089        if err != nil {
  4090          return types.SetresgidArgs{}, err
  4091        }
  4092      }
  4093    }
  4094    return result, nil
  4095  }
  4096  
  4097  func ParseGetresgidArgs(decoder *Decoder) (types.GetresgidArgs, error) {
  4098    var result types.GetresgidArgs
  4099    var err error
  4100  
  4101    var numArgs uint8
  4102    err = decoder.DecodeUint8(&numArgs)
  4103    if err != nil {
  4104      return types.GetresgidArgs{}, err
  4105    }
  4106  
  4107    for arg := 0; arg < int(numArgs); arg++ {
  4108      var currArg uint8
  4109      err = decoder.DecodeUint8(&currArg)
  4110      if err != nil {
  4111        return types.GetresgidArgs{}, err
  4112      }
  4113  
  4114      switch currArg {
  4115      case 0:
  4116        var dataRgid uint64
  4117        err = decoder.DecodeUint64(&dataRgid)
  4118        if err != nil {
  4119          return types.GetresgidArgs{}, err
  4120        }
  4121        result.Rgid = uintptr(dataRgid)
  4122      case 1:
  4123        var dataEgid uint64
  4124        err = decoder.DecodeUint64(&dataEgid)
  4125        if err != nil {
  4126          return types.GetresgidArgs{}, err
  4127        }
  4128        result.Egid = uintptr(dataEgid)
  4129      case 2:
  4130        var dataSgid uint64
  4131        err = decoder.DecodeUint64(&dataSgid)
  4132        if err != nil {
  4133          return types.GetresgidArgs{}, err
  4134        }
  4135        result.Sgid = uintptr(dataSgid)
  4136      }
  4137    }
  4138    return result, nil
  4139  }
  4140  
  4141  func ParseGetpgidArgs(decoder *Decoder) (types.GetpgidArgs, error) {
  4142    var result types.GetpgidArgs
  4143    var err error
  4144  
  4145    var numArgs uint8
  4146    err = decoder.DecodeUint8(&numArgs)
  4147    if err != nil {
  4148      return types.GetpgidArgs{}, err
  4149    }
  4150  
  4151    for arg := 0; arg < int(numArgs); arg++ {
  4152      var currArg uint8
  4153      err = decoder.DecodeUint8(&currArg)
  4154      if err != nil {
  4155        return types.GetpgidArgs{}, err
  4156      }
  4157  
  4158      switch currArg {
  4159      case 0:
  4160        err = decoder.DecodeInt32(&result.Pid)
  4161        if err != nil {
  4162          return types.GetpgidArgs{}, err
  4163        }
  4164      }
  4165    }
  4166    return result, nil
  4167  }
  4168  
  4169  func ParseSetfsuidArgs(decoder *Decoder) (types.SetfsuidArgs, error) {
  4170    var result types.SetfsuidArgs
  4171    var err error
  4172  
  4173    var numArgs uint8
  4174    err = decoder.DecodeUint8(&numArgs)
  4175    if err != nil {
  4176      return types.SetfsuidArgs{}, err
  4177    }
  4178  
  4179    for arg := 0; arg < int(numArgs); arg++ {
  4180      var currArg uint8
  4181      err = decoder.DecodeUint8(&currArg)
  4182      if err != nil {
  4183        return types.SetfsuidArgs{}, err
  4184      }
  4185  
  4186      switch currArg {
  4187      case 0:
  4188        err = decoder.DecodeInt32(&result.Fsuid)
  4189        if err != nil {
  4190          return types.SetfsuidArgs{}, err
  4191        }
  4192      }
  4193    }
  4194    return result, nil
  4195  }
  4196  
  4197  func ParseSetfsgidArgs(decoder *Decoder) (types.SetfsgidArgs, error) {
  4198    var result types.SetfsgidArgs
  4199    var err error
  4200  
  4201    var numArgs uint8
  4202    err = decoder.DecodeUint8(&numArgs)
  4203    if err != nil {
  4204      return types.SetfsgidArgs{}, err
  4205    }
  4206  
  4207    for arg := 0; arg < int(numArgs); arg++ {
  4208      var currArg uint8
  4209      err = decoder.DecodeUint8(&currArg)
  4210      if err != nil {
  4211        return types.SetfsgidArgs{}, err
  4212      }
  4213  
  4214      switch currArg {
  4215      case 0:
  4216        err = decoder.DecodeInt32(&result.Fsgid)
  4217        if err != nil {
  4218          return types.SetfsgidArgs{}, err
  4219        }
  4220      }
  4221    }
  4222    return result, nil
  4223  }
  4224  
  4225  func ParseGetsidArgs(decoder *Decoder) (types.GetsidArgs, error) {
  4226    var result types.GetsidArgs
  4227    var err error
  4228  
  4229    var numArgs uint8
  4230    err = decoder.DecodeUint8(&numArgs)
  4231    if err != nil {
  4232      return types.GetsidArgs{}, err
  4233    }
  4234  
  4235    for arg := 0; arg < int(numArgs); arg++ {
  4236      var currArg uint8
  4237      err = decoder.DecodeUint8(&currArg)
  4238      if err != nil {
  4239        return types.GetsidArgs{}, err
  4240      }
  4241  
  4242      switch currArg {
  4243      case 0:
  4244        err = decoder.DecodeInt32(&result.Pid)
  4245        if err != nil {
  4246          return types.GetsidArgs{}, err
  4247        }
  4248      }
  4249    }
  4250    return result, nil
  4251  }
  4252  
  4253  func ParseCapgetArgs(decoder *Decoder) (types.CapgetArgs, error) {
  4254    var result types.CapgetArgs
  4255    var err error
  4256  
  4257    var numArgs uint8
  4258    err = decoder.DecodeUint8(&numArgs)
  4259    if err != nil {
  4260      return types.CapgetArgs{}, err
  4261    }
  4262  
  4263    for arg := 0; arg < int(numArgs); arg++ {
  4264      var currArg uint8
  4265      err = decoder.DecodeUint8(&currArg)
  4266      if err != nil {
  4267        return types.CapgetArgs{}, err
  4268      }
  4269  
  4270      switch currArg {
  4271      case 0:
  4272        var dataHdrp uint64
  4273        err = decoder.DecodeUint64(&dataHdrp)
  4274        if err != nil {
  4275          return types.CapgetArgs{}, err
  4276        }
  4277        result.Hdrp = uintptr(dataHdrp)
  4278      case 1:
  4279        var dataDatap uint64
  4280        err = decoder.DecodeUint64(&dataDatap)
  4281        if err != nil {
  4282          return types.CapgetArgs{}, err
  4283        }
  4284        result.Datap = uintptr(dataDatap)
  4285      }
  4286    }
  4287    return result, nil
  4288  }
  4289  
  4290  func ParseCapsetArgs(decoder *Decoder) (types.CapsetArgs, error) {
  4291    var result types.CapsetArgs
  4292    var err error
  4293  
  4294    var numArgs uint8
  4295    err = decoder.DecodeUint8(&numArgs)
  4296    if err != nil {
  4297      return types.CapsetArgs{}, err
  4298    }
  4299  
  4300    for arg := 0; arg < int(numArgs); arg++ {
  4301      var currArg uint8
  4302      err = decoder.DecodeUint8(&currArg)
  4303      if err != nil {
  4304        return types.CapsetArgs{}, err
  4305      }
  4306  
  4307      switch currArg {
  4308      case 0:
  4309        var dataHdrp uint64
  4310        err = decoder.DecodeUint64(&dataHdrp)
  4311        if err != nil {
  4312          return types.CapsetArgs{}, err
  4313        }
  4314        result.Hdrp = uintptr(dataHdrp)
  4315      case 1:
  4316        var dataDatap uint64
  4317        err = decoder.DecodeUint64(&dataDatap)
  4318        if err != nil {
  4319          return types.CapsetArgs{}, err
  4320        }
  4321        result.Datap = uintptr(dataDatap)
  4322      }
  4323    }
  4324    return result, nil
  4325  }
  4326  
  4327  func ParseRtSigpendingArgs(decoder *Decoder) (types.RtSigpendingArgs, error) {
  4328    var result types.RtSigpendingArgs
  4329    var err error
  4330  
  4331    var numArgs uint8
  4332    err = decoder.DecodeUint8(&numArgs)
  4333    if err != nil {
  4334      return types.RtSigpendingArgs{}, err
  4335    }
  4336  
  4337    for arg := 0; arg < int(numArgs); arg++ {
  4338      var currArg uint8
  4339      err = decoder.DecodeUint8(&currArg)
  4340      if err != nil {
  4341        return types.RtSigpendingArgs{}, err
  4342      }
  4343  
  4344      switch currArg {
  4345      case 0:
  4346        var dataSet uint64
  4347        err = decoder.DecodeUint64(&dataSet)
  4348        if err != nil {
  4349          return types.RtSigpendingArgs{}, err
  4350        }
  4351        result.Set = uintptr(dataSet)
  4352      case 1:
  4353        err = decoder.DecodeUint64(&result.Sigsetsize)
  4354        if err != nil {
  4355          return types.RtSigpendingArgs{}, err
  4356        }
  4357      }
  4358    }
  4359    return result, nil
  4360  }
  4361  
  4362  func ParseRtSigtimedwaitArgs(decoder *Decoder) (types.RtSigtimedwaitArgs, error) {
  4363    var result types.RtSigtimedwaitArgs
  4364    var err error
  4365  
  4366    var numArgs uint8
  4367    err = decoder.DecodeUint8(&numArgs)
  4368    if err != nil {
  4369      return types.RtSigtimedwaitArgs{}, err
  4370    }
  4371  
  4372    for arg := 0; arg < int(numArgs); arg++ {
  4373      var currArg uint8
  4374      err = decoder.DecodeUint8(&currArg)
  4375      if err != nil {
  4376        return types.RtSigtimedwaitArgs{}, err
  4377      }
  4378  
  4379      switch currArg {
  4380      case 0:
  4381        var dataSet uint64
  4382        err = decoder.DecodeUint64(&dataSet)
  4383        if err != nil {
  4384          return types.RtSigtimedwaitArgs{}, err
  4385        }
  4386        result.Set = uintptr(dataSet)
  4387      case 1:
  4388        var dataInfo uint64
  4389        err = decoder.DecodeUint64(&dataInfo)
  4390        if err != nil {
  4391          return types.RtSigtimedwaitArgs{}, err
  4392        }
  4393        result.Info = uintptr(dataInfo)
  4394      case 2:
  4395        result.Timeout, err = decoder.ReadTimespec()
  4396        if err != nil {
  4397          return types.RtSigtimedwaitArgs{}, err
  4398        }
  4399      case 3:
  4400        err = decoder.DecodeUint64(&result.Sigsetsize)
  4401        if err != nil {
  4402          return types.RtSigtimedwaitArgs{}, err
  4403        }
  4404      }
  4405    }
  4406    return result, nil
  4407  }
  4408  
  4409  func ParseRtSigqueueinfoArgs(decoder *Decoder) (types.RtSigqueueinfoArgs, error) {
  4410    var result types.RtSigqueueinfoArgs
  4411    var err error
  4412  
  4413    var numArgs uint8
  4414    err = decoder.DecodeUint8(&numArgs)
  4415    if err != nil {
  4416      return types.RtSigqueueinfoArgs{}, err
  4417    }
  4418  
  4419    for arg := 0; arg < int(numArgs); arg++ {
  4420      var currArg uint8
  4421      err = decoder.DecodeUint8(&currArg)
  4422      if err != nil {
  4423        return types.RtSigqueueinfoArgs{}, err
  4424      }
  4425  
  4426      switch currArg {
  4427      case 0:
  4428        err = decoder.DecodeInt32(&result.Tgid)
  4429        if err != nil {
  4430          return types.RtSigqueueinfoArgs{}, err
  4431        }
  4432      case 1:
  4433        err = decoder.DecodeInt32(&result.Sig)
  4434        if err != nil {
  4435          return types.RtSigqueueinfoArgs{}, err
  4436        }
  4437      case 2:
  4438        var dataInfo uint64
  4439        err = decoder.DecodeUint64(&dataInfo)
  4440        if err != nil {
  4441          return types.RtSigqueueinfoArgs{}, err
  4442        }
  4443        result.Info = uintptr(dataInfo)
  4444      }
  4445    }
  4446    return result, nil
  4447  }
  4448  
  4449  func ParseRtSigsuspendArgs(decoder *Decoder) (types.RtSigsuspendArgs, error) {
  4450    var result types.RtSigsuspendArgs
  4451    var err error
  4452  
  4453    var numArgs uint8
  4454    err = decoder.DecodeUint8(&numArgs)
  4455    if err != nil {
  4456      return types.RtSigsuspendArgs{}, err
  4457    }
  4458  
  4459    for arg := 0; arg < int(numArgs); arg++ {
  4460      var currArg uint8
  4461      err = decoder.DecodeUint8(&currArg)
  4462      if err != nil {
  4463        return types.RtSigsuspendArgs{}, err
  4464      }
  4465  
  4466      switch currArg {
  4467      case 0:
  4468        var dataMask uint64
  4469        err = decoder.DecodeUint64(&dataMask)
  4470        if err != nil {
  4471          return types.RtSigsuspendArgs{}, err
  4472        }
  4473        result.Mask = uintptr(dataMask)
  4474      case 1:
  4475        err = decoder.DecodeUint64(&result.Sigsetsize)
  4476        if err != nil {
  4477          return types.RtSigsuspendArgs{}, err
  4478        }
  4479      }
  4480    }
  4481    return result, nil
  4482  }
  4483  
  4484  func ParseSigaltstackArgs(decoder *Decoder) (types.SigaltstackArgs, error) {
  4485    var result types.SigaltstackArgs
  4486    var err error
  4487  
  4488    var numArgs uint8
  4489    err = decoder.DecodeUint8(&numArgs)
  4490    if err != nil {
  4491      return types.SigaltstackArgs{}, err
  4492    }
  4493  
  4494    for arg := 0; arg < int(numArgs); arg++ {
  4495      var currArg uint8
  4496      err = decoder.DecodeUint8(&currArg)
  4497      if err != nil {
  4498        return types.SigaltstackArgs{}, err
  4499      }
  4500  
  4501      switch currArg {
  4502      case 0:
  4503        var dataSs uint64
  4504        err = decoder.DecodeUint64(&dataSs)
  4505        if err != nil {
  4506          return types.SigaltstackArgs{}, err
  4507        }
  4508        result.Ss = uintptr(dataSs)
  4509      case 1:
  4510        var dataOldSs uint64
  4511        err = decoder.DecodeUint64(&dataOldSs)
  4512        if err != nil {
  4513          return types.SigaltstackArgs{}, err
  4514        }
  4515        result.OldSs = uintptr(dataOldSs)
  4516      }
  4517    }
  4518    return result, nil
  4519  }
  4520  
  4521  func ParseUtimeArgs(decoder *Decoder) (types.UtimeArgs, error) {
  4522    var result types.UtimeArgs
  4523    var err error
  4524  
  4525    var numArgs uint8
  4526    err = decoder.DecodeUint8(&numArgs)
  4527    if err != nil {
  4528      return types.UtimeArgs{}, err
  4529    }
  4530  
  4531    for arg := 0; arg < int(numArgs); arg++ {
  4532      var currArg uint8
  4533      err = decoder.DecodeUint8(&currArg)
  4534      if err != nil {
  4535        return types.UtimeArgs{}, err
  4536      }
  4537  
  4538      switch currArg {
  4539      case 0:
  4540        result.Filename, err = decoder.ReadStringFromBuff()
  4541        if err != nil {
  4542          return types.UtimeArgs{}, err
  4543        }
  4544      case 1:
  4545        var dataTimes uint64
  4546        err = decoder.DecodeUint64(&dataTimes)
  4547        if err != nil {
  4548          return types.UtimeArgs{}, err
  4549        }
  4550        result.Times = uintptr(dataTimes)
  4551      }
  4552    }
  4553    return result, nil
  4554  }
  4555  
  4556  func ParseMknodArgs(decoder *Decoder) (types.MknodArgs, error) {
  4557    var result types.MknodArgs
  4558    var err error
  4559  
  4560    var numArgs uint8
  4561    err = decoder.DecodeUint8(&numArgs)
  4562    if err != nil {
  4563      return types.MknodArgs{}, err
  4564    }
  4565  
  4566    for arg := 0; arg < int(numArgs); arg++ {
  4567      var currArg uint8
  4568      err = decoder.DecodeUint8(&currArg)
  4569      if err != nil {
  4570        return types.MknodArgs{}, err
  4571      }
  4572  
  4573      switch currArg {
  4574      case 0:
  4575        result.Pathname, err = decoder.ReadStringFromBuff()
  4576        if err != nil {
  4577          return types.MknodArgs{}, err
  4578        }
  4579      case 1:
  4580        err = decoder.DecodeUint32(&result.Mode)
  4581        if err != nil {
  4582          return types.MknodArgs{}, err
  4583        }
  4584      case 2:
  4585        err = decoder.DecodeUint32(&result.Dev)
  4586        if err != nil {
  4587          return types.MknodArgs{}, err
  4588        }
  4589      }
  4590    }
  4591    return result, nil
  4592  }
  4593  
  4594  func ParseUselibArgs(decoder *Decoder) (types.UselibArgs, error) {
  4595    var result types.UselibArgs
  4596    var err error
  4597  
  4598    var numArgs uint8
  4599    err = decoder.DecodeUint8(&numArgs)
  4600    if err != nil {
  4601      return types.UselibArgs{}, err
  4602    }
  4603  
  4604    for arg := 0; arg < int(numArgs); arg++ {
  4605      var currArg uint8
  4606      err = decoder.DecodeUint8(&currArg)
  4607      if err != nil {
  4608        return types.UselibArgs{}, err
  4609      }
  4610  
  4611      switch currArg {
  4612      case 0:
  4613        result.Library, err = decoder.ReadStringFromBuff()
  4614        if err != nil {
  4615          return types.UselibArgs{}, err
  4616        }
  4617      }
  4618    }
  4619    return result, nil
  4620  }
  4621  
  4622  func ParsePersonalityArgs(decoder *Decoder) (types.PersonalityArgs, error) {
  4623    var result types.PersonalityArgs
  4624    var err error
  4625  
  4626    var numArgs uint8
  4627    err = decoder.DecodeUint8(&numArgs)
  4628    if err != nil {
  4629      return types.PersonalityArgs{}, err
  4630    }
  4631  
  4632    for arg := 0; arg < int(numArgs); arg++ {
  4633      var currArg uint8
  4634      err = decoder.DecodeUint8(&currArg)
  4635      if err != nil {
  4636        return types.PersonalityArgs{}, err
  4637      }
  4638  
  4639      switch currArg {
  4640      case 0:
  4641        err = decoder.DecodeUint64(&result.Persona)
  4642        if err != nil {
  4643          return types.PersonalityArgs{}, err
  4644        }
  4645      }
  4646    }
  4647    return result, nil
  4648  }
  4649  
  4650  func ParseUstatArgs(decoder *Decoder) (types.UstatArgs, error) {
  4651    var result types.UstatArgs
  4652    var err error
  4653  
  4654    var numArgs uint8
  4655    err = decoder.DecodeUint8(&numArgs)
  4656    if err != nil {
  4657      return types.UstatArgs{}, err
  4658    }
  4659  
  4660    for arg := 0; arg < int(numArgs); arg++ {
  4661      var currArg uint8
  4662      err = decoder.DecodeUint8(&currArg)
  4663      if err != nil {
  4664        return types.UstatArgs{}, err
  4665      }
  4666  
  4667      switch currArg {
  4668      case 0:
  4669        err = decoder.DecodeUint32(&result.Dev)
  4670        if err != nil {
  4671          return types.UstatArgs{}, err
  4672        }
  4673      case 1:
  4674        var dataUbuf uint64
  4675        err = decoder.DecodeUint64(&dataUbuf)
  4676        if err != nil {
  4677          return types.UstatArgs{}, err
  4678        }
  4679        result.Ubuf = uintptr(dataUbuf)
  4680      }
  4681    }
  4682    return result, nil
  4683  }
  4684  
  4685  func ParseStatfsArgs(decoder *Decoder) (types.StatfsArgs, error) {
  4686    var result types.StatfsArgs
  4687    var err error
  4688  
  4689    var numArgs uint8
  4690    err = decoder.DecodeUint8(&numArgs)
  4691    if err != nil {
  4692      return types.StatfsArgs{}, err
  4693    }
  4694  
  4695    for arg := 0; arg < int(numArgs); arg++ {
  4696      var currArg uint8
  4697      err = decoder.DecodeUint8(&currArg)
  4698      if err != nil {
  4699        return types.StatfsArgs{}, err
  4700      }
  4701  
  4702      switch currArg {
  4703      case 0:
  4704        result.Path, err = decoder.ReadStringFromBuff()
  4705        if err != nil {
  4706          return types.StatfsArgs{}, err
  4707        }
  4708      case 1:
  4709        var dataBuf uint64
  4710        err = decoder.DecodeUint64(&dataBuf)
  4711        if err != nil {
  4712          return types.StatfsArgs{}, err
  4713        }
  4714        result.Buf = uintptr(dataBuf)
  4715      }
  4716    }
  4717    return result, nil
  4718  }
  4719  
  4720  func ParseFstatfsArgs(decoder *Decoder) (types.FstatfsArgs, error) {
  4721    var result types.FstatfsArgs
  4722    var err error
  4723  
  4724    var numArgs uint8
  4725    err = decoder.DecodeUint8(&numArgs)
  4726    if err != nil {
  4727      return types.FstatfsArgs{}, err
  4728    }
  4729  
  4730    for arg := 0; arg < int(numArgs); arg++ {
  4731      var currArg uint8
  4732      err = decoder.DecodeUint8(&currArg)
  4733      if err != nil {
  4734        return types.FstatfsArgs{}, err
  4735      }
  4736  
  4737      switch currArg {
  4738      case 0:
  4739        err = decoder.DecodeInt32(&result.Fd)
  4740        if err != nil {
  4741          return types.FstatfsArgs{}, err
  4742        }
  4743      case 1:
  4744        var dataBuf uint64
  4745        err = decoder.DecodeUint64(&dataBuf)
  4746        if err != nil {
  4747          return types.FstatfsArgs{}, err
  4748        }
  4749        result.Buf = uintptr(dataBuf)
  4750      }
  4751    }
  4752    return result, nil
  4753  }
  4754  
  4755  func ParseSysfsArgs(decoder *Decoder) (types.SysfsArgs, error) {
  4756    var result types.SysfsArgs
  4757    var err error
  4758  
  4759    var numArgs uint8
  4760    err = decoder.DecodeUint8(&numArgs)
  4761    if err != nil {
  4762      return types.SysfsArgs{}, err
  4763    }
  4764  
  4765    for arg := 0; arg < int(numArgs); arg++ {
  4766      var currArg uint8
  4767      err = decoder.DecodeUint8(&currArg)
  4768      if err != nil {
  4769        return types.SysfsArgs{}, err
  4770      }
  4771  
  4772      switch currArg {
  4773      case 0:
  4774        err = decoder.DecodeInt32(&result.Option)
  4775        if err != nil {
  4776          return types.SysfsArgs{}, err
  4777        }
  4778      }
  4779    }
  4780    return result, nil
  4781  }
  4782  
  4783  func ParseGetpriorityArgs(decoder *Decoder) (types.GetpriorityArgs, error) {
  4784    var result types.GetpriorityArgs
  4785    var err error
  4786  
  4787    var numArgs uint8
  4788    err = decoder.DecodeUint8(&numArgs)
  4789    if err != nil {
  4790      return types.GetpriorityArgs{}, err
  4791    }
  4792  
  4793    for arg := 0; arg < int(numArgs); arg++ {
  4794      var currArg uint8
  4795      err = decoder.DecodeUint8(&currArg)
  4796      if err != nil {
  4797        return types.GetpriorityArgs{}, err
  4798      }
  4799  
  4800      switch currArg {
  4801      case 0:
  4802        err = decoder.DecodeInt32(&result.Which)
  4803        if err != nil {
  4804          return types.GetpriorityArgs{}, err
  4805        }
  4806      case 1:
  4807        err = decoder.DecodeInt32(&result.Who)
  4808        if err != nil {
  4809          return types.GetpriorityArgs{}, err
  4810        }
  4811      }
  4812    }
  4813    return result, nil
  4814  }
  4815  
  4816  func ParseSetpriorityArgs(decoder *Decoder) (types.SetpriorityArgs, error) {
  4817    var result types.SetpriorityArgs
  4818    var err error
  4819  
  4820    var numArgs uint8
  4821    err = decoder.DecodeUint8(&numArgs)
  4822    if err != nil {
  4823      return types.SetpriorityArgs{}, err
  4824    }
  4825  
  4826    for arg := 0; arg < int(numArgs); arg++ {
  4827      var currArg uint8
  4828      err = decoder.DecodeUint8(&currArg)
  4829      if err != nil {
  4830        return types.SetpriorityArgs{}, err
  4831      }
  4832  
  4833      switch currArg {
  4834      case 0:
  4835        err = decoder.DecodeInt32(&result.Which)
  4836        if err != nil {
  4837          return types.SetpriorityArgs{}, err
  4838        }
  4839      case 1:
  4840        err = decoder.DecodeInt32(&result.Who)
  4841        if err != nil {
  4842          return types.SetpriorityArgs{}, err
  4843        }
  4844      case 2:
  4845        err = decoder.DecodeInt32(&result.Prio)
  4846        if err != nil {
  4847          return types.SetpriorityArgs{}, err
  4848        }
  4849      }
  4850    }
  4851    return result, nil
  4852  }
  4853  
  4854  func ParseSchedSetparamArgs(decoder *Decoder) (types.SchedSetparamArgs, error) {
  4855    var result types.SchedSetparamArgs
  4856    var err error
  4857  
  4858    var numArgs uint8
  4859    err = decoder.DecodeUint8(&numArgs)
  4860    if err != nil {
  4861      return types.SchedSetparamArgs{}, err
  4862    }
  4863  
  4864    for arg := 0; arg < int(numArgs); arg++ {
  4865      var currArg uint8
  4866      err = decoder.DecodeUint8(&currArg)
  4867      if err != nil {
  4868        return types.SchedSetparamArgs{}, err
  4869      }
  4870  
  4871      switch currArg {
  4872      case 0:
  4873        err = decoder.DecodeInt32(&result.Pid)
  4874        if err != nil {
  4875          return types.SchedSetparamArgs{}, err
  4876        }
  4877      case 1:
  4878        var dataParam uint64
  4879        err = decoder.DecodeUint64(&dataParam)
  4880        if err != nil {
  4881          return types.SchedSetparamArgs{}, err
  4882        }
  4883        result.Param = uintptr(dataParam)
  4884      }
  4885    }
  4886    return result, nil
  4887  }
  4888  
  4889  func ParseSchedGetparamArgs(decoder *Decoder) (types.SchedGetparamArgs, error) {
  4890    var result types.SchedGetparamArgs
  4891    var err error
  4892  
  4893    var numArgs uint8
  4894    err = decoder.DecodeUint8(&numArgs)
  4895    if err != nil {
  4896      return types.SchedGetparamArgs{}, err
  4897    }
  4898  
  4899    for arg := 0; arg < int(numArgs); arg++ {
  4900      var currArg uint8
  4901      err = decoder.DecodeUint8(&currArg)
  4902      if err != nil {
  4903        return types.SchedGetparamArgs{}, err
  4904      }
  4905  
  4906      switch currArg {
  4907      case 0:
  4908        err = decoder.DecodeInt32(&result.Pid)
  4909        if err != nil {
  4910          return types.SchedGetparamArgs{}, err
  4911        }
  4912      case 1:
  4913        var dataParam uint64
  4914        err = decoder.DecodeUint64(&dataParam)
  4915        if err != nil {
  4916          return types.SchedGetparamArgs{}, err
  4917        }
  4918        result.Param = uintptr(dataParam)
  4919      }
  4920    }
  4921    return result, nil
  4922  }
  4923  
  4924  func ParseSchedSetschedulerArgs(decoder *Decoder) (types.SchedSetschedulerArgs, error) {
  4925    var result types.SchedSetschedulerArgs
  4926    var err error
  4927  
  4928    var numArgs uint8
  4929    err = decoder.DecodeUint8(&numArgs)
  4930    if err != nil {
  4931      return types.SchedSetschedulerArgs{}, err
  4932    }
  4933  
  4934    for arg := 0; arg < int(numArgs); arg++ {
  4935      var currArg uint8
  4936      err = decoder.DecodeUint8(&currArg)
  4937      if err != nil {
  4938        return types.SchedSetschedulerArgs{}, err
  4939      }
  4940  
  4941      switch currArg {
  4942      case 0:
  4943        err = decoder.DecodeInt32(&result.Pid)
  4944        if err != nil {
  4945          return types.SchedSetschedulerArgs{}, err
  4946        }
  4947      case 1:
  4948        err = decoder.DecodeInt32(&result.Policy)
  4949        if err != nil {
  4950          return types.SchedSetschedulerArgs{}, err
  4951        }
  4952      case 2:
  4953        var dataParam uint64
  4954        err = decoder.DecodeUint64(&dataParam)
  4955        if err != nil {
  4956          return types.SchedSetschedulerArgs{}, err
  4957        }
  4958        result.Param = uintptr(dataParam)
  4959      }
  4960    }
  4961    return result, nil
  4962  }
  4963  
  4964  func ParseSchedGetschedulerArgs(decoder *Decoder) (types.SchedGetschedulerArgs, error) {
  4965    var result types.SchedGetschedulerArgs
  4966    var err error
  4967  
  4968    var numArgs uint8
  4969    err = decoder.DecodeUint8(&numArgs)
  4970    if err != nil {
  4971      return types.SchedGetschedulerArgs{}, err
  4972    }
  4973  
  4974    for arg := 0; arg < int(numArgs); arg++ {
  4975      var currArg uint8
  4976      err = decoder.DecodeUint8(&currArg)
  4977      if err != nil {
  4978        return types.SchedGetschedulerArgs{}, err
  4979      }
  4980  
  4981      switch currArg {
  4982      case 0:
  4983        err = decoder.DecodeInt32(&result.Pid)
  4984        if err != nil {
  4985          return types.SchedGetschedulerArgs{}, err
  4986        }
  4987      }
  4988    }
  4989    return result, nil
  4990  }
  4991  
  4992  func ParseSchedGetPriorityMaxArgs(decoder *Decoder) (types.SchedGetPriorityMaxArgs, error) {
  4993    var result types.SchedGetPriorityMaxArgs
  4994    var err error
  4995  
  4996    var numArgs uint8
  4997    err = decoder.DecodeUint8(&numArgs)
  4998    if err != nil {
  4999      return types.SchedGetPriorityMaxArgs{}, err
  5000    }
  5001  
  5002    for arg := 0; arg < int(numArgs); arg++ {
  5003      var currArg uint8
  5004      err = decoder.DecodeUint8(&currArg)
  5005      if err != nil {
  5006        return types.SchedGetPriorityMaxArgs{}, err
  5007      }
  5008  
  5009      switch currArg {
  5010      case 0:
  5011        err = decoder.DecodeInt32(&result.Policy)
  5012        if err != nil {
  5013          return types.SchedGetPriorityMaxArgs{}, err
  5014        }
  5015      }
  5016    }
  5017    return result, nil
  5018  }
  5019  
  5020  func ParseSchedGetPriorityMinArgs(decoder *Decoder) (types.SchedGetPriorityMinArgs, error) {
  5021    var result types.SchedGetPriorityMinArgs
  5022    var err error
  5023  
  5024    var numArgs uint8
  5025    err = decoder.DecodeUint8(&numArgs)
  5026    if err != nil {
  5027      return types.SchedGetPriorityMinArgs{}, err
  5028    }
  5029  
  5030    for arg := 0; arg < int(numArgs); arg++ {
  5031      var currArg uint8
  5032      err = decoder.DecodeUint8(&currArg)
  5033      if err != nil {
  5034        return types.SchedGetPriorityMinArgs{}, err
  5035      }
  5036  
  5037      switch currArg {
  5038      case 0:
  5039        err = decoder.DecodeInt32(&result.Policy)
  5040        if err != nil {
  5041          return types.SchedGetPriorityMinArgs{}, err
  5042        }
  5043      }
  5044    }
  5045    return result, nil
  5046  }
  5047  
  5048  func ParseSchedRrGetIntervalArgs(decoder *Decoder) (types.SchedRrGetIntervalArgs, error) {
  5049    var result types.SchedRrGetIntervalArgs
  5050    var err error
  5051  
  5052    var numArgs uint8
  5053    err = decoder.DecodeUint8(&numArgs)
  5054    if err != nil {
  5055      return types.SchedRrGetIntervalArgs{}, err
  5056    }
  5057  
  5058    for arg := 0; arg < int(numArgs); arg++ {
  5059      var currArg uint8
  5060      err = decoder.DecodeUint8(&currArg)
  5061      if err != nil {
  5062        return types.SchedRrGetIntervalArgs{}, err
  5063      }
  5064  
  5065      switch currArg {
  5066      case 0:
  5067        err = decoder.DecodeInt32(&result.Pid)
  5068        if err != nil {
  5069          return types.SchedRrGetIntervalArgs{}, err
  5070        }
  5071      case 1:
  5072        result.Tp, err = decoder.ReadTimespec()
  5073        if err != nil {
  5074          return types.SchedRrGetIntervalArgs{}, err
  5075        }
  5076      }
  5077    }
  5078    return result, nil
  5079  }
  5080  
  5081  func ParseMlockArgs(decoder *Decoder) (types.MlockArgs, error) {
  5082    var result types.MlockArgs
  5083    var err error
  5084  
  5085    var numArgs uint8
  5086    err = decoder.DecodeUint8(&numArgs)
  5087    if err != nil {
  5088      return types.MlockArgs{}, err
  5089    }
  5090  
  5091    for arg := 0; arg < int(numArgs); arg++ {
  5092      var currArg uint8
  5093      err = decoder.DecodeUint8(&currArg)
  5094      if err != nil {
  5095        return types.MlockArgs{}, err
  5096      }
  5097  
  5098      switch currArg {
  5099      case 0:
  5100        var dataAddr uint64
  5101        err = decoder.DecodeUint64(&dataAddr)
  5102        if err != nil {
  5103          return types.MlockArgs{}, err
  5104        }
  5105        result.Addr = uintptr(dataAddr)
  5106      case 1:
  5107        err = decoder.DecodeUint64(&result.Len)
  5108        if err != nil {
  5109          return types.MlockArgs{}, err
  5110        }
  5111      }
  5112    }
  5113    return result, nil
  5114  }
  5115  
  5116  func ParseMunlockArgs(decoder *Decoder) (types.MunlockArgs, error) {
  5117    var result types.MunlockArgs
  5118    var err error
  5119  
  5120    var numArgs uint8
  5121    err = decoder.DecodeUint8(&numArgs)
  5122    if err != nil {
  5123      return types.MunlockArgs{}, err
  5124    }
  5125  
  5126    for arg := 0; arg < int(numArgs); arg++ {
  5127      var currArg uint8
  5128      err = decoder.DecodeUint8(&currArg)
  5129      if err != nil {
  5130        return types.MunlockArgs{}, err
  5131      }
  5132  
  5133      switch currArg {
  5134      case 0:
  5135        var dataAddr uint64
  5136        err = decoder.DecodeUint64(&dataAddr)
  5137        if err != nil {
  5138          return types.MunlockArgs{}, err
  5139        }
  5140        result.Addr = uintptr(dataAddr)
  5141      case 1:
  5142        err = decoder.DecodeUint64(&result.Len)
  5143        if err != nil {
  5144          return types.MunlockArgs{}, err
  5145        }
  5146      }
  5147    }
  5148    return result, nil
  5149  }
  5150  
  5151  func ParseMlockallArgs(decoder *Decoder) (types.MlockallArgs, error) {
  5152    var result types.MlockallArgs
  5153    var err error
  5154  
  5155    var numArgs uint8
  5156    err = decoder.DecodeUint8(&numArgs)
  5157    if err != nil {
  5158      return types.MlockallArgs{}, err
  5159    }
  5160  
  5161    for arg := 0; arg < int(numArgs); arg++ {
  5162      var currArg uint8
  5163      err = decoder.DecodeUint8(&currArg)
  5164      if err != nil {
  5165        return types.MlockallArgs{}, err
  5166      }
  5167  
  5168      switch currArg {
  5169      case 0:
  5170        err = decoder.DecodeInt32(&result.Flags)
  5171        if err != nil {
  5172          return types.MlockallArgs{}, err
  5173        }
  5174      }
  5175    }
  5176    return result, nil
  5177  }
  5178  
  5179  func ParseMunlockallArgs(decoder *Decoder) (types.MunlockallArgs, error) {
  5180    return types.MunlockallArgs{}, nil
  5181  }
  5182  
  5183  func ParseVhangupArgs(decoder *Decoder) (types.VhangupArgs, error) {
  5184    return types.VhangupArgs{}, nil
  5185  }
  5186  
  5187  func ParseModifyLdtArgs(decoder *Decoder) (types.ModifyLdtArgs, error) {
  5188    var result types.ModifyLdtArgs
  5189    var err error
  5190  
  5191    var numArgs uint8
  5192    err = decoder.DecodeUint8(&numArgs)
  5193    if err != nil {
  5194      return types.ModifyLdtArgs{}, err
  5195    }
  5196  
  5197    for arg := 0; arg < int(numArgs); arg++ {
  5198      var currArg uint8
  5199      err = decoder.DecodeUint8(&currArg)
  5200      if err != nil {
  5201        return types.ModifyLdtArgs{}, err
  5202      }
  5203  
  5204      switch currArg {
  5205      case 0:
  5206        err = decoder.DecodeInt32(&result.Func)
  5207        if err != nil {
  5208          return types.ModifyLdtArgs{}, err
  5209        }
  5210      case 1:
  5211        var dataPtr uint64
  5212        err = decoder.DecodeUint64(&dataPtr)
  5213        if err != nil {
  5214          return types.ModifyLdtArgs{}, err
  5215        }
  5216        result.Ptr = uintptr(dataPtr)
  5217      case 2:
  5218        err = decoder.DecodeUint64(&result.Bytecount)
  5219        if err != nil {
  5220          return types.ModifyLdtArgs{}, err
  5221        }
  5222      }
  5223    }
  5224    return result, nil
  5225  }
  5226  
  5227  func ParsePivotRootArgs(decoder *Decoder) (types.PivotRootArgs, error) {
  5228    var result types.PivotRootArgs
  5229    var err error
  5230  
  5231    var numArgs uint8
  5232    err = decoder.DecodeUint8(&numArgs)
  5233    if err != nil {
  5234      return types.PivotRootArgs{}, err
  5235    }
  5236  
  5237    for arg := 0; arg < int(numArgs); arg++ {
  5238      var currArg uint8
  5239      err = decoder.DecodeUint8(&currArg)
  5240      if err != nil {
  5241        return types.PivotRootArgs{}, err
  5242      }
  5243  
  5244      switch currArg {
  5245      case 0:
  5246        result.NewRoot, err = decoder.ReadStringFromBuff()
  5247        if err != nil {
  5248          return types.PivotRootArgs{}, err
  5249        }
  5250      case 1:
  5251        result.PutOld, err = decoder.ReadStringFromBuff()
  5252        if err != nil {
  5253          return types.PivotRootArgs{}, err
  5254        }
  5255      }
  5256    }
  5257    return result, nil
  5258  }
  5259  
  5260  func ParseSysctlArgs(decoder *Decoder) (types.SysctlArgs, error) {
  5261    var result types.SysctlArgs
  5262    var err error
  5263  
  5264    var numArgs uint8
  5265    err = decoder.DecodeUint8(&numArgs)
  5266    if err != nil {
  5267      return types.SysctlArgs{}, err
  5268    }
  5269  
  5270    for arg := 0; arg < int(numArgs); arg++ {
  5271      var currArg uint8
  5272      err = decoder.DecodeUint8(&currArg)
  5273      if err != nil {
  5274        return types.SysctlArgs{}, err
  5275      }
  5276  
  5277      switch currArg {
  5278      case 0:
  5279        var dataArgs uint64
  5280        err = decoder.DecodeUint64(&dataArgs)
  5281        if err != nil {
  5282          return types.SysctlArgs{}, err
  5283        }
  5284        result.Args = uintptr(dataArgs)
  5285      }
  5286    }
  5287    return result, nil
  5288  }
  5289  
  5290  func ParsePrctlArgs(decoder *Decoder) (types.PrctlArgs, error) {
  5291    var result types.PrctlArgs
  5292    var err error
  5293  
  5294    var numArgs uint8
  5295    err = decoder.DecodeUint8(&numArgs)
  5296    if err != nil {
  5297      return types.PrctlArgs{}, err
  5298    }
  5299  
  5300    for arg := 0; arg < int(numArgs); arg++ {
  5301      var currArg uint8
  5302      err = decoder.DecodeUint8(&currArg)
  5303      if err != nil {
  5304        return types.PrctlArgs{}, err
  5305      }
  5306  
  5307      switch currArg {
  5308      case 0:
  5309        err = decoder.DecodeInt32(&result.Option)
  5310        if err != nil {
  5311          return types.PrctlArgs{}, err
  5312        }
  5313      case 1:
  5314        err = decoder.DecodeUint64(&result.Arg2)
  5315        if err != nil {
  5316          return types.PrctlArgs{}, err
  5317        }
  5318      case 2:
  5319        err = decoder.DecodeUint64(&result.Arg3)
  5320        if err != nil {
  5321          return types.PrctlArgs{}, err
  5322        }
  5323      case 3:
  5324        err = decoder.DecodeUint64(&result.Arg4)
  5325        if err != nil {
  5326          return types.PrctlArgs{}, err
  5327        }
  5328      case 4:
  5329        err = decoder.DecodeUint64(&result.Arg5)
  5330        if err != nil {
  5331          return types.PrctlArgs{}, err
  5332        }
  5333      }
  5334    }
  5335    return result, nil
  5336  }
  5337  
  5338  func ParseArchPrctlArgs(decoder *Decoder) (types.ArchPrctlArgs, error) {
  5339    var result types.ArchPrctlArgs
  5340    var err error
  5341  
  5342    var numArgs uint8
  5343    err = decoder.DecodeUint8(&numArgs)
  5344    if err != nil {
  5345      return types.ArchPrctlArgs{}, err
  5346    }
  5347  
  5348    for arg := 0; arg < int(numArgs); arg++ {
  5349      var currArg uint8
  5350      err = decoder.DecodeUint8(&currArg)
  5351      if err != nil {
  5352        return types.ArchPrctlArgs{}, err
  5353      }
  5354  
  5355      switch currArg {
  5356      case 0:
  5357        err = decoder.DecodeInt32(&result.Option)
  5358        if err != nil {
  5359          return types.ArchPrctlArgs{}, err
  5360        }
  5361      case 1:
  5362        err = decoder.DecodeUint64(&result.Addr)
  5363        if err != nil {
  5364          return types.ArchPrctlArgs{}, err
  5365        }
  5366      }
  5367    }
  5368    return result, nil
  5369  }
  5370  
  5371  func ParseAdjtimexArgs(decoder *Decoder) (types.AdjtimexArgs, error) {
  5372    var result types.AdjtimexArgs
  5373    var err error
  5374  
  5375    var numArgs uint8
  5376    err = decoder.DecodeUint8(&numArgs)
  5377    if err != nil {
  5378      return types.AdjtimexArgs{}, err
  5379    }
  5380  
  5381    for arg := 0; arg < int(numArgs); arg++ {
  5382      var currArg uint8
  5383      err = decoder.DecodeUint8(&currArg)
  5384      if err != nil {
  5385        return types.AdjtimexArgs{}, err
  5386      }
  5387  
  5388      switch currArg {
  5389      case 0:
  5390        var dataBuf uint64
  5391        err = decoder.DecodeUint64(&dataBuf)
  5392        if err != nil {
  5393          return types.AdjtimexArgs{}, err
  5394        }
  5395        result.Buf = uintptr(dataBuf)
  5396      }
  5397    }
  5398    return result, nil
  5399  }
  5400  
  5401  func ParseSetrlimitArgs(decoder *Decoder) (types.SetrlimitArgs, error) {
  5402    var result types.SetrlimitArgs
  5403    var err error
  5404  
  5405    var numArgs uint8
  5406    err = decoder.DecodeUint8(&numArgs)
  5407    if err != nil {
  5408      return types.SetrlimitArgs{}, err
  5409    }
  5410  
  5411    for arg := 0; arg < int(numArgs); arg++ {
  5412      var currArg uint8
  5413      err = decoder.DecodeUint8(&currArg)
  5414      if err != nil {
  5415        return types.SetrlimitArgs{}, err
  5416      }
  5417  
  5418      switch currArg {
  5419      case 0:
  5420        err = decoder.DecodeInt32(&result.Resource)
  5421        if err != nil {
  5422          return types.SetrlimitArgs{}, err
  5423        }
  5424      case 1:
  5425        var dataRlim uint64
  5426        err = decoder.DecodeUint64(&dataRlim)
  5427        if err != nil {
  5428          return types.SetrlimitArgs{}, err
  5429        }
  5430        result.Rlim = uintptr(dataRlim)
  5431      }
  5432    }
  5433    return result, nil
  5434  }
  5435  
  5436  func ParseChrootArgs(decoder *Decoder) (types.ChrootArgs, error) {
  5437    var result types.ChrootArgs
  5438    var err error
  5439  
  5440    var numArgs uint8
  5441    err = decoder.DecodeUint8(&numArgs)
  5442    if err != nil {
  5443      return types.ChrootArgs{}, err
  5444    }
  5445  
  5446    for arg := 0; arg < int(numArgs); arg++ {
  5447      var currArg uint8
  5448      err = decoder.DecodeUint8(&currArg)
  5449      if err != nil {
  5450        return types.ChrootArgs{}, err
  5451      }
  5452  
  5453      switch currArg {
  5454      case 0:
  5455        result.Path, err = decoder.ReadStringFromBuff()
  5456        if err != nil {
  5457          return types.ChrootArgs{}, err
  5458        }
  5459      }
  5460    }
  5461    return result, nil
  5462  }
  5463  
  5464  func ParseSyncArgs(decoder *Decoder) (types.SyncArgs, error) {
  5465    return types.SyncArgs{}, nil
  5466  }
  5467  
  5468  func ParseAcctArgs(decoder *Decoder) (types.AcctArgs, error) {
  5469    var result types.AcctArgs
  5470    var err error
  5471  
  5472    var numArgs uint8
  5473    err = decoder.DecodeUint8(&numArgs)
  5474    if err != nil {
  5475      return types.AcctArgs{}, err
  5476    }
  5477  
  5478    for arg := 0; arg < int(numArgs); arg++ {
  5479      var currArg uint8
  5480      err = decoder.DecodeUint8(&currArg)
  5481      if err != nil {
  5482        return types.AcctArgs{}, err
  5483      }
  5484  
  5485      switch currArg {
  5486      case 0:
  5487        result.Filename, err = decoder.ReadStringFromBuff()
  5488        if err != nil {
  5489          return types.AcctArgs{}, err
  5490        }
  5491      }
  5492    }
  5493    return result, nil
  5494  }
  5495  
  5496  func ParseSettimeofdayArgs(decoder *Decoder) (types.SettimeofdayArgs, error) {
  5497    var result types.SettimeofdayArgs
  5498    var err error
  5499  
  5500    var numArgs uint8
  5501    err = decoder.DecodeUint8(&numArgs)
  5502    if err != nil {
  5503      return types.SettimeofdayArgs{}, err
  5504    }
  5505  
  5506    for arg := 0; arg < int(numArgs); arg++ {
  5507      var currArg uint8
  5508      err = decoder.DecodeUint8(&currArg)
  5509      if err != nil {
  5510        return types.SettimeofdayArgs{}, err
  5511      }
  5512  
  5513      switch currArg {
  5514      case 0:
  5515        var dataTv uint64
  5516        err = decoder.DecodeUint64(&dataTv)
  5517        if err != nil {
  5518          return types.SettimeofdayArgs{}, err
  5519        }
  5520        result.Tv = uintptr(dataTv)
  5521      case 1:
  5522        var dataTz uint64
  5523        err = decoder.DecodeUint64(&dataTz)
  5524        if err != nil {
  5525          return types.SettimeofdayArgs{}, err
  5526        }
  5527        result.Tz = uintptr(dataTz)
  5528      }
  5529    }
  5530    return result, nil
  5531  }
  5532  
  5533  func ParseMountArgs(decoder *Decoder) (types.MountArgs, error) {
  5534    var result types.MountArgs
  5535    var err error
  5536  
  5537    var numArgs uint8
  5538    err = decoder.DecodeUint8(&numArgs)
  5539    if err != nil {
  5540      return types.MountArgs{}, err
  5541    }
  5542  
  5543    for arg := 0; arg < int(numArgs); arg++ {
  5544      var currArg uint8
  5545      err = decoder.DecodeUint8(&currArg)
  5546      if err != nil {
  5547        return types.MountArgs{}, err
  5548      }
  5549  
  5550      switch currArg {
  5551      case 0:
  5552        result.Source, err = decoder.ReadStringFromBuff()
  5553        if err != nil {
  5554          return types.MountArgs{}, err
  5555        }
  5556      case 1:
  5557        result.Target, err = decoder.ReadStringFromBuff()
  5558        if err != nil {
  5559          return types.MountArgs{}, err
  5560        }
  5561      case 2:
  5562        result.Filesystemtype, err = decoder.ReadStringFromBuff()
  5563        if err != nil {
  5564          return types.MountArgs{}, err
  5565        }
  5566      case 3:
  5567        err = decoder.DecodeUint64(&result.Mountflags)
  5568        if err != nil {
  5569          return types.MountArgs{}, err
  5570        }
  5571      case 4:
  5572        var dataData uint64
  5573        err = decoder.DecodeUint64(&dataData)
  5574        if err != nil {
  5575          return types.MountArgs{}, err
  5576        }
  5577        result.Data = uintptr(dataData)
  5578      }
  5579    }
  5580    return result, nil
  5581  }
  5582  
  5583  func ParseUmount2Args(decoder *Decoder) (types.Umount2Args, error) {
  5584    var result types.Umount2Args
  5585    var err error
  5586  
  5587    var numArgs uint8
  5588    err = decoder.DecodeUint8(&numArgs)
  5589    if err != nil {
  5590      return types.Umount2Args{}, err
  5591    }
  5592  
  5593    for arg := 0; arg < int(numArgs); arg++ {
  5594      var currArg uint8
  5595      err = decoder.DecodeUint8(&currArg)
  5596      if err != nil {
  5597        return types.Umount2Args{}, err
  5598      }
  5599  
  5600      switch currArg {
  5601      case 0:
  5602        result.Target, err = decoder.ReadStringFromBuff()
  5603        if err != nil {
  5604          return types.Umount2Args{}, err
  5605        }
  5606      case 1:
  5607        err = decoder.DecodeInt32(&result.Flags)
  5608        if err != nil {
  5609          return types.Umount2Args{}, err
  5610        }
  5611      }
  5612    }
  5613    return result, nil
  5614  }
  5615  
  5616  func ParseSwaponArgs(decoder *Decoder) (types.SwaponArgs, error) {
  5617    var result types.SwaponArgs
  5618    var err error
  5619  
  5620    var numArgs uint8
  5621    err = decoder.DecodeUint8(&numArgs)
  5622    if err != nil {
  5623      return types.SwaponArgs{}, err
  5624    }
  5625  
  5626    for arg := 0; arg < int(numArgs); arg++ {
  5627      var currArg uint8
  5628      err = decoder.DecodeUint8(&currArg)
  5629      if err != nil {
  5630        return types.SwaponArgs{}, err
  5631      }
  5632  
  5633      switch currArg {
  5634      case 0:
  5635        result.Path, err = decoder.ReadStringFromBuff()
  5636        if err != nil {
  5637          return types.SwaponArgs{}, err
  5638        }
  5639      case 1:
  5640        err = decoder.DecodeInt32(&result.Swapflags)
  5641        if err != nil {
  5642          return types.SwaponArgs{}, err
  5643        }
  5644      }
  5645    }
  5646    return result, nil
  5647  }
  5648  
  5649  func ParseSwapoffArgs(decoder *Decoder) (types.SwapoffArgs, error) {
  5650    var result types.SwapoffArgs
  5651    var err error
  5652  
  5653    var numArgs uint8
  5654    err = decoder.DecodeUint8(&numArgs)
  5655    if err != nil {
  5656      return types.SwapoffArgs{}, err
  5657    }
  5658  
  5659    for arg := 0; arg < int(numArgs); arg++ {
  5660      var currArg uint8
  5661      err = decoder.DecodeUint8(&currArg)
  5662      if err != nil {
  5663        return types.SwapoffArgs{}, err
  5664      }
  5665  
  5666      switch currArg {
  5667      case 0:
  5668        result.Path, err = decoder.ReadStringFromBuff()
  5669        if err != nil {
  5670          return types.SwapoffArgs{}, err
  5671        }
  5672      }
  5673    }
  5674    return result, nil
  5675  }
  5676  
  5677  func ParseRebootArgs(decoder *Decoder) (types.RebootArgs, error) {
  5678    var result types.RebootArgs
  5679    var err error
  5680  
  5681    var numArgs uint8
  5682    err = decoder.DecodeUint8(&numArgs)
  5683    if err != nil {
  5684      return types.RebootArgs{}, err
  5685    }
  5686  
  5687    for arg := 0; arg < int(numArgs); arg++ {
  5688      var currArg uint8
  5689      err = decoder.DecodeUint8(&currArg)
  5690      if err != nil {
  5691        return types.RebootArgs{}, err
  5692      }
  5693  
  5694      switch currArg {
  5695      case 0:
  5696        err = decoder.DecodeInt32(&result.Magic)
  5697        if err != nil {
  5698          return types.RebootArgs{}, err
  5699        }
  5700      case 1:
  5701        err = decoder.DecodeInt32(&result.Magic2)
  5702        if err != nil {
  5703          return types.RebootArgs{}, err
  5704        }
  5705      case 2:
  5706        err = decoder.DecodeInt32(&result.Cmd)
  5707        if err != nil {
  5708          return types.RebootArgs{}, err
  5709        }
  5710      case 3:
  5711        var dataArg uint64
  5712        err = decoder.DecodeUint64(&dataArg)
  5713        if err != nil {
  5714          return types.RebootArgs{}, err
  5715        }
  5716        result.Arg = uintptr(dataArg)
  5717      }
  5718    }
  5719    return result, nil
  5720  }
  5721  
  5722  func ParseSethostnameArgs(decoder *Decoder) (types.SethostnameArgs, error) {
  5723    var result types.SethostnameArgs
  5724    var err error
  5725  
  5726    var numArgs uint8
  5727    err = decoder.DecodeUint8(&numArgs)
  5728    if err != nil {
  5729      return types.SethostnameArgs{}, err
  5730    }
  5731  
  5732    for arg := 0; arg < int(numArgs); arg++ {
  5733      var currArg uint8
  5734      err = decoder.DecodeUint8(&currArg)
  5735      if err != nil {
  5736        return types.SethostnameArgs{}, err
  5737      }
  5738  
  5739      switch currArg {
  5740      case 0:
  5741        result.Name, err = decoder.ReadStringFromBuff()
  5742        if err != nil {
  5743          return types.SethostnameArgs{}, err
  5744        }
  5745      case 1:
  5746        err = decoder.DecodeUint64(&result.Len)
  5747        if err != nil {
  5748          return types.SethostnameArgs{}, err
  5749        }
  5750      }
  5751    }
  5752    return result, nil
  5753  }
  5754  
  5755  func ParseSetdomainnameArgs(decoder *Decoder) (types.SetdomainnameArgs, error) {
  5756    var result types.SetdomainnameArgs
  5757    var err error
  5758  
  5759    var numArgs uint8
  5760    err = decoder.DecodeUint8(&numArgs)
  5761    if err != nil {
  5762      return types.SetdomainnameArgs{}, err
  5763    }
  5764  
  5765    for arg := 0; arg < int(numArgs); arg++ {
  5766      var currArg uint8
  5767      err = decoder.DecodeUint8(&currArg)
  5768      if err != nil {
  5769        return types.SetdomainnameArgs{}, err
  5770      }
  5771  
  5772      switch currArg {
  5773      case 0:
  5774        result.Name, err = decoder.ReadStringFromBuff()
  5775        if err != nil {
  5776          return types.SetdomainnameArgs{}, err
  5777        }
  5778      case 1:
  5779        err = decoder.DecodeUint64(&result.Len)
  5780        if err != nil {
  5781          return types.SetdomainnameArgs{}, err
  5782        }
  5783      }
  5784    }
  5785    return result, nil
  5786  }
  5787  
  5788  func ParseIoplArgs(decoder *Decoder) (types.IoplArgs, error) {
  5789    var result types.IoplArgs
  5790    var err error
  5791  
  5792    var numArgs uint8
  5793    err = decoder.DecodeUint8(&numArgs)
  5794    if err != nil {
  5795      return types.IoplArgs{}, err
  5796    }
  5797  
  5798    for arg := 0; arg < int(numArgs); arg++ {
  5799      var currArg uint8
  5800      err = decoder.DecodeUint8(&currArg)
  5801      if err != nil {
  5802        return types.IoplArgs{}, err
  5803      }
  5804  
  5805      switch currArg {
  5806      case 0:
  5807        err = decoder.DecodeInt32(&result.Level)
  5808        if err != nil {
  5809          return types.IoplArgs{}, err
  5810        }
  5811      }
  5812    }
  5813    return result, nil
  5814  }
  5815  
  5816  func ParseIopermArgs(decoder *Decoder) (types.IopermArgs, error) {
  5817    var result types.IopermArgs
  5818    var err error
  5819  
  5820    var numArgs uint8
  5821    err = decoder.DecodeUint8(&numArgs)
  5822    if err != nil {
  5823      return types.IopermArgs{}, err
  5824    }
  5825  
  5826    for arg := 0; arg < int(numArgs); arg++ {
  5827      var currArg uint8
  5828      err = decoder.DecodeUint8(&currArg)
  5829      if err != nil {
  5830        return types.IopermArgs{}, err
  5831      }
  5832  
  5833      switch currArg {
  5834      case 0:
  5835        err = decoder.DecodeUint64(&result.From)
  5836        if err != nil {
  5837          return types.IopermArgs{}, err
  5838        }
  5839      case 1:
  5840        err = decoder.DecodeUint64(&result.Num)
  5841        if err != nil {
  5842          return types.IopermArgs{}, err
  5843        }
  5844      case 2:
  5845        err = decoder.DecodeInt32(&result.TurnOn)
  5846        if err != nil {
  5847          return types.IopermArgs{}, err
  5848        }
  5849      }
  5850    }
  5851    return result, nil
  5852  }
  5853  
  5854  func ParseCreateModuleArgs(decoder *Decoder) (types.CreateModuleArgs, error) {
  5855    return types.CreateModuleArgs{}, nil
  5856  }
  5857  
  5858  func ParseInitModuleArgs(decoder *Decoder) (types.InitModuleArgs, error) {
  5859    var result types.InitModuleArgs
  5860    var err error
  5861  
  5862    var numArgs uint8
  5863    err = decoder.DecodeUint8(&numArgs)
  5864    if err != nil {
  5865      return types.InitModuleArgs{}, err
  5866    }
  5867  
  5868    for arg := 0; arg < int(numArgs); arg++ {
  5869      var currArg uint8
  5870      err = decoder.DecodeUint8(&currArg)
  5871      if err != nil {
  5872        return types.InitModuleArgs{}, err
  5873      }
  5874  
  5875      switch currArg {
  5876      case 0:
  5877        var dataModuleImage uint64
  5878        err = decoder.DecodeUint64(&dataModuleImage)
  5879        if err != nil {
  5880          return types.InitModuleArgs{}, err
  5881        }
  5882        result.ModuleImage = uintptr(dataModuleImage)
  5883      case 1:
  5884        err = decoder.DecodeUint64(&result.Len)
  5885        if err != nil {
  5886          return types.InitModuleArgs{}, err
  5887        }
  5888      case 2:
  5889        result.ParamValues, err = decoder.ReadStringFromBuff()
  5890        if err != nil {
  5891          return types.InitModuleArgs{}, err
  5892        }
  5893      }
  5894    }
  5895    return result, nil
  5896  }
  5897  
  5898  func ParseDeleteModuleArgs(decoder *Decoder) (types.DeleteModuleArgs, error) {
  5899    var result types.DeleteModuleArgs
  5900    var err error
  5901  
  5902    var numArgs uint8
  5903    err = decoder.DecodeUint8(&numArgs)
  5904    if err != nil {
  5905      return types.DeleteModuleArgs{}, err
  5906    }
  5907  
  5908    for arg := 0; arg < int(numArgs); arg++ {
  5909      var currArg uint8
  5910      err = decoder.DecodeUint8(&currArg)
  5911      if err != nil {
  5912        return types.DeleteModuleArgs{}, err
  5913      }
  5914  
  5915      switch currArg {
  5916      case 0:
  5917        result.Name, err = decoder.ReadStringFromBuff()
  5918        if err != nil {
  5919          return types.DeleteModuleArgs{}, err
  5920        }
  5921      case 1:
  5922        err = decoder.DecodeInt32(&result.Flags)
  5923        if err != nil {
  5924          return types.DeleteModuleArgs{}, err
  5925        }
  5926      }
  5927    }
  5928    return result, nil
  5929  }
  5930  
  5931  func ParseGetKernelSymsArgs(decoder *Decoder) (types.GetKernelSymsArgs, error) {
  5932    return types.GetKernelSymsArgs{}, nil
  5933  }
  5934  
  5935  func ParseQueryModuleArgs(decoder *Decoder) (types.QueryModuleArgs, error) {
  5936    return types.QueryModuleArgs{}, nil
  5937  }
  5938  
  5939  func ParseQuotactlArgs(decoder *Decoder) (types.QuotactlArgs, error) {
  5940    var result types.QuotactlArgs
  5941    var err error
  5942  
  5943    var numArgs uint8
  5944    err = decoder.DecodeUint8(&numArgs)
  5945    if err != nil {
  5946      return types.QuotactlArgs{}, err
  5947    }
  5948  
  5949    for arg := 0; arg < int(numArgs); arg++ {
  5950      var currArg uint8
  5951      err = decoder.DecodeUint8(&currArg)
  5952      if err != nil {
  5953        return types.QuotactlArgs{}, err
  5954      }
  5955  
  5956      switch currArg {
  5957      case 0:
  5958        err = decoder.DecodeInt32(&result.Cmd)
  5959        if err != nil {
  5960          return types.QuotactlArgs{}, err
  5961        }
  5962      case 1:
  5963        result.Special, err = decoder.ReadStringFromBuff()
  5964        if err != nil {
  5965          return types.QuotactlArgs{}, err
  5966        }
  5967      case 2:
  5968        err = decoder.DecodeInt32(&result.Id)
  5969        if err != nil {
  5970          return types.QuotactlArgs{}, err
  5971        }
  5972      case 3:
  5973        var dataAddr uint64
  5974        err = decoder.DecodeUint64(&dataAddr)
  5975        if err != nil {
  5976          return types.QuotactlArgs{}, err
  5977        }
  5978        result.Addr = uintptr(dataAddr)
  5979      }
  5980    }
  5981    return result, nil
  5982  }
  5983  
  5984  func ParseNfsservctlArgs(decoder *Decoder) (types.NfsservctlArgs, error) {
  5985    return types.NfsservctlArgs{}, nil
  5986  }
  5987  
  5988  func ParseGetpmsgArgs(decoder *Decoder) (types.GetpmsgArgs, error) {
  5989    return types.GetpmsgArgs{}, nil
  5990  }
  5991  
  5992  func ParsePutpmsgArgs(decoder *Decoder) (types.PutpmsgArgs, error) {
  5993    return types.PutpmsgArgs{}, nil
  5994  }
  5995  
  5996  func ParseAfsArgs(decoder *Decoder) (types.AfsArgs, error) {
  5997    return types.AfsArgs{}, nil
  5998  }
  5999  
  6000  func ParseTuxcallArgs(decoder *Decoder) (types.TuxcallArgs, error) {
  6001    return types.TuxcallArgs{}, nil
  6002  }
  6003  
  6004  func ParseSecurityArgs(decoder *Decoder) (types.SecurityArgs, error) {
  6005    return types.SecurityArgs{}, nil
  6006  }
  6007  
  6008  func ParseGettidArgs(decoder *Decoder) (types.GettidArgs, error) {
  6009    return types.GettidArgs{}, nil
  6010  }
  6011  
  6012  func ParseReadaheadArgs(decoder *Decoder) (types.ReadaheadArgs, error) {
  6013    var result types.ReadaheadArgs
  6014    var err error
  6015  
  6016    var numArgs uint8
  6017    err = decoder.DecodeUint8(&numArgs)
  6018    if err != nil {
  6019      return types.ReadaheadArgs{}, err
  6020    }
  6021  
  6022    for arg := 0; arg < int(numArgs); arg++ {
  6023      var currArg uint8
  6024      err = decoder.DecodeUint8(&currArg)
  6025      if err != nil {
  6026        return types.ReadaheadArgs{}, err
  6027      }
  6028  
  6029      switch currArg {
  6030      case 0:
  6031        err = decoder.DecodeInt32(&result.Fd)
  6032        if err != nil {
  6033          return types.ReadaheadArgs{}, err
  6034        }
  6035      case 1:
  6036        err = decoder.DecodeUint64(&result.Offset)
  6037        if err != nil {
  6038          return types.ReadaheadArgs{}, err
  6039        }
  6040      case 2:
  6041        err = decoder.DecodeUint64(&result.Count)
  6042        if err != nil {
  6043          return types.ReadaheadArgs{}, err
  6044        }
  6045      }
  6046    }
  6047    return result, nil
  6048  }
  6049  
  6050  func ParseSetxattrArgs(decoder *Decoder) (types.SetxattrArgs, error) {
  6051    var result types.SetxattrArgs
  6052    var err error
  6053  
  6054    var numArgs uint8
  6055    err = decoder.DecodeUint8(&numArgs)
  6056    if err != nil {
  6057      return types.SetxattrArgs{}, err
  6058    }
  6059  
  6060    for arg := 0; arg < int(numArgs); arg++ {
  6061      var currArg uint8
  6062      err = decoder.DecodeUint8(&currArg)
  6063      if err != nil {
  6064        return types.SetxattrArgs{}, err
  6065      }
  6066  
  6067      switch currArg {
  6068      case 0:
  6069        result.Path, err = decoder.ReadStringFromBuff()
  6070        if err != nil {
  6071          return types.SetxattrArgs{}, err
  6072        }
  6073      case 1:
  6074        result.Name, err = decoder.ReadStringFromBuff()
  6075        if err != nil {
  6076          return types.SetxattrArgs{}, err
  6077        }
  6078      case 2:
  6079        var dataValue uint64
  6080        err = decoder.DecodeUint64(&dataValue)
  6081        if err != nil {
  6082          return types.SetxattrArgs{}, err
  6083        }
  6084        result.Value = uintptr(dataValue)
  6085      case 3:
  6086        err = decoder.DecodeUint64(&result.Size)
  6087        if err != nil {
  6088          return types.SetxattrArgs{}, err
  6089        }
  6090      case 4:
  6091        err = decoder.DecodeInt32(&result.Flags)
  6092        if err != nil {
  6093          return types.SetxattrArgs{}, err
  6094        }
  6095      }
  6096    }
  6097    return result, nil
  6098  }
  6099  
  6100  func ParseLsetxattrArgs(decoder *Decoder) (types.LsetxattrArgs, error) {
  6101    var result types.LsetxattrArgs
  6102    var err error
  6103  
  6104    var numArgs uint8
  6105    err = decoder.DecodeUint8(&numArgs)
  6106    if err != nil {
  6107      return types.LsetxattrArgs{}, err
  6108    }
  6109  
  6110    for arg := 0; arg < int(numArgs); arg++ {
  6111      var currArg uint8
  6112      err = decoder.DecodeUint8(&currArg)
  6113      if err != nil {
  6114        return types.LsetxattrArgs{}, err
  6115      }
  6116  
  6117      switch currArg {
  6118      case 0:
  6119        result.Path, err = decoder.ReadStringFromBuff()
  6120        if err != nil {
  6121          return types.LsetxattrArgs{}, err
  6122        }
  6123      case 1:
  6124        result.Name, err = decoder.ReadStringFromBuff()
  6125        if err != nil {
  6126          return types.LsetxattrArgs{}, err
  6127        }
  6128      case 2:
  6129        var dataValue uint64
  6130        err = decoder.DecodeUint64(&dataValue)
  6131        if err != nil {
  6132          return types.LsetxattrArgs{}, err
  6133        }
  6134        result.Value = uintptr(dataValue)
  6135      case 3:
  6136        err = decoder.DecodeUint64(&result.Size)
  6137        if err != nil {
  6138          return types.LsetxattrArgs{}, err
  6139        }
  6140      case 4:
  6141        err = decoder.DecodeInt32(&result.Flags)
  6142        if err != nil {
  6143          return types.LsetxattrArgs{}, err
  6144        }
  6145      }
  6146    }
  6147    return result, nil
  6148  }
  6149  
  6150  func ParseFsetxattrArgs(decoder *Decoder) (types.FsetxattrArgs, error) {
  6151    var result types.FsetxattrArgs
  6152    var err error
  6153  
  6154    var numArgs uint8
  6155    err = decoder.DecodeUint8(&numArgs)
  6156    if err != nil {
  6157      return types.FsetxattrArgs{}, err
  6158    }
  6159  
  6160    for arg := 0; arg < int(numArgs); arg++ {
  6161      var currArg uint8
  6162      err = decoder.DecodeUint8(&currArg)
  6163      if err != nil {
  6164        return types.FsetxattrArgs{}, err
  6165      }
  6166  
  6167      switch currArg {
  6168      case 0:
  6169        err = decoder.DecodeInt32(&result.Fd)
  6170        if err != nil {
  6171          return types.FsetxattrArgs{}, err
  6172        }
  6173      case 1:
  6174        result.Name, err = decoder.ReadStringFromBuff()
  6175        if err != nil {
  6176          return types.FsetxattrArgs{}, err
  6177        }
  6178      case 2:
  6179        var dataValue uint64
  6180        err = decoder.DecodeUint64(&dataValue)
  6181        if err != nil {
  6182          return types.FsetxattrArgs{}, err
  6183        }
  6184        result.Value = uintptr(dataValue)
  6185      case 3:
  6186        err = decoder.DecodeUint64(&result.Size)
  6187        if err != nil {
  6188          return types.FsetxattrArgs{}, err
  6189        }
  6190      case 4:
  6191        err = decoder.DecodeInt32(&result.Flags)
  6192        if err != nil {
  6193          return types.FsetxattrArgs{}, err
  6194        }
  6195      }
  6196    }
  6197    return result, nil
  6198  }
  6199  
  6200  func ParseGetxattrArgs(decoder *Decoder) (types.GetxattrArgs, error) {
  6201    var result types.GetxattrArgs
  6202    var err error
  6203  
  6204    var numArgs uint8
  6205    err = decoder.DecodeUint8(&numArgs)
  6206    if err != nil {
  6207      return types.GetxattrArgs{}, err
  6208    }
  6209  
  6210    for arg := 0; arg < int(numArgs); arg++ {
  6211      var currArg uint8
  6212      err = decoder.DecodeUint8(&currArg)
  6213      if err != nil {
  6214        return types.GetxattrArgs{}, err
  6215      }
  6216  
  6217      switch currArg {
  6218      case 0:
  6219        result.Path, err = decoder.ReadStringFromBuff()
  6220        if err != nil {
  6221          return types.GetxattrArgs{}, err
  6222        }
  6223      case 1:
  6224        result.Name, err = decoder.ReadStringFromBuff()
  6225        if err != nil {
  6226          return types.GetxattrArgs{}, err
  6227        }
  6228      case 2:
  6229        var dataValue uint64
  6230        err = decoder.DecodeUint64(&dataValue)
  6231        if err != nil {
  6232          return types.GetxattrArgs{}, err
  6233        }
  6234        result.Value = uintptr(dataValue)
  6235      case 3:
  6236        err = decoder.DecodeUint64(&result.Size)
  6237        if err != nil {
  6238          return types.GetxattrArgs{}, err
  6239        }
  6240      }
  6241    }
  6242    return result, nil
  6243  }
  6244  
  6245  func ParseLgetxattrArgs(decoder *Decoder) (types.LgetxattrArgs, error) {
  6246    var result types.LgetxattrArgs
  6247    var err error
  6248  
  6249    var numArgs uint8
  6250    err = decoder.DecodeUint8(&numArgs)
  6251    if err != nil {
  6252      return types.LgetxattrArgs{}, err
  6253    }
  6254  
  6255    for arg := 0; arg < int(numArgs); arg++ {
  6256      var currArg uint8
  6257      err = decoder.DecodeUint8(&currArg)
  6258      if err != nil {
  6259        return types.LgetxattrArgs{}, err
  6260      }
  6261  
  6262      switch currArg {
  6263      case 0:
  6264        result.Path, err = decoder.ReadStringFromBuff()
  6265        if err != nil {
  6266          return types.LgetxattrArgs{}, err
  6267        }
  6268      case 1:
  6269        result.Name, err = decoder.ReadStringFromBuff()
  6270        if err != nil {
  6271          return types.LgetxattrArgs{}, err
  6272        }
  6273      case 2:
  6274        var dataValue uint64
  6275        err = decoder.DecodeUint64(&dataValue)
  6276        if err != nil {
  6277          return types.LgetxattrArgs{}, err
  6278        }
  6279        result.Value = uintptr(dataValue)
  6280      case 3:
  6281        err = decoder.DecodeUint64(&result.Size)
  6282        if err != nil {
  6283          return types.LgetxattrArgs{}, err
  6284        }
  6285      }
  6286    }
  6287    return result, nil
  6288  }
  6289  
  6290  func ParseFgetxattrArgs(decoder *Decoder) (types.FgetxattrArgs, error) {
  6291    var result types.FgetxattrArgs
  6292    var err error
  6293  
  6294    var numArgs uint8
  6295    err = decoder.DecodeUint8(&numArgs)
  6296    if err != nil {
  6297      return types.FgetxattrArgs{}, err
  6298    }
  6299  
  6300    for arg := 0; arg < int(numArgs); arg++ {
  6301      var currArg uint8
  6302      err = decoder.DecodeUint8(&currArg)
  6303      if err != nil {
  6304        return types.FgetxattrArgs{}, err
  6305      }
  6306  
  6307      switch currArg {
  6308      case 0:
  6309        err = decoder.DecodeInt32(&result.Fd)
  6310        if err != nil {
  6311          return types.FgetxattrArgs{}, err
  6312        }
  6313      case 1:
  6314        result.Name, err = decoder.ReadStringFromBuff()
  6315        if err != nil {
  6316          return types.FgetxattrArgs{}, err
  6317        }
  6318      case 2:
  6319        var dataValue uint64
  6320        err = decoder.DecodeUint64(&dataValue)
  6321        if err != nil {
  6322          return types.FgetxattrArgs{}, err
  6323        }
  6324        result.Value = uintptr(dataValue)
  6325      case 3:
  6326        err = decoder.DecodeUint64(&result.Size)
  6327        if err != nil {
  6328          return types.FgetxattrArgs{}, err
  6329        }
  6330      }
  6331    }
  6332    return result, nil
  6333  }
  6334  
  6335  func ParseListxattrArgs(decoder *Decoder) (types.ListxattrArgs, error) {
  6336    var result types.ListxattrArgs
  6337    var err error
  6338  
  6339    var numArgs uint8
  6340    err = decoder.DecodeUint8(&numArgs)
  6341    if err != nil {
  6342      return types.ListxattrArgs{}, err
  6343    }
  6344  
  6345    for arg := 0; arg < int(numArgs); arg++ {
  6346      var currArg uint8
  6347      err = decoder.DecodeUint8(&currArg)
  6348      if err != nil {
  6349        return types.ListxattrArgs{}, err
  6350      }
  6351  
  6352      switch currArg {
  6353      case 0:
  6354        result.Path, err = decoder.ReadStringFromBuff()
  6355        if err != nil {
  6356          return types.ListxattrArgs{}, err
  6357        }
  6358      case 1:
  6359        result.List, err = decoder.ReadStringFromBuff()
  6360        if err != nil {
  6361          return types.ListxattrArgs{}, err
  6362        }
  6363      case 2:
  6364        err = decoder.DecodeUint64(&result.Size)
  6365        if err != nil {
  6366          return types.ListxattrArgs{}, err
  6367        }
  6368      }
  6369    }
  6370    return result, nil
  6371  }
  6372  
  6373  func ParseLlistxattrArgs(decoder *Decoder) (types.LlistxattrArgs, error) {
  6374    var result types.LlistxattrArgs
  6375    var err error
  6376  
  6377    var numArgs uint8
  6378    err = decoder.DecodeUint8(&numArgs)
  6379    if err != nil {
  6380      return types.LlistxattrArgs{}, err
  6381    }
  6382  
  6383    for arg := 0; arg < int(numArgs); arg++ {
  6384      var currArg uint8
  6385      err = decoder.DecodeUint8(&currArg)
  6386      if err != nil {
  6387        return types.LlistxattrArgs{}, err
  6388      }
  6389  
  6390      switch currArg {
  6391      case 0:
  6392        result.Path, err = decoder.ReadStringFromBuff()
  6393        if err != nil {
  6394          return types.LlistxattrArgs{}, err
  6395        }
  6396      case 1:
  6397        result.List, err = decoder.ReadStringFromBuff()
  6398        if err != nil {
  6399          return types.LlistxattrArgs{}, err
  6400        }
  6401      case 2:
  6402        err = decoder.DecodeUint64(&result.Size)
  6403        if err != nil {
  6404          return types.LlistxattrArgs{}, err
  6405        }
  6406      }
  6407    }
  6408    return result, nil
  6409  }
  6410  
  6411  func ParseFlistxattrArgs(decoder *Decoder) (types.FlistxattrArgs, error) {
  6412    var result types.FlistxattrArgs
  6413    var err error
  6414  
  6415    var numArgs uint8
  6416    err = decoder.DecodeUint8(&numArgs)
  6417    if err != nil {
  6418      return types.FlistxattrArgs{}, err
  6419    }
  6420  
  6421    for arg := 0; arg < int(numArgs); arg++ {
  6422      var currArg uint8
  6423      err = decoder.DecodeUint8(&currArg)
  6424      if err != nil {
  6425        return types.FlistxattrArgs{}, err
  6426      }
  6427  
  6428      switch currArg {
  6429      case 0:
  6430        err = decoder.DecodeInt32(&result.Fd)
  6431        if err != nil {
  6432          return types.FlistxattrArgs{}, err
  6433        }
  6434      case 1:
  6435        result.List, err = decoder.ReadStringFromBuff()
  6436        if err != nil {
  6437          return types.FlistxattrArgs{}, err
  6438        }
  6439      case 2:
  6440        err = decoder.DecodeUint64(&result.Size)
  6441        if err != nil {
  6442          return types.FlistxattrArgs{}, err
  6443        }
  6444      }
  6445    }
  6446    return result, nil
  6447  }
  6448  
  6449  func ParseRemovexattrArgs(decoder *Decoder) (types.RemovexattrArgs, error) {
  6450    var result types.RemovexattrArgs
  6451    var err error
  6452  
  6453    var numArgs uint8
  6454    err = decoder.DecodeUint8(&numArgs)
  6455    if err != nil {
  6456      return types.RemovexattrArgs{}, err
  6457    }
  6458  
  6459    for arg := 0; arg < int(numArgs); arg++ {
  6460      var currArg uint8
  6461      err = decoder.DecodeUint8(&currArg)
  6462      if err != nil {
  6463        return types.RemovexattrArgs{}, err
  6464      }
  6465  
  6466      switch currArg {
  6467      case 0:
  6468        result.Path, err = decoder.ReadStringFromBuff()
  6469        if err != nil {
  6470          return types.RemovexattrArgs{}, err
  6471        }
  6472      case 1:
  6473        result.Name, err = decoder.ReadStringFromBuff()
  6474        if err != nil {
  6475          return types.RemovexattrArgs{}, err
  6476        }
  6477      }
  6478    }
  6479    return result, nil
  6480  }
  6481  
  6482  func ParseLremovexattrArgs(decoder *Decoder) (types.LremovexattrArgs, error) {
  6483    var result types.LremovexattrArgs
  6484    var err error
  6485  
  6486    var numArgs uint8
  6487    err = decoder.DecodeUint8(&numArgs)
  6488    if err != nil {
  6489      return types.LremovexattrArgs{}, err
  6490    }
  6491  
  6492    for arg := 0; arg < int(numArgs); arg++ {
  6493      var currArg uint8
  6494      err = decoder.DecodeUint8(&currArg)
  6495      if err != nil {
  6496        return types.LremovexattrArgs{}, err
  6497      }
  6498  
  6499      switch currArg {
  6500      case 0:
  6501        result.Path, err = decoder.ReadStringFromBuff()
  6502        if err != nil {
  6503          return types.LremovexattrArgs{}, err
  6504        }
  6505      case 1:
  6506        result.Name, err = decoder.ReadStringFromBuff()
  6507        if err != nil {
  6508          return types.LremovexattrArgs{}, err
  6509        }
  6510      }
  6511    }
  6512    return result, nil
  6513  }
  6514  
  6515  func ParseFremovexattrArgs(decoder *Decoder) (types.FremovexattrArgs, error) {
  6516    var result types.FremovexattrArgs
  6517    var err error
  6518  
  6519    var numArgs uint8
  6520    err = decoder.DecodeUint8(&numArgs)
  6521    if err != nil {
  6522      return types.FremovexattrArgs{}, err
  6523    }
  6524  
  6525    for arg := 0; arg < int(numArgs); arg++ {
  6526      var currArg uint8
  6527      err = decoder.DecodeUint8(&currArg)
  6528      if err != nil {
  6529        return types.FremovexattrArgs{}, err
  6530      }
  6531  
  6532      switch currArg {
  6533      case 0:
  6534        err = decoder.DecodeInt32(&result.Fd)
  6535        if err != nil {
  6536          return types.FremovexattrArgs{}, err
  6537        }
  6538      case 1:
  6539        result.Name, err = decoder.ReadStringFromBuff()
  6540        if err != nil {
  6541          return types.FremovexattrArgs{}, err
  6542        }
  6543      }
  6544    }
  6545    return result, nil
  6546  }
  6547  
  6548  func ParseTkillArgs(decoder *Decoder) (types.TkillArgs, error) {
  6549    var result types.TkillArgs
  6550    var err error
  6551  
  6552    var numArgs uint8
  6553    err = decoder.DecodeUint8(&numArgs)
  6554    if err != nil {
  6555      return types.TkillArgs{}, err
  6556    }
  6557  
  6558    for arg := 0; arg < int(numArgs); arg++ {
  6559      var currArg uint8
  6560      err = decoder.DecodeUint8(&currArg)
  6561      if err != nil {
  6562        return types.TkillArgs{}, err
  6563      }
  6564  
  6565      switch currArg {
  6566      case 0:
  6567        err = decoder.DecodeInt32(&result.Tid)
  6568        if err != nil {
  6569          return types.TkillArgs{}, err
  6570        }
  6571      case 1:
  6572        err = decoder.DecodeInt32(&result.Sig)
  6573        if err != nil {
  6574          return types.TkillArgs{}, err
  6575        }
  6576      }
  6577    }
  6578    return result, nil
  6579  }
  6580  
  6581  func ParseTimeArgs(decoder *Decoder) (types.TimeArgs, error) {
  6582    var result types.TimeArgs
  6583    var err error
  6584  
  6585    var numArgs uint8
  6586    err = decoder.DecodeUint8(&numArgs)
  6587    if err != nil {
  6588      return types.TimeArgs{}, err
  6589    }
  6590  
  6591    for arg := 0; arg < int(numArgs); arg++ {
  6592      var currArg uint8
  6593      err = decoder.DecodeUint8(&currArg)
  6594      if err != nil {
  6595        return types.TimeArgs{}, err
  6596      }
  6597  
  6598      switch currArg {
  6599      case 0:
  6600        var dataTloc uint64
  6601        err = decoder.DecodeUint64(&dataTloc)
  6602        if err != nil {
  6603          return types.TimeArgs{}, err
  6604        }
  6605        result.Tloc = uintptr(dataTloc)
  6606      }
  6607    }
  6608    return result, nil
  6609  }
  6610  
  6611  func ParseFutexArgs(decoder *Decoder) (types.FutexArgs, error) {
  6612    var result types.FutexArgs
  6613    var err error
  6614  
  6615    var numArgs uint8
  6616    err = decoder.DecodeUint8(&numArgs)
  6617    if err != nil {
  6618      return types.FutexArgs{}, err
  6619    }
  6620  
  6621    for arg := 0; arg < int(numArgs); arg++ {
  6622      var currArg uint8
  6623      err = decoder.DecodeUint8(&currArg)
  6624      if err != nil {
  6625        return types.FutexArgs{}, err
  6626      }
  6627  
  6628      switch currArg {
  6629      case 0:
  6630        var dataUaddr uint64
  6631        err = decoder.DecodeUint64(&dataUaddr)
  6632        if err != nil {
  6633          return types.FutexArgs{}, err
  6634        }
  6635        result.Uaddr = uintptr(dataUaddr)
  6636      case 1:
  6637        err = decoder.DecodeInt32(&result.FutexOp)
  6638        if err != nil {
  6639          return types.FutexArgs{}, err
  6640        }
  6641      case 2:
  6642        err = decoder.DecodeInt32(&result.Val)
  6643        if err != nil {
  6644          return types.FutexArgs{}, err
  6645        }
  6646      case 3:
  6647        result.Timeout, err = decoder.ReadTimespec()
  6648        if err != nil {
  6649          return types.FutexArgs{}, err
  6650        }
  6651      case 4:
  6652        var dataUaddr2 uint64
  6653        err = decoder.DecodeUint64(&dataUaddr2)
  6654        if err != nil {
  6655          return types.FutexArgs{}, err
  6656        }
  6657        result.Uaddr2 = uintptr(dataUaddr2)
  6658      case 5:
  6659        err = decoder.DecodeInt32(&result.Val3)
  6660        if err != nil {
  6661          return types.FutexArgs{}, err
  6662        }
  6663      }
  6664    }
  6665    return result, nil
  6666  }
  6667  
  6668  func ParseSchedSetaffinityArgs(decoder *Decoder) (types.SchedSetaffinityArgs, error) {
  6669    var result types.SchedSetaffinityArgs
  6670    var err error
  6671  
  6672    var numArgs uint8
  6673    err = decoder.DecodeUint8(&numArgs)
  6674    if err != nil {
  6675      return types.SchedSetaffinityArgs{}, err
  6676    }
  6677  
  6678    for arg := 0; arg < int(numArgs); arg++ {
  6679      var currArg uint8
  6680      err = decoder.DecodeUint8(&currArg)
  6681      if err != nil {
  6682        return types.SchedSetaffinityArgs{}, err
  6683      }
  6684  
  6685      switch currArg {
  6686      case 0:
  6687        err = decoder.DecodeInt32(&result.Pid)
  6688        if err != nil {
  6689          return types.SchedSetaffinityArgs{}, err
  6690        }
  6691      case 1:
  6692        err = decoder.DecodeUint64(&result.Cpusetsize)
  6693        if err != nil {
  6694          return types.SchedSetaffinityArgs{}, err
  6695        }
  6696      case 2:
  6697        var dataMask uint64
  6698        err = decoder.DecodeUint64(&dataMask)
  6699        if err != nil {
  6700          return types.SchedSetaffinityArgs{}, err
  6701        }
  6702        result.Mask = uintptr(dataMask)
  6703      }
  6704    }
  6705    return result, nil
  6706  }
  6707  
  6708  func ParseSchedGetaffinityArgs(decoder *Decoder) (types.SchedGetaffinityArgs, error) {
  6709    var result types.SchedGetaffinityArgs
  6710    var err error
  6711  
  6712    var numArgs uint8
  6713    err = decoder.DecodeUint8(&numArgs)
  6714    if err != nil {
  6715      return types.SchedGetaffinityArgs{}, err
  6716    }
  6717  
  6718    for arg := 0; arg < int(numArgs); arg++ {
  6719      var currArg uint8
  6720      err = decoder.DecodeUint8(&currArg)
  6721      if err != nil {
  6722        return types.SchedGetaffinityArgs{}, err
  6723      }
  6724  
  6725      switch currArg {
  6726      case 0:
  6727        err = decoder.DecodeInt32(&result.Pid)
  6728        if err != nil {
  6729          return types.SchedGetaffinityArgs{}, err
  6730        }
  6731      case 1:
  6732        err = decoder.DecodeUint64(&result.Cpusetsize)
  6733        if err != nil {
  6734          return types.SchedGetaffinityArgs{}, err
  6735        }
  6736      case 2:
  6737        var dataMask uint64
  6738        err = decoder.DecodeUint64(&dataMask)
  6739        if err != nil {
  6740          return types.SchedGetaffinityArgs{}, err
  6741        }
  6742        result.Mask = uintptr(dataMask)
  6743      }
  6744    }
  6745    return result, nil
  6746  }
  6747  
  6748  func ParseSetThreadAreaArgs(decoder *Decoder) (types.SetThreadAreaArgs, error) {
  6749    var result types.SetThreadAreaArgs
  6750    var err error
  6751  
  6752    var numArgs uint8
  6753    err = decoder.DecodeUint8(&numArgs)
  6754    if err != nil {
  6755      return types.SetThreadAreaArgs{}, err
  6756    }
  6757  
  6758    for arg := 0; arg < int(numArgs); arg++ {
  6759      var currArg uint8
  6760      err = decoder.DecodeUint8(&currArg)
  6761      if err != nil {
  6762        return types.SetThreadAreaArgs{}, err
  6763      }
  6764  
  6765      switch currArg {
  6766      case 0:
  6767        var dataUInfo uint64
  6768        err = decoder.DecodeUint64(&dataUInfo)
  6769        if err != nil {
  6770          return types.SetThreadAreaArgs{}, err
  6771        }
  6772        result.UInfo = uintptr(dataUInfo)
  6773      }
  6774    }
  6775    return result, nil
  6776  }
  6777  
  6778  func ParseIoSetupArgs(decoder *Decoder) (types.IoSetupArgs, error) {
  6779    var result types.IoSetupArgs
  6780    var err error
  6781  
  6782    var numArgs uint8
  6783    err = decoder.DecodeUint8(&numArgs)
  6784    if err != nil {
  6785      return types.IoSetupArgs{}, err
  6786    }
  6787  
  6788    for arg := 0; arg < int(numArgs); arg++ {
  6789      var currArg uint8
  6790      err = decoder.DecodeUint8(&currArg)
  6791      if err != nil {
  6792        return types.IoSetupArgs{}, err
  6793      }
  6794  
  6795      switch currArg {
  6796      case 0:
  6797        err = decoder.DecodeUint32(&result.NrEvents)
  6798        if err != nil {
  6799          return types.IoSetupArgs{}, err
  6800        }
  6801      case 1:
  6802        var dataCtxIdp uint64
  6803        err = decoder.DecodeUint64(&dataCtxIdp)
  6804        if err != nil {
  6805          return types.IoSetupArgs{}, err
  6806        }
  6807        result.CtxIdp = uintptr(dataCtxIdp)
  6808      }
  6809    }
  6810    return result, nil
  6811  }
  6812  
  6813  func ParseIoDestroyArgs(decoder *Decoder) (types.IoDestroyArgs, error) {
  6814    var result types.IoDestroyArgs
  6815    var err error
  6816  
  6817    var numArgs uint8
  6818    err = decoder.DecodeUint8(&numArgs)
  6819    if err != nil {
  6820      return types.IoDestroyArgs{}, err
  6821    }
  6822  
  6823    for arg := 0; arg < int(numArgs); arg++ {
  6824      var currArg uint8
  6825      err = decoder.DecodeUint8(&currArg)
  6826      if err != nil {
  6827        return types.IoDestroyArgs{}, err
  6828      }
  6829  
  6830      switch currArg {
  6831      case 0:
  6832        var dataCtxId uint64
  6833        err = decoder.DecodeUint64(&dataCtxId)
  6834        if err != nil {
  6835          return types.IoDestroyArgs{}, err
  6836        }
  6837        result.CtxId = uintptr(dataCtxId)
  6838      }
  6839    }
  6840    return result, nil
  6841  }
  6842  
  6843  func ParseIoGeteventsArgs(decoder *Decoder) (types.IoGeteventsArgs, error) {
  6844    var result types.IoGeteventsArgs
  6845    var err error
  6846  
  6847    var numArgs uint8
  6848    err = decoder.DecodeUint8(&numArgs)
  6849    if err != nil {
  6850      return types.IoGeteventsArgs{}, err
  6851    }
  6852  
  6853    for arg := 0; arg < int(numArgs); arg++ {
  6854      var currArg uint8
  6855      err = decoder.DecodeUint8(&currArg)
  6856      if err != nil {
  6857        return types.IoGeteventsArgs{}, err
  6858      }
  6859  
  6860      switch currArg {
  6861      case 0:
  6862        var dataCtxId uint64
  6863        err = decoder.DecodeUint64(&dataCtxId)
  6864        if err != nil {
  6865          return types.IoGeteventsArgs{}, err
  6866        }
  6867        result.CtxId = uintptr(dataCtxId)
  6868      case 1:
  6869        err = decoder.DecodeInt64(&result.MinNr)
  6870        if err != nil {
  6871          return types.IoGeteventsArgs{}, err
  6872        }
  6873      case 2:
  6874        err = decoder.DecodeInt64(&result.Nr)
  6875        if err != nil {
  6876          return types.IoGeteventsArgs{}, err
  6877        }
  6878      case 3:
  6879        var dataEvents uint64
  6880        err = decoder.DecodeUint64(&dataEvents)
  6881        if err != nil {
  6882          return types.IoGeteventsArgs{}, err
  6883        }
  6884        result.Events = uintptr(dataEvents)
  6885      case 4:
  6886        result.Timeout, err = decoder.ReadTimespec()
  6887        if err != nil {
  6888          return types.IoGeteventsArgs{}, err
  6889        }
  6890      }
  6891    }
  6892    return result, nil
  6893  }
  6894  
  6895  func ParseIoSubmitArgs(decoder *Decoder) (types.IoSubmitArgs, error) {
  6896    var result types.IoSubmitArgs
  6897    var err error
  6898  
  6899    var numArgs uint8
  6900    err = decoder.DecodeUint8(&numArgs)
  6901    if err != nil {
  6902      return types.IoSubmitArgs{}, err
  6903    }
  6904  
  6905    for arg := 0; arg < int(numArgs); arg++ {
  6906      var currArg uint8
  6907      err = decoder.DecodeUint8(&currArg)
  6908      if err != nil {
  6909        return types.IoSubmitArgs{}, err
  6910      }
  6911  
  6912      switch currArg {
  6913      case 0:
  6914        var dataCtxId uint64
  6915        err = decoder.DecodeUint64(&dataCtxId)
  6916        if err != nil {
  6917          return types.IoSubmitArgs{}, err
  6918        }
  6919        result.CtxId = uintptr(dataCtxId)
  6920      case 1:
  6921        err = decoder.DecodeInt64(&result.Nr)
  6922        if err != nil {
  6923          return types.IoSubmitArgs{}, err
  6924        }
  6925      case 2:
  6926        var dataIocbpp uint64
  6927        err = decoder.DecodeUint64(&dataIocbpp)
  6928        if err != nil {
  6929          return types.IoSubmitArgs{}, err
  6930        }
  6931        result.Iocbpp = uintptr(dataIocbpp)
  6932      }
  6933    }
  6934    return result, nil
  6935  }
  6936  
  6937  func ParseIoCancelArgs(decoder *Decoder) (types.IoCancelArgs, error) {
  6938    var result types.IoCancelArgs
  6939    var err error
  6940  
  6941    var numArgs uint8
  6942    err = decoder.DecodeUint8(&numArgs)
  6943    if err != nil {
  6944      return types.IoCancelArgs{}, err
  6945    }
  6946  
  6947    for arg := 0; arg < int(numArgs); arg++ {
  6948      var currArg uint8
  6949      err = decoder.DecodeUint8(&currArg)
  6950      if err != nil {
  6951        return types.IoCancelArgs{}, err
  6952      }
  6953  
  6954      switch currArg {
  6955      case 0:
  6956        var dataCtxId uint64
  6957        err = decoder.DecodeUint64(&dataCtxId)
  6958        if err != nil {
  6959          return types.IoCancelArgs{}, err
  6960        }
  6961        result.CtxId = uintptr(dataCtxId)
  6962      case 1:
  6963        var dataIocb uint64
  6964        err = decoder.DecodeUint64(&dataIocb)
  6965        if err != nil {
  6966          return types.IoCancelArgs{}, err
  6967        }
  6968        result.Iocb = uintptr(dataIocb)
  6969      case 2:
  6970        var dataResult uint64
  6971        err = decoder.DecodeUint64(&dataResult)
  6972        if err != nil {
  6973          return types.IoCancelArgs{}, err
  6974        }
  6975        result.Result = uintptr(dataResult)
  6976      }
  6977    }
  6978    return result, nil
  6979  }
  6980  
  6981  func ParseGetThreadAreaArgs(decoder *Decoder) (types.GetThreadAreaArgs, error) {
  6982    var result types.GetThreadAreaArgs
  6983    var err error
  6984  
  6985    var numArgs uint8
  6986    err = decoder.DecodeUint8(&numArgs)
  6987    if err != nil {
  6988      return types.GetThreadAreaArgs{}, err
  6989    }
  6990  
  6991    for arg := 0; arg < int(numArgs); arg++ {
  6992      var currArg uint8
  6993      err = decoder.DecodeUint8(&currArg)
  6994      if err != nil {
  6995        return types.GetThreadAreaArgs{}, err
  6996      }
  6997  
  6998      switch currArg {
  6999      case 0:
  7000        var dataUInfo uint64
  7001        err = decoder.DecodeUint64(&dataUInfo)
  7002        if err != nil {
  7003          return types.GetThreadAreaArgs{}, err
  7004        }
  7005        result.UInfo = uintptr(dataUInfo)
  7006      }
  7007    }
  7008    return result, nil
  7009  }
  7010  
  7011  func ParseLookupDcookieArgs(decoder *Decoder) (types.LookupDcookieArgs, error) {
  7012    var result types.LookupDcookieArgs
  7013    var err error
  7014  
  7015    var numArgs uint8
  7016    err = decoder.DecodeUint8(&numArgs)
  7017    if err != nil {
  7018      return types.LookupDcookieArgs{}, err
  7019    }
  7020  
  7021    for arg := 0; arg < int(numArgs); arg++ {
  7022      var currArg uint8
  7023      err = decoder.DecodeUint8(&currArg)
  7024      if err != nil {
  7025        return types.LookupDcookieArgs{}, err
  7026      }
  7027  
  7028      switch currArg {
  7029      case 0:
  7030        err = decoder.DecodeUint64(&result.Cookie)
  7031        if err != nil {
  7032          return types.LookupDcookieArgs{}, err
  7033        }
  7034      case 1:
  7035        result.Buffer, err = decoder.ReadStringFromBuff()
  7036        if err != nil {
  7037          return types.LookupDcookieArgs{}, err
  7038        }
  7039      case 2:
  7040        err = decoder.DecodeUint64(&result.Len)
  7041        if err != nil {
  7042          return types.LookupDcookieArgs{}, err
  7043        }
  7044      }
  7045    }
  7046    return result, nil
  7047  }
  7048  
  7049  func ParseEpollCreateArgs(decoder *Decoder) (types.EpollCreateArgs, error) {
  7050    var result types.EpollCreateArgs
  7051    var err error
  7052  
  7053    var numArgs uint8
  7054    err = decoder.DecodeUint8(&numArgs)
  7055    if err != nil {
  7056      return types.EpollCreateArgs{}, err
  7057    }
  7058  
  7059    for arg := 0; arg < int(numArgs); arg++ {
  7060      var currArg uint8
  7061      err = decoder.DecodeUint8(&currArg)
  7062      if err != nil {
  7063        return types.EpollCreateArgs{}, err
  7064      }
  7065  
  7066      switch currArg {
  7067      case 0:
  7068        err = decoder.DecodeInt32(&result.Size)
  7069        if err != nil {
  7070          return types.EpollCreateArgs{}, err
  7071        }
  7072      }
  7073    }
  7074    return result, nil
  7075  }
  7076  
  7077  func ParseEpollCtlOldArgs(decoder *Decoder) (types.EpollCtlOldArgs, error) {
  7078    return types.EpollCtlOldArgs{}, nil
  7079  }
  7080  
  7081  func ParseEpollWaitOldArgs(decoder *Decoder) (types.EpollWaitOldArgs, error) {
  7082    return types.EpollWaitOldArgs{}, nil
  7083  }
  7084  
  7085  func ParseRemapFilePagesArgs(decoder *Decoder) (types.RemapFilePagesArgs, error) {
  7086    var result types.RemapFilePagesArgs
  7087    var err error
  7088  
  7089    var numArgs uint8
  7090    err = decoder.DecodeUint8(&numArgs)
  7091    if err != nil {
  7092      return types.RemapFilePagesArgs{}, err
  7093    }
  7094  
  7095    for arg := 0; arg < int(numArgs); arg++ {
  7096      var currArg uint8
  7097      err = decoder.DecodeUint8(&currArg)
  7098      if err != nil {
  7099        return types.RemapFilePagesArgs{}, err
  7100      }
  7101  
  7102      switch currArg {
  7103      case 0:
  7104        var dataAddr uint64
  7105        err = decoder.DecodeUint64(&dataAddr)
  7106        if err != nil {
  7107          return types.RemapFilePagesArgs{}, err
  7108        }
  7109        result.Addr = uintptr(dataAddr)
  7110      case 1:
  7111        err = decoder.DecodeUint64(&result.Size)
  7112        if err != nil {
  7113          return types.RemapFilePagesArgs{}, err
  7114        }
  7115      case 2:
  7116        err = decoder.DecodeInt32(&result.Prot)
  7117        if err != nil {
  7118          return types.RemapFilePagesArgs{}, err
  7119        }
  7120      case 3:
  7121        err = decoder.DecodeUint64(&result.Pgoff)
  7122        if err != nil {
  7123          return types.RemapFilePagesArgs{}, err
  7124        }
  7125      case 4:
  7126        err = decoder.DecodeInt32(&result.Flags)
  7127        if err != nil {
  7128          return types.RemapFilePagesArgs{}, err
  7129        }
  7130      }
  7131    }
  7132    return result, nil
  7133  }
  7134  
  7135  func ParseGetdents64Args(decoder *Decoder) (types.Getdents64Args, error) {
  7136    var result types.Getdents64Args
  7137    var err error
  7138  
  7139    var numArgs uint8
  7140    err = decoder.DecodeUint8(&numArgs)
  7141    if err != nil {
  7142      return types.Getdents64Args{}, err
  7143    }
  7144  
  7145    for arg := 0; arg < int(numArgs); arg++ {
  7146      var currArg uint8
  7147      err = decoder.DecodeUint8(&currArg)
  7148      if err != nil {
  7149        return types.Getdents64Args{}, err
  7150      }
  7151  
  7152      switch currArg {
  7153      case 0:
  7154        err = decoder.DecodeUint32(&result.Fd)
  7155        if err != nil {
  7156          return types.Getdents64Args{}, err
  7157        }
  7158      case 1:
  7159        var dataDirp uint64
  7160        err = decoder.DecodeUint64(&dataDirp)
  7161        if err != nil {
  7162          return types.Getdents64Args{}, err
  7163        }
  7164        result.Dirp = uintptr(dataDirp)
  7165      case 2:
  7166        err = decoder.DecodeUint32(&result.Count)
  7167        if err != nil {
  7168          return types.Getdents64Args{}, err
  7169        }
  7170      }
  7171    }
  7172    return result, nil
  7173  }
  7174  
  7175  func ParseSetTidAddressArgs(decoder *Decoder) (types.SetTidAddressArgs, error) {
  7176    var result types.SetTidAddressArgs
  7177    var err error
  7178  
  7179    var numArgs uint8
  7180    err = decoder.DecodeUint8(&numArgs)
  7181    if err != nil {
  7182      return types.SetTidAddressArgs{}, err
  7183    }
  7184  
  7185    for arg := 0; arg < int(numArgs); arg++ {
  7186      var currArg uint8
  7187      err = decoder.DecodeUint8(&currArg)
  7188      if err != nil {
  7189        return types.SetTidAddressArgs{}, err
  7190      }
  7191  
  7192      switch currArg {
  7193      case 0:
  7194        var dataTidptr uint64
  7195        err = decoder.DecodeUint64(&dataTidptr)
  7196        if err != nil {
  7197          return types.SetTidAddressArgs{}, err
  7198        }
  7199        result.Tidptr = uintptr(dataTidptr)
  7200      }
  7201    }
  7202    return result, nil
  7203  }
  7204  
  7205  func ParseRestartSyscallArgs(decoder *Decoder) (types.RestartSyscallArgs, error) {
  7206    return types.RestartSyscallArgs{}, nil
  7207  }
  7208  
  7209  func ParseSemtimedopArgs(decoder *Decoder) (types.SemtimedopArgs, error) {
  7210    var result types.SemtimedopArgs
  7211    var err error
  7212  
  7213    var numArgs uint8
  7214    err = decoder.DecodeUint8(&numArgs)
  7215    if err != nil {
  7216      return types.SemtimedopArgs{}, err
  7217    }
  7218  
  7219    for arg := 0; arg < int(numArgs); arg++ {
  7220      var currArg uint8
  7221      err = decoder.DecodeUint8(&currArg)
  7222      if err != nil {
  7223        return types.SemtimedopArgs{}, err
  7224      }
  7225  
  7226      switch currArg {
  7227      case 0:
  7228        err = decoder.DecodeInt32(&result.Semid)
  7229        if err != nil {
  7230          return types.SemtimedopArgs{}, err
  7231        }
  7232      case 1:
  7233        var dataSops uint64
  7234        err = decoder.DecodeUint64(&dataSops)
  7235        if err != nil {
  7236          return types.SemtimedopArgs{}, err
  7237        }
  7238        result.Sops = uintptr(dataSops)
  7239      case 2:
  7240        err = decoder.DecodeUint64(&result.Nsops)
  7241        if err != nil {
  7242          return types.SemtimedopArgs{}, err
  7243        }
  7244      case 3:
  7245        result.Timeout, err = decoder.ReadTimespec()
  7246        if err != nil {
  7247          return types.SemtimedopArgs{}, err
  7248        }
  7249      }
  7250    }
  7251    return result, nil
  7252  }
  7253  
  7254  func ParseFadvise64Args(decoder *Decoder) (types.Fadvise64Args, error) {
  7255    var result types.Fadvise64Args
  7256    var err error
  7257  
  7258    var numArgs uint8
  7259    err = decoder.DecodeUint8(&numArgs)
  7260    if err != nil {
  7261      return types.Fadvise64Args{}, err
  7262    }
  7263  
  7264    for arg := 0; arg < int(numArgs); arg++ {
  7265      var currArg uint8
  7266      err = decoder.DecodeUint8(&currArg)
  7267      if err != nil {
  7268        return types.Fadvise64Args{}, err
  7269      }
  7270  
  7271      switch currArg {
  7272      case 0:
  7273        err = decoder.DecodeInt32(&result.Fd)
  7274        if err != nil {
  7275          return types.Fadvise64Args{}, err
  7276        }
  7277      case 1:
  7278        err = decoder.DecodeUint64(&result.Offset)
  7279        if err != nil {
  7280          return types.Fadvise64Args{}, err
  7281        }
  7282      case 2:
  7283        err = decoder.DecodeUint64(&result.Len)
  7284        if err != nil {
  7285          return types.Fadvise64Args{}, err
  7286        }
  7287      case 3:
  7288        err = decoder.DecodeInt32(&result.Advice)
  7289        if err != nil {
  7290          return types.Fadvise64Args{}, err
  7291        }
  7292      }
  7293    }
  7294    return result, nil
  7295  }
  7296  
  7297  func ParseTimerCreateArgs(decoder *Decoder) (types.TimerCreateArgs, error) {
  7298    var result types.TimerCreateArgs
  7299    var err error
  7300  
  7301    var numArgs uint8
  7302    err = decoder.DecodeUint8(&numArgs)
  7303    if err != nil {
  7304      return types.TimerCreateArgs{}, err
  7305    }
  7306  
  7307    for arg := 0; arg < int(numArgs); arg++ {
  7308      var currArg uint8
  7309      err = decoder.DecodeUint8(&currArg)
  7310      if err != nil {
  7311        return types.TimerCreateArgs{}, err
  7312      }
  7313  
  7314      switch currArg {
  7315      case 0:
  7316        err = decoder.DecodeInt32(&result.Clockid)
  7317        if err != nil {
  7318          return types.TimerCreateArgs{}, err
  7319        }
  7320      case 1:
  7321        var dataSevp uint64
  7322        err = decoder.DecodeUint64(&dataSevp)
  7323        if err != nil {
  7324          return types.TimerCreateArgs{}, err
  7325        }
  7326        result.Sevp = uintptr(dataSevp)
  7327      case 2:
  7328        var dataTimerId uint64
  7329        err = decoder.DecodeUint64(&dataTimerId)
  7330        if err != nil {
  7331          return types.TimerCreateArgs{}, err
  7332        }
  7333        result.TimerId = uintptr(dataTimerId)
  7334      }
  7335    }
  7336    return result, nil
  7337  }
  7338  
  7339  func ParseTimerSettimeArgs(decoder *Decoder) (types.TimerSettimeArgs, error) {
  7340    var result types.TimerSettimeArgs
  7341    var err error
  7342  
  7343    var numArgs uint8
  7344    err = decoder.DecodeUint8(&numArgs)
  7345    if err != nil {
  7346      return types.TimerSettimeArgs{}, err
  7347    }
  7348  
  7349    for arg := 0; arg < int(numArgs); arg++ {
  7350      var currArg uint8
  7351      err = decoder.DecodeUint8(&currArg)
  7352      if err != nil {
  7353        return types.TimerSettimeArgs{}, err
  7354      }
  7355  
  7356      switch currArg {
  7357      case 0:
  7358        err = decoder.DecodeInt32(&result.TimerId)
  7359        if err != nil {
  7360          return types.TimerSettimeArgs{}, err
  7361        }
  7362      case 1:
  7363        err = decoder.DecodeInt32(&result.Flags)
  7364        if err != nil {
  7365          return types.TimerSettimeArgs{}, err
  7366        }
  7367      case 2:
  7368        var dataNewValue uint64
  7369        err = decoder.DecodeUint64(&dataNewValue)
  7370        if err != nil {
  7371          return types.TimerSettimeArgs{}, err
  7372        }
  7373        result.NewValue = uintptr(dataNewValue)
  7374      case 3:
  7375        var dataOldValue uint64
  7376        err = decoder.DecodeUint64(&dataOldValue)
  7377        if err != nil {
  7378          return types.TimerSettimeArgs{}, err
  7379        }
  7380        result.OldValue = uintptr(dataOldValue)
  7381      }
  7382    }
  7383    return result, nil
  7384  }
  7385  
  7386  func ParseTimerGettimeArgs(decoder *Decoder) (types.TimerGettimeArgs, error) {
  7387    var result types.TimerGettimeArgs
  7388    var err error
  7389  
  7390    var numArgs uint8
  7391    err = decoder.DecodeUint8(&numArgs)
  7392    if err != nil {
  7393      return types.TimerGettimeArgs{}, err
  7394    }
  7395  
  7396    for arg := 0; arg < int(numArgs); arg++ {
  7397      var currArg uint8
  7398      err = decoder.DecodeUint8(&currArg)
  7399      if err != nil {
  7400        return types.TimerGettimeArgs{}, err
  7401      }
  7402  
  7403      switch currArg {
  7404      case 0:
  7405        err = decoder.DecodeInt32(&result.TimerId)
  7406        if err != nil {
  7407          return types.TimerGettimeArgs{}, err
  7408        }
  7409      case 1:
  7410        var dataCurrValue uint64
  7411        err = decoder.DecodeUint64(&dataCurrValue)
  7412        if err != nil {
  7413          return types.TimerGettimeArgs{}, err
  7414        }
  7415        result.CurrValue = uintptr(dataCurrValue)
  7416      }
  7417    }
  7418    return result, nil
  7419  }
  7420  
  7421  func ParseTimerGetoverrunArgs(decoder *Decoder) (types.TimerGetoverrunArgs, error) {
  7422    var result types.TimerGetoverrunArgs
  7423    var err error
  7424  
  7425    var numArgs uint8
  7426    err = decoder.DecodeUint8(&numArgs)
  7427    if err != nil {
  7428      return types.TimerGetoverrunArgs{}, err
  7429    }
  7430  
  7431    for arg := 0; arg < int(numArgs); arg++ {
  7432      var currArg uint8
  7433      err = decoder.DecodeUint8(&currArg)
  7434      if err != nil {
  7435        return types.TimerGetoverrunArgs{}, err
  7436      }
  7437  
  7438      switch currArg {
  7439      case 0:
  7440        err = decoder.DecodeInt32(&result.TimerId)
  7441        if err != nil {
  7442          return types.TimerGetoverrunArgs{}, err
  7443        }
  7444      }
  7445    }
  7446    return result, nil
  7447  }
  7448  
  7449  func ParseTimerDeleteArgs(decoder *Decoder) (types.TimerDeleteArgs, error) {
  7450    var result types.TimerDeleteArgs
  7451    var err error
  7452  
  7453    var numArgs uint8
  7454    err = decoder.DecodeUint8(&numArgs)
  7455    if err != nil {
  7456      return types.TimerDeleteArgs{}, err
  7457    }
  7458  
  7459    for arg := 0; arg < int(numArgs); arg++ {
  7460      var currArg uint8
  7461      err = decoder.DecodeUint8(&currArg)
  7462      if err != nil {
  7463        return types.TimerDeleteArgs{}, err
  7464      }
  7465  
  7466      switch currArg {
  7467      case 0:
  7468        err = decoder.DecodeInt32(&result.TimerId)
  7469        if err != nil {
  7470          return types.TimerDeleteArgs{}, err
  7471        }
  7472      }
  7473    }
  7474    return result, nil
  7475  }
  7476  
  7477  func ParseClockSettimeArgs(decoder *Decoder) (types.ClockSettimeArgs, error) {
  7478    var result types.ClockSettimeArgs
  7479    var err error
  7480  
  7481    var numArgs uint8
  7482    err = decoder.DecodeUint8(&numArgs)
  7483    if err != nil {
  7484      return types.ClockSettimeArgs{}, err
  7485    }
  7486  
  7487    for arg := 0; arg < int(numArgs); arg++ {
  7488      var currArg uint8
  7489      err = decoder.DecodeUint8(&currArg)
  7490      if err != nil {
  7491        return types.ClockSettimeArgs{}, err
  7492      }
  7493  
  7494      switch currArg {
  7495      case 0:
  7496        err = decoder.DecodeInt32(&result.Clockid)
  7497        if err != nil {
  7498          return types.ClockSettimeArgs{}, err
  7499        }
  7500      case 1:
  7501        result.Tp, err = decoder.ReadTimespec()
  7502        if err != nil {
  7503          return types.ClockSettimeArgs{}, err
  7504        }
  7505      }
  7506    }
  7507    return result, nil
  7508  }
  7509  
  7510  func ParseClockGettimeArgs(decoder *Decoder) (types.ClockGettimeArgs, error) {
  7511    var result types.ClockGettimeArgs
  7512    var err error
  7513  
  7514    var numArgs uint8
  7515    err = decoder.DecodeUint8(&numArgs)
  7516    if err != nil {
  7517      return types.ClockGettimeArgs{}, err
  7518    }
  7519  
  7520    for arg := 0; arg < int(numArgs); arg++ {
  7521      var currArg uint8
  7522      err = decoder.DecodeUint8(&currArg)
  7523      if err != nil {
  7524        return types.ClockGettimeArgs{}, err
  7525      }
  7526  
  7527      switch currArg {
  7528      case 0:
  7529        err = decoder.DecodeInt32(&result.Clockid)
  7530        if err != nil {
  7531          return types.ClockGettimeArgs{}, err
  7532        }
  7533      case 1:
  7534        result.Tp, err = decoder.ReadTimespec()
  7535        if err != nil {
  7536          return types.ClockGettimeArgs{}, err
  7537        }
  7538      }
  7539    }
  7540    return result, nil
  7541  }
  7542  
  7543  func ParseClockGetresArgs(decoder *Decoder) (types.ClockGetresArgs, error) {
  7544    var result types.ClockGetresArgs
  7545    var err error
  7546  
  7547    var numArgs uint8
  7548    err = decoder.DecodeUint8(&numArgs)
  7549    if err != nil {
  7550      return types.ClockGetresArgs{}, err
  7551    }
  7552  
  7553    for arg := 0; arg < int(numArgs); arg++ {
  7554      var currArg uint8
  7555      err = decoder.DecodeUint8(&currArg)
  7556      if err != nil {
  7557        return types.ClockGetresArgs{}, err
  7558      }
  7559  
  7560      switch currArg {
  7561      case 0:
  7562        err = decoder.DecodeInt32(&result.Clockid)
  7563        if err != nil {
  7564          return types.ClockGetresArgs{}, err
  7565        }
  7566      case 1:
  7567        result.Res, err = decoder.ReadTimespec()
  7568        if err != nil {
  7569          return types.ClockGetresArgs{}, err
  7570        }
  7571      }
  7572    }
  7573    return result, nil
  7574  }
  7575  
  7576  func ParseClockNanosleepArgs(decoder *Decoder) (types.ClockNanosleepArgs, error) {
  7577    var result types.ClockNanosleepArgs
  7578    var err error
  7579  
  7580    var numArgs uint8
  7581    err = decoder.DecodeUint8(&numArgs)
  7582    if err != nil {
  7583      return types.ClockNanosleepArgs{}, err
  7584    }
  7585  
  7586    for arg := 0; arg < int(numArgs); arg++ {
  7587      var currArg uint8
  7588      err = decoder.DecodeUint8(&currArg)
  7589      if err != nil {
  7590        return types.ClockNanosleepArgs{}, err
  7591      }
  7592  
  7593      switch currArg {
  7594      case 0:
  7595        err = decoder.DecodeInt32(&result.Clockid)
  7596        if err != nil {
  7597          return types.ClockNanosleepArgs{}, err
  7598        }
  7599      case 1:
  7600        err = decoder.DecodeInt32(&result.Flags)
  7601        if err != nil {
  7602          return types.ClockNanosleepArgs{}, err
  7603        }
  7604      case 2:
  7605        result.Request, err = decoder.ReadTimespec()
  7606        if err != nil {
  7607          return types.ClockNanosleepArgs{}, err
  7608        }
  7609      case 3:
  7610        result.Remain, err = decoder.ReadTimespec()
  7611        if err != nil {
  7612          return types.ClockNanosleepArgs{}, err
  7613        }
  7614      }
  7615    }
  7616    return result, nil
  7617  }
  7618  
  7619  func ParseExitGroupArgs(decoder *Decoder) (types.ExitGroupArgs, error) {
  7620    var result types.ExitGroupArgs
  7621    var err error
  7622  
  7623    var numArgs uint8
  7624    err = decoder.DecodeUint8(&numArgs)
  7625    if err != nil {
  7626      return types.ExitGroupArgs{}, err
  7627    }
  7628  
  7629    for arg := 0; arg < int(numArgs); arg++ {
  7630      var currArg uint8
  7631      err = decoder.DecodeUint8(&currArg)
  7632      if err != nil {
  7633        return types.ExitGroupArgs{}, err
  7634      }
  7635  
  7636      switch currArg {
  7637      case 0:
  7638        err = decoder.DecodeInt32(&result.Status)
  7639        if err != nil {
  7640          return types.ExitGroupArgs{}, err
  7641        }
  7642      }
  7643    }
  7644    return result, nil
  7645  }
  7646  
  7647  func ParseEpollWaitArgs(decoder *Decoder) (types.EpollWaitArgs, error) {
  7648    var result types.EpollWaitArgs
  7649    var err error
  7650  
  7651    var numArgs uint8
  7652    err = decoder.DecodeUint8(&numArgs)
  7653    if err != nil {
  7654      return types.EpollWaitArgs{}, err
  7655    }
  7656  
  7657    for arg := 0; arg < int(numArgs); arg++ {
  7658      var currArg uint8
  7659      err = decoder.DecodeUint8(&currArg)
  7660      if err != nil {
  7661        return types.EpollWaitArgs{}, err
  7662      }
  7663  
  7664      switch currArg {
  7665      case 0:
  7666        err = decoder.DecodeInt32(&result.Epfd)
  7667        if err != nil {
  7668          return types.EpollWaitArgs{}, err
  7669        }
  7670      case 1:
  7671        var dataEvents uint64
  7672        err = decoder.DecodeUint64(&dataEvents)
  7673        if err != nil {
  7674          return types.EpollWaitArgs{}, err
  7675        }
  7676        result.Events = uintptr(dataEvents)
  7677      case 2:
  7678        err = decoder.DecodeInt32(&result.Maxevents)
  7679        if err != nil {
  7680          return types.EpollWaitArgs{}, err
  7681        }
  7682      case 3:
  7683        err = decoder.DecodeInt32(&result.Timeout)
  7684        if err != nil {
  7685          return types.EpollWaitArgs{}, err
  7686        }
  7687      }
  7688    }
  7689    return result, nil
  7690  }
  7691  
  7692  func ParseEpollCtlArgs(decoder *Decoder) (types.EpollCtlArgs, error) {
  7693    var result types.EpollCtlArgs
  7694    var err error
  7695  
  7696    var numArgs uint8
  7697    err = decoder.DecodeUint8(&numArgs)
  7698    if err != nil {
  7699      return types.EpollCtlArgs{}, err
  7700    }
  7701  
  7702    for arg := 0; arg < int(numArgs); arg++ {
  7703      var currArg uint8
  7704      err = decoder.DecodeUint8(&currArg)
  7705      if err != nil {
  7706        return types.EpollCtlArgs{}, err
  7707      }
  7708  
  7709      switch currArg {
  7710      case 0:
  7711        err = decoder.DecodeInt32(&result.Epfd)
  7712        if err != nil {
  7713          return types.EpollCtlArgs{}, err
  7714        }
  7715      case 1:
  7716        err = decoder.DecodeInt32(&result.Op)
  7717        if err != nil {
  7718          return types.EpollCtlArgs{}, err
  7719        }
  7720      case 2:
  7721        err = decoder.DecodeInt32(&result.Fd)
  7722        if err != nil {
  7723          return types.EpollCtlArgs{}, err
  7724        }
  7725      case 3:
  7726        var dataEvent uint64
  7727        err = decoder.DecodeUint64(&dataEvent)
  7728        if err != nil {
  7729          return types.EpollCtlArgs{}, err
  7730        }
  7731        result.Event = uintptr(dataEvent)
  7732      }
  7733    }
  7734    return result, nil
  7735  }
  7736  
  7737  func ParseTgkillArgs(decoder *Decoder) (types.TgkillArgs, error) {
  7738    var result types.TgkillArgs
  7739    var err error
  7740  
  7741    var numArgs uint8
  7742    err = decoder.DecodeUint8(&numArgs)
  7743    if err != nil {
  7744      return types.TgkillArgs{}, err
  7745    }
  7746  
  7747    for arg := 0; arg < int(numArgs); arg++ {
  7748      var currArg uint8
  7749      err = decoder.DecodeUint8(&currArg)
  7750      if err != nil {
  7751        return types.TgkillArgs{}, err
  7752      }
  7753  
  7754      switch currArg {
  7755      case 0:
  7756        err = decoder.DecodeInt32(&result.Tgid)
  7757        if err != nil {
  7758          return types.TgkillArgs{}, err
  7759        }
  7760      case 1:
  7761        err = decoder.DecodeInt32(&result.Tid)
  7762        if err != nil {
  7763          return types.TgkillArgs{}, err
  7764        }
  7765      case 2:
  7766        err = decoder.DecodeInt32(&result.Sig)
  7767        if err != nil {
  7768          return types.TgkillArgs{}, err
  7769        }
  7770      }
  7771    }
  7772    return result, nil
  7773  }
  7774  
  7775  func ParseUtimesArgs(decoder *Decoder) (types.UtimesArgs, error) {
  7776    var result types.UtimesArgs
  7777    var err error
  7778  
  7779    var numArgs uint8
  7780    err = decoder.DecodeUint8(&numArgs)
  7781    if err != nil {
  7782      return types.UtimesArgs{}, err
  7783    }
  7784  
  7785    for arg := 0; arg < int(numArgs); arg++ {
  7786      var currArg uint8
  7787      err = decoder.DecodeUint8(&currArg)
  7788      if err != nil {
  7789        return types.UtimesArgs{}, err
  7790      }
  7791  
  7792      switch currArg {
  7793      case 0:
  7794        result.Filename, err = decoder.ReadStringFromBuff()
  7795        if err != nil {
  7796          return types.UtimesArgs{}, err
  7797        }
  7798      case 1:
  7799        var dataTimes uint64
  7800        err = decoder.DecodeUint64(&dataTimes)
  7801        if err != nil {
  7802          return types.UtimesArgs{}, err
  7803        }
  7804        result.Times = uintptr(dataTimes)
  7805      }
  7806    }
  7807    return result, nil
  7808  }
  7809  
  7810  func ParseVserverArgs(decoder *Decoder) (types.VserverArgs, error) {
  7811    return types.VserverArgs{}, nil
  7812  }
  7813  
  7814  func ParseMbindArgs(decoder *Decoder) (types.MbindArgs, error) {
  7815    var result types.MbindArgs
  7816    var err error
  7817  
  7818    var numArgs uint8
  7819    err = decoder.DecodeUint8(&numArgs)
  7820    if err != nil {
  7821      return types.MbindArgs{}, err
  7822    }
  7823  
  7824    for arg := 0; arg < int(numArgs); arg++ {
  7825      var currArg uint8
  7826      err = decoder.DecodeUint8(&currArg)
  7827      if err != nil {
  7828        return types.MbindArgs{}, err
  7829      }
  7830  
  7831      switch currArg {
  7832      case 0:
  7833        var dataAddr uint64
  7834        err = decoder.DecodeUint64(&dataAddr)
  7835        if err != nil {
  7836          return types.MbindArgs{}, err
  7837        }
  7838        result.Addr = uintptr(dataAddr)
  7839      case 1:
  7840        err = decoder.DecodeUint64(&result.Len)
  7841        if err != nil {
  7842          return types.MbindArgs{}, err
  7843        }
  7844      case 2:
  7845        err = decoder.DecodeInt32(&result.Mode)
  7846        if err != nil {
  7847          return types.MbindArgs{}, err
  7848        }
  7849      case 3:
  7850        var dataNodemask uint64
  7851        err = decoder.DecodeUint64(&dataNodemask)
  7852        if err != nil {
  7853          return types.MbindArgs{}, err
  7854        }
  7855        result.Nodemask = uintptr(dataNodemask)
  7856      case 4:
  7857        err = decoder.DecodeUint64(&result.Maxnode)
  7858        if err != nil {
  7859          return types.MbindArgs{}, err
  7860        }
  7861      case 5:
  7862        err = decoder.DecodeUint32(&result.Flags)
  7863        if err != nil {
  7864          return types.MbindArgs{}, err
  7865        }
  7866      }
  7867    }
  7868    return result, nil
  7869  }
  7870  
  7871  func ParseSetMempolicyArgs(decoder *Decoder) (types.SetMempolicyArgs, error) {
  7872    var result types.SetMempolicyArgs
  7873    var err error
  7874  
  7875    var numArgs uint8
  7876    err = decoder.DecodeUint8(&numArgs)
  7877    if err != nil {
  7878      return types.SetMempolicyArgs{}, err
  7879    }
  7880  
  7881    for arg := 0; arg < int(numArgs); arg++ {
  7882      var currArg uint8
  7883      err = decoder.DecodeUint8(&currArg)
  7884      if err != nil {
  7885        return types.SetMempolicyArgs{}, err
  7886      }
  7887  
  7888      switch currArg {
  7889      case 0:
  7890        err = decoder.DecodeInt32(&result.Mode)
  7891        if err != nil {
  7892          return types.SetMempolicyArgs{}, err
  7893        }
  7894      case 1:
  7895        var dataNodemask uint64
  7896        err = decoder.DecodeUint64(&dataNodemask)
  7897        if err != nil {
  7898          return types.SetMempolicyArgs{}, err
  7899        }
  7900        result.Nodemask = uintptr(dataNodemask)
  7901      case 2:
  7902        err = decoder.DecodeUint64(&result.Maxnode)
  7903        if err != nil {
  7904          return types.SetMempolicyArgs{}, err
  7905        }
  7906      }
  7907    }
  7908    return result, nil
  7909  }
  7910  
  7911  func ParseGetMempolicyArgs(decoder *Decoder) (types.GetMempolicyArgs, error) {
  7912    var result types.GetMempolicyArgs
  7913    var err error
  7914  
  7915    var numArgs uint8
  7916    err = decoder.DecodeUint8(&numArgs)
  7917    if err != nil {
  7918      return types.GetMempolicyArgs{}, err
  7919    }
  7920  
  7921    for arg := 0; arg < int(numArgs); arg++ {
  7922      var currArg uint8
  7923      err = decoder.DecodeUint8(&currArg)
  7924      if err != nil {
  7925        return types.GetMempolicyArgs{}, err
  7926      }
  7927  
  7928      switch currArg {
  7929      case 0:
  7930        var dataMode uint64
  7931        err = decoder.DecodeUint64(&dataMode)
  7932        if err != nil {
  7933          return types.GetMempolicyArgs{}, err
  7934        }
  7935        result.Mode = uintptr(dataMode)
  7936      case 1:
  7937        var dataNodemask uint64
  7938        err = decoder.DecodeUint64(&dataNodemask)
  7939        if err != nil {
  7940          return types.GetMempolicyArgs{}, err
  7941        }
  7942        result.Nodemask = uintptr(dataNodemask)
  7943      case 2:
  7944        err = decoder.DecodeUint64(&result.Maxnode)
  7945        if err != nil {
  7946          return types.GetMempolicyArgs{}, err
  7947        }
  7948      case 3:
  7949        var dataAddr uint64
  7950        err = decoder.DecodeUint64(&dataAddr)
  7951        if err != nil {
  7952          return types.GetMempolicyArgs{}, err
  7953        }
  7954        result.Addr = uintptr(dataAddr)
  7955      case 4:
  7956        err = decoder.DecodeUint64(&result.Flags)
  7957        if err != nil {
  7958          return types.GetMempolicyArgs{}, err
  7959        }
  7960      }
  7961    }
  7962    return result, nil
  7963  }
  7964  
  7965  func ParseMqOpenArgs(decoder *Decoder) (types.MqOpenArgs, error) {
  7966    var result types.MqOpenArgs
  7967    var err error
  7968  
  7969    var numArgs uint8
  7970    err = decoder.DecodeUint8(&numArgs)
  7971    if err != nil {
  7972      return types.MqOpenArgs{}, err
  7973    }
  7974  
  7975    for arg := 0; arg < int(numArgs); arg++ {
  7976      var currArg uint8
  7977      err = decoder.DecodeUint8(&currArg)
  7978      if err != nil {
  7979        return types.MqOpenArgs{}, err
  7980      }
  7981  
  7982      switch currArg {
  7983      case 0:
  7984        result.Name, err = decoder.ReadStringFromBuff()
  7985        if err != nil {
  7986          return types.MqOpenArgs{}, err
  7987        }
  7988      case 1:
  7989        err = decoder.DecodeInt32(&result.Oflag)
  7990        if err != nil {
  7991          return types.MqOpenArgs{}, err
  7992        }
  7993      case 2:
  7994        err = decoder.DecodeUint32(&result.Mode)
  7995        if err != nil {
  7996          return types.MqOpenArgs{}, err
  7997        }
  7998      case 3:
  7999        var dataAttr uint64
  8000        err = decoder.DecodeUint64(&dataAttr)
  8001        if err != nil {
  8002          return types.MqOpenArgs{}, err
  8003        }
  8004        result.Attr = uintptr(dataAttr)
  8005      }
  8006    }
  8007    return result, nil
  8008  }
  8009  
  8010  func ParseMqUnlinkArgs(decoder *Decoder) (types.MqUnlinkArgs, error) {
  8011    var result types.MqUnlinkArgs
  8012    var err error
  8013  
  8014    var numArgs uint8
  8015    err = decoder.DecodeUint8(&numArgs)
  8016    if err != nil {
  8017      return types.MqUnlinkArgs{}, err
  8018    }
  8019  
  8020    for arg := 0; arg < int(numArgs); arg++ {
  8021      var currArg uint8
  8022      err = decoder.DecodeUint8(&currArg)
  8023      if err != nil {
  8024        return types.MqUnlinkArgs{}, err
  8025      }
  8026  
  8027      switch currArg {
  8028      case 0:
  8029        result.Name, err = decoder.ReadStringFromBuff()
  8030        if err != nil {
  8031          return types.MqUnlinkArgs{}, err
  8032        }
  8033      }
  8034    }
  8035    return result, nil
  8036  }
  8037  
  8038  func ParseMqTimedsendArgs(decoder *Decoder) (types.MqTimedsendArgs, error) {
  8039    var result types.MqTimedsendArgs
  8040    var err error
  8041  
  8042    var numArgs uint8
  8043    err = decoder.DecodeUint8(&numArgs)
  8044    if err != nil {
  8045      return types.MqTimedsendArgs{}, err
  8046    }
  8047  
  8048    for arg := 0; arg < int(numArgs); arg++ {
  8049      var currArg uint8
  8050      err = decoder.DecodeUint8(&currArg)
  8051      if err != nil {
  8052        return types.MqTimedsendArgs{}, err
  8053      }
  8054  
  8055      switch currArg {
  8056      case 0:
  8057        err = decoder.DecodeInt32(&result.Mqdes)
  8058        if err != nil {
  8059          return types.MqTimedsendArgs{}, err
  8060        }
  8061      case 1:
  8062        result.MsgPtr, err = decoder.ReadStringFromBuff()
  8063        if err != nil {
  8064          return types.MqTimedsendArgs{}, err
  8065        }
  8066      case 2:
  8067        err = decoder.DecodeUint64(&result.MsgLen)
  8068        if err != nil {
  8069          return types.MqTimedsendArgs{}, err
  8070        }
  8071      case 3:
  8072        err = decoder.DecodeUint32(&result.MsgPrio)
  8073        if err != nil {
  8074          return types.MqTimedsendArgs{}, err
  8075        }
  8076      case 4:
  8077        result.AbsTimeout, err = decoder.ReadTimespec()
  8078        if err != nil {
  8079          return types.MqTimedsendArgs{}, err
  8080        }
  8081      }
  8082    }
  8083    return result, nil
  8084  }
  8085  
  8086  func ParseMqTimedreceiveArgs(decoder *Decoder) (types.MqTimedreceiveArgs, error) {
  8087    var result types.MqTimedreceiveArgs
  8088    var err error
  8089  
  8090    var numArgs uint8
  8091    err = decoder.DecodeUint8(&numArgs)
  8092    if err != nil {
  8093      return types.MqTimedreceiveArgs{}, err
  8094    }
  8095  
  8096    for arg := 0; arg < int(numArgs); arg++ {
  8097      var currArg uint8
  8098      err = decoder.DecodeUint8(&currArg)
  8099      if err != nil {
  8100        return types.MqTimedreceiveArgs{}, err
  8101      }
  8102  
  8103      switch currArg {
  8104      case 0:
  8105        err = decoder.DecodeInt32(&result.Mqdes)
  8106        if err != nil {
  8107          return types.MqTimedreceiveArgs{}, err
  8108        }
  8109      case 1:
  8110        result.MsgPtr, err = decoder.ReadStringFromBuff()
  8111        if err != nil {
  8112          return types.MqTimedreceiveArgs{}, err
  8113        }
  8114      case 2:
  8115        err = decoder.DecodeUint64(&result.MsgLen)
  8116        if err != nil {
  8117          return types.MqTimedreceiveArgs{}, err
  8118        }
  8119      case 3:
  8120        var dataMsgPrio uint64
  8121        err = decoder.DecodeUint64(&dataMsgPrio)
  8122        if err != nil {
  8123          return types.MqTimedreceiveArgs{}, err
  8124        }
  8125        result.MsgPrio = uintptr(dataMsgPrio)
  8126      case 4:
  8127        result.AbsTimeout, err = decoder.ReadTimespec()
  8128        if err != nil {
  8129          return types.MqTimedreceiveArgs{}, err
  8130        }
  8131      }
  8132    }
  8133    return result, nil
  8134  }
  8135  
  8136  func ParseMqNotifyArgs(decoder *Decoder) (types.MqNotifyArgs, error) {
  8137    var result types.MqNotifyArgs
  8138    var err error
  8139  
  8140    var numArgs uint8
  8141    err = decoder.DecodeUint8(&numArgs)
  8142    if err != nil {
  8143      return types.MqNotifyArgs{}, err
  8144    }
  8145  
  8146    for arg := 0; arg < int(numArgs); arg++ {
  8147      var currArg uint8
  8148      err = decoder.DecodeUint8(&currArg)
  8149      if err != nil {
  8150        return types.MqNotifyArgs{}, err
  8151      }
  8152  
  8153      switch currArg {
  8154      case 0:
  8155        err = decoder.DecodeInt32(&result.Mqdes)
  8156        if err != nil {
  8157          return types.MqNotifyArgs{}, err
  8158        }
  8159      case 1:
  8160        var dataSevp uint64
  8161        err = decoder.DecodeUint64(&dataSevp)
  8162        if err != nil {
  8163          return types.MqNotifyArgs{}, err
  8164        }
  8165        result.Sevp = uintptr(dataSevp)
  8166      }
  8167    }
  8168    return result, nil
  8169  }
  8170  
  8171  func ParseMqGetsetattrArgs(decoder *Decoder) (types.MqGetsetattrArgs, error) {
  8172    var result types.MqGetsetattrArgs
  8173    var err error
  8174  
  8175    var numArgs uint8
  8176    err = decoder.DecodeUint8(&numArgs)
  8177    if err != nil {
  8178      return types.MqGetsetattrArgs{}, err
  8179    }
  8180  
  8181    for arg := 0; arg < int(numArgs); arg++ {
  8182      var currArg uint8
  8183      err = decoder.DecodeUint8(&currArg)
  8184      if err != nil {
  8185        return types.MqGetsetattrArgs{}, err
  8186      }
  8187  
  8188      switch currArg {
  8189      case 0:
  8190        err = decoder.DecodeInt32(&result.Mqdes)
  8191        if err != nil {
  8192          return types.MqGetsetattrArgs{}, err
  8193        }
  8194      case 1:
  8195        var dataNewattr uint64
  8196        err = decoder.DecodeUint64(&dataNewattr)
  8197        if err != nil {
  8198          return types.MqGetsetattrArgs{}, err
  8199        }
  8200        result.Newattr = uintptr(dataNewattr)
  8201      case 2:
  8202        var dataOldattr uint64
  8203        err = decoder.DecodeUint64(&dataOldattr)
  8204        if err != nil {
  8205          return types.MqGetsetattrArgs{}, err
  8206        }
  8207        result.Oldattr = uintptr(dataOldattr)
  8208      }
  8209    }
  8210    return result, nil
  8211  }
  8212  
  8213  func ParseKexecLoadArgs(decoder *Decoder) (types.KexecLoadArgs, error) {
  8214    var result types.KexecLoadArgs
  8215    var err error
  8216  
  8217    var numArgs uint8
  8218    err = decoder.DecodeUint8(&numArgs)
  8219    if err != nil {
  8220      return types.KexecLoadArgs{}, err
  8221    }
  8222  
  8223    for arg := 0; arg < int(numArgs); arg++ {
  8224      var currArg uint8
  8225      err = decoder.DecodeUint8(&currArg)
  8226      if err != nil {
  8227        return types.KexecLoadArgs{}, err
  8228      }
  8229  
  8230      switch currArg {
  8231      case 0:
  8232        err = decoder.DecodeUint64(&result.Entry)
  8233        if err != nil {
  8234          return types.KexecLoadArgs{}, err
  8235        }
  8236      case 1:
  8237        err = decoder.DecodeUint64(&result.NrSegments)
  8238        if err != nil {
  8239          return types.KexecLoadArgs{}, err
  8240        }
  8241      case 2:
  8242        var dataSegments uint64
  8243        err = decoder.DecodeUint64(&dataSegments)
  8244        if err != nil {
  8245          return types.KexecLoadArgs{}, err
  8246        }
  8247        result.Segments = uintptr(dataSegments)
  8248      case 3:
  8249        err = decoder.DecodeUint64(&result.Flags)
  8250        if err != nil {
  8251          return types.KexecLoadArgs{}, err
  8252        }
  8253      }
  8254    }
  8255    return result, nil
  8256  }
  8257  
  8258  func ParseWaitidArgs(decoder *Decoder) (types.WaitidArgs, error) {
  8259    var result types.WaitidArgs
  8260    var err error
  8261  
  8262    var numArgs uint8
  8263    err = decoder.DecodeUint8(&numArgs)
  8264    if err != nil {
  8265      return types.WaitidArgs{}, err
  8266    }
  8267  
  8268    for arg := 0; arg < int(numArgs); arg++ {
  8269      var currArg uint8
  8270      err = decoder.DecodeUint8(&currArg)
  8271      if err != nil {
  8272        return types.WaitidArgs{}, err
  8273      }
  8274  
  8275      switch currArg {
  8276      case 0:
  8277        err = decoder.DecodeInt32(&result.Idtype)
  8278        if err != nil {
  8279          return types.WaitidArgs{}, err
  8280        }
  8281      case 1:
  8282        err = decoder.DecodeInt32(&result.Id)
  8283        if err != nil {
  8284          return types.WaitidArgs{}, err
  8285        }
  8286      case 2:
  8287        var dataInfop uint64
  8288        err = decoder.DecodeUint64(&dataInfop)
  8289        if err != nil {
  8290          return types.WaitidArgs{}, err
  8291        }
  8292        result.Infop = uintptr(dataInfop)
  8293      case 3:
  8294        err = decoder.DecodeInt32(&result.Options)
  8295        if err != nil {
  8296          return types.WaitidArgs{}, err
  8297        }
  8298      case 4:
  8299        var dataRusage uint64
  8300        err = decoder.DecodeUint64(&dataRusage)
  8301        if err != nil {
  8302          return types.WaitidArgs{}, err
  8303        }
  8304        result.Rusage = uintptr(dataRusage)
  8305      }
  8306    }
  8307    return result, nil
  8308  }
  8309  
  8310  func ParseAddKeyArgs(decoder *Decoder) (types.AddKeyArgs, error) {
  8311    var result types.AddKeyArgs
  8312    var err error
  8313  
  8314    var numArgs uint8
  8315    err = decoder.DecodeUint8(&numArgs)
  8316    if err != nil {
  8317      return types.AddKeyArgs{}, err
  8318    }
  8319  
  8320    for arg := 0; arg < int(numArgs); arg++ {
  8321      var currArg uint8
  8322      err = decoder.DecodeUint8(&currArg)
  8323      if err != nil {
  8324        return types.AddKeyArgs{}, err
  8325      }
  8326  
  8327      switch currArg {
  8328      case 0:
  8329        result.Type, err = decoder.ReadStringFromBuff()
  8330        if err != nil {
  8331          return types.AddKeyArgs{}, err
  8332        }
  8333      case 1:
  8334        result.Description, err = decoder.ReadStringFromBuff()
  8335        if err != nil {
  8336          return types.AddKeyArgs{}, err
  8337        }
  8338      case 2:
  8339        var dataPayload uint64
  8340        err = decoder.DecodeUint64(&dataPayload)
  8341        if err != nil {
  8342          return types.AddKeyArgs{}, err
  8343        }
  8344        result.Payload = uintptr(dataPayload)
  8345      case 3:
  8346        err = decoder.DecodeUint64(&result.Plen)
  8347        if err != nil {
  8348          return types.AddKeyArgs{}, err
  8349        }
  8350      case 4:
  8351        err = decoder.DecodeInt32(&result.Keyring)
  8352        if err != nil {
  8353          return types.AddKeyArgs{}, err
  8354        }
  8355      }
  8356    }
  8357    return result, nil
  8358  }
  8359  
  8360  func ParseRequestKeyArgs(decoder *Decoder) (types.RequestKeyArgs, error) {
  8361    var result types.RequestKeyArgs
  8362    var err error
  8363  
  8364    var numArgs uint8
  8365    err = decoder.DecodeUint8(&numArgs)
  8366    if err != nil {
  8367      return types.RequestKeyArgs{}, err
  8368    }
  8369  
  8370    for arg := 0; arg < int(numArgs); arg++ {
  8371      var currArg uint8
  8372      err = decoder.DecodeUint8(&currArg)
  8373      if err != nil {
  8374        return types.RequestKeyArgs{}, err
  8375      }
  8376  
  8377      switch currArg {
  8378      case 0:
  8379        result.Type, err = decoder.ReadStringFromBuff()
  8380        if err != nil {
  8381          return types.RequestKeyArgs{}, err
  8382        }
  8383      case 1:
  8384        result.Description, err = decoder.ReadStringFromBuff()
  8385        if err != nil {
  8386          return types.RequestKeyArgs{}, err
  8387        }
  8388      case 2:
  8389        result.CalloutInfo, err = decoder.ReadStringFromBuff()
  8390        if err != nil {
  8391          return types.RequestKeyArgs{}, err
  8392        }
  8393      case 3:
  8394        err = decoder.DecodeInt32(&result.DestKeyring)
  8395        if err != nil {
  8396          return types.RequestKeyArgs{}, err
  8397        }
  8398      }
  8399    }
  8400    return result, nil
  8401  }
  8402  
  8403  func ParseKeyctlArgs(decoder *Decoder) (types.KeyctlArgs, error) {
  8404    var result types.KeyctlArgs
  8405    var err error
  8406  
  8407    var numArgs uint8
  8408    err = decoder.DecodeUint8(&numArgs)
  8409    if err != nil {
  8410      return types.KeyctlArgs{}, err
  8411    }
  8412  
  8413    for arg := 0; arg < int(numArgs); arg++ {
  8414      var currArg uint8
  8415      err = decoder.DecodeUint8(&currArg)
  8416      if err != nil {
  8417        return types.KeyctlArgs{}, err
  8418      }
  8419  
  8420      switch currArg {
  8421      case 0:
  8422        err = decoder.DecodeInt32(&result.Operation)
  8423        if err != nil {
  8424          return types.KeyctlArgs{}, err
  8425        }
  8426      case 1:
  8427        err = decoder.DecodeUint64(&result.Arg2)
  8428        if err != nil {
  8429          return types.KeyctlArgs{}, err
  8430        }
  8431      case 2:
  8432        err = decoder.DecodeUint64(&result.Arg3)
  8433        if err != nil {
  8434          return types.KeyctlArgs{}, err
  8435        }
  8436      case 3:
  8437        err = decoder.DecodeUint64(&result.Arg4)
  8438        if err != nil {
  8439          return types.KeyctlArgs{}, err
  8440        }
  8441      case 4:
  8442        err = decoder.DecodeUint64(&result.Arg5)
  8443        if err != nil {
  8444          return types.KeyctlArgs{}, err
  8445        }
  8446      }
  8447    }
  8448    return result, nil
  8449  }
  8450  
  8451  func ParseIoprioSetArgs(decoder *Decoder) (types.IoprioSetArgs, error) {
  8452    var result types.IoprioSetArgs
  8453    var err error
  8454  
  8455    var numArgs uint8
  8456    err = decoder.DecodeUint8(&numArgs)
  8457    if err != nil {
  8458      return types.IoprioSetArgs{}, err
  8459    }
  8460  
  8461    for arg := 0; arg < int(numArgs); arg++ {
  8462      var currArg uint8
  8463      err = decoder.DecodeUint8(&currArg)
  8464      if err != nil {
  8465        return types.IoprioSetArgs{}, err
  8466      }
  8467  
  8468      switch currArg {
  8469      case 0:
  8470        err = decoder.DecodeInt32(&result.Which)
  8471        if err != nil {
  8472          return types.IoprioSetArgs{}, err
  8473        }
  8474      case 1:
  8475        err = decoder.DecodeInt32(&result.Who)
  8476        if err != nil {
  8477          return types.IoprioSetArgs{}, err
  8478        }
  8479      case 2:
  8480        err = decoder.DecodeInt32(&result.Ioprio)
  8481        if err != nil {
  8482          return types.IoprioSetArgs{}, err
  8483        }
  8484      }
  8485    }
  8486    return result, nil
  8487  }
  8488  
  8489  func ParseIoprioGetArgs(decoder *Decoder) (types.IoprioGetArgs, error) {
  8490    var result types.IoprioGetArgs
  8491    var err error
  8492  
  8493    var numArgs uint8
  8494    err = decoder.DecodeUint8(&numArgs)
  8495    if err != nil {
  8496      return types.IoprioGetArgs{}, err
  8497    }
  8498  
  8499    for arg := 0; arg < int(numArgs); arg++ {
  8500      var currArg uint8
  8501      err = decoder.DecodeUint8(&currArg)
  8502      if err != nil {
  8503        return types.IoprioGetArgs{}, err
  8504      }
  8505  
  8506      switch currArg {
  8507      case 0:
  8508        err = decoder.DecodeInt32(&result.Which)
  8509        if err != nil {
  8510          return types.IoprioGetArgs{}, err
  8511        }
  8512      case 1:
  8513        err = decoder.DecodeInt32(&result.Who)
  8514        if err != nil {
  8515          return types.IoprioGetArgs{}, err
  8516        }
  8517      }
  8518    }
  8519    return result, nil
  8520  }
  8521  
  8522  func ParseInotifyInitArgs(decoder *Decoder) (types.InotifyInitArgs, error) {
  8523    return types.InotifyInitArgs{}, nil
  8524  }
  8525  
  8526  func ParseInotifyAddWatchArgs(decoder *Decoder) (types.InotifyAddWatchArgs, error) {
  8527    var result types.InotifyAddWatchArgs
  8528    var err error
  8529  
  8530    var numArgs uint8
  8531    err = decoder.DecodeUint8(&numArgs)
  8532    if err != nil {
  8533      return types.InotifyAddWatchArgs{}, err
  8534    }
  8535  
  8536    for arg := 0; arg < int(numArgs); arg++ {
  8537      var currArg uint8
  8538      err = decoder.DecodeUint8(&currArg)
  8539      if err != nil {
  8540        return types.InotifyAddWatchArgs{}, err
  8541      }
  8542  
  8543      switch currArg {
  8544      case 0:
  8545        err = decoder.DecodeInt32(&result.Fd)
  8546        if err != nil {
  8547          return types.InotifyAddWatchArgs{}, err
  8548        }
  8549      case 1:
  8550        result.Pathname, err = decoder.ReadStringFromBuff()
  8551        if err != nil {
  8552          return types.InotifyAddWatchArgs{}, err
  8553        }
  8554      case 2:
  8555        err = decoder.DecodeUint32(&result.Mask)
  8556        if err != nil {
  8557          return types.InotifyAddWatchArgs{}, err
  8558        }
  8559      }
  8560    }
  8561    return result, nil
  8562  }
  8563  
  8564  func ParseInotifyRmWatchArgs(decoder *Decoder) (types.InotifyRmWatchArgs, error) {
  8565    var result types.InotifyRmWatchArgs
  8566    var err error
  8567  
  8568    var numArgs uint8
  8569    err = decoder.DecodeUint8(&numArgs)
  8570    if err != nil {
  8571      return types.InotifyRmWatchArgs{}, err
  8572    }
  8573  
  8574    for arg := 0; arg < int(numArgs); arg++ {
  8575      var currArg uint8
  8576      err = decoder.DecodeUint8(&currArg)
  8577      if err != nil {
  8578        return types.InotifyRmWatchArgs{}, err
  8579      }
  8580  
  8581      switch currArg {
  8582      case 0:
  8583        err = decoder.DecodeInt32(&result.Fd)
  8584        if err != nil {
  8585          return types.InotifyRmWatchArgs{}, err
  8586        }
  8587      case 1:
  8588        err = decoder.DecodeInt32(&result.Wd)
  8589        if err != nil {
  8590          return types.InotifyRmWatchArgs{}, err
  8591        }
  8592      }
  8593    }
  8594    return result, nil
  8595  }
  8596  
  8597  func ParseMigratePagesArgs(decoder *Decoder) (types.MigratePagesArgs, error) {
  8598    var result types.MigratePagesArgs
  8599    var err error
  8600  
  8601    var numArgs uint8
  8602    err = decoder.DecodeUint8(&numArgs)
  8603    if err != nil {
  8604      return types.MigratePagesArgs{}, err
  8605    }
  8606  
  8607    for arg := 0; arg < int(numArgs); arg++ {
  8608      var currArg uint8
  8609      err = decoder.DecodeUint8(&currArg)
  8610      if err != nil {
  8611        return types.MigratePagesArgs{}, err
  8612      }
  8613  
  8614      switch currArg {
  8615      case 0:
  8616        err = decoder.DecodeInt32(&result.Pid)
  8617        if err != nil {
  8618          return types.MigratePagesArgs{}, err
  8619        }
  8620      case 1:
  8621        err = decoder.DecodeUint64(&result.Maxnode)
  8622        if err != nil {
  8623          return types.MigratePagesArgs{}, err
  8624        }
  8625      case 2:
  8626        var dataOldNodes uint64
  8627        err = decoder.DecodeUint64(&dataOldNodes)
  8628        if err != nil {
  8629          return types.MigratePagesArgs{}, err
  8630        }
  8631        result.OldNodes = uintptr(dataOldNodes)
  8632      case 3:
  8633        var dataNewNodes uint64
  8634        err = decoder.DecodeUint64(&dataNewNodes)
  8635        if err != nil {
  8636          return types.MigratePagesArgs{}, err
  8637        }
  8638        result.NewNodes = uintptr(dataNewNodes)
  8639      }
  8640    }
  8641    return result, nil
  8642  }
  8643  
  8644  func ParseOpenatArgs(decoder *Decoder) (types.OpenatArgs, error) {
  8645    var result types.OpenatArgs
  8646    var err error
  8647  
  8648    var numArgs uint8
  8649    err = decoder.DecodeUint8(&numArgs)
  8650    if err != nil {
  8651      return types.OpenatArgs{}, err
  8652    }
  8653  
  8654    for arg := 0; arg < int(numArgs); arg++ {
  8655      var currArg uint8
  8656      err = decoder.DecodeUint8(&currArg)
  8657      if err != nil {
  8658        return types.OpenatArgs{}, err
  8659      }
  8660  
  8661      switch currArg {
  8662      case 0:
  8663        err = decoder.DecodeInt32(&result.Dirfd)
  8664        if err != nil {
  8665          return types.OpenatArgs{}, err
  8666        }
  8667      case 1:
  8668        result.Pathname, err = decoder.ReadStringFromBuff()
  8669        if err != nil {
  8670          return types.OpenatArgs{}, err
  8671        }
  8672      case 2:
  8673        err = decoder.DecodeInt32(&result.Flags)
  8674        if err != nil {
  8675          return types.OpenatArgs{}, err
  8676        }
  8677      case 3:
  8678        err = decoder.DecodeUint32(&result.Mode)
  8679        if err != nil {
  8680          return types.OpenatArgs{}, err
  8681        }
  8682      }
  8683    }
  8684    return result, nil
  8685  }
  8686  
  8687  func ParseMkdiratArgs(decoder *Decoder) (types.MkdiratArgs, error) {
  8688    var result types.MkdiratArgs
  8689    var err error
  8690  
  8691    var numArgs uint8
  8692    err = decoder.DecodeUint8(&numArgs)
  8693    if err != nil {
  8694      return types.MkdiratArgs{}, err
  8695    }
  8696  
  8697    for arg := 0; arg < int(numArgs); arg++ {
  8698      var currArg uint8
  8699      err = decoder.DecodeUint8(&currArg)
  8700      if err != nil {
  8701        return types.MkdiratArgs{}, err
  8702      }
  8703  
  8704      switch currArg {
  8705      case 0:
  8706        err = decoder.DecodeInt32(&result.Dirfd)
  8707        if err != nil {
  8708          return types.MkdiratArgs{}, err
  8709        }
  8710      case 1:
  8711        result.Pathname, err = decoder.ReadStringFromBuff()
  8712        if err != nil {
  8713          return types.MkdiratArgs{}, err
  8714        }
  8715      case 2:
  8716        err = decoder.DecodeUint32(&result.Mode)
  8717        if err != nil {
  8718          return types.MkdiratArgs{}, err
  8719        }
  8720      }
  8721    }
  8722    return result, nil
  8723  }
  8724  
  8725  func ParseMknodatArgs(decoder *Decoder) (types.MknodatArgs, error) {
  8726    var result types.MknodatArgs
  8727    var err error
  8728  
  8729    var numArgs uint8
  8730    err = decoder.DecodeUint8(&numArgs)
  8731    if err != nil {
  8732      return types.MknodatArgs{}, err
  8733    }
  8734  
  8735    for arg := 0; arg < int(numArgs); arg++ {
  8736      var currArg uint8
  8737      err = decoder.DecodeUint8(&currArg)
  8738      if err != nil {
  8739        return types.MknodatArgs{}, err
  8740      }
  8741  
  8742      switch currArg {
  8743      case 0:
  8744        err = decoder.DecodeInt32(&result.Dirfd)
  8745        if err != nil {
  8746          return types.MknodatArgs{}, err
  8747        }
  8748      case 1:
  8749        result.Pathname, err = decoder.ReadStringFromBuff()
  8750        if err != nil {
  8751          return types.MknodatArgs{}, err
  8752        }
  8753      case 2:
  8754        err = decoder.DecodeUint32(&result.Mode)
  8755        if err != nil {
  8756          return types.MknodatArgs{}, err
  8757        }
  8758      case 3:
  8759        err = decoder.DecodeUint32(&result.Dev)
  8760        if err != nil {
  8761          return types.MknodatArgs{}, err
  8762        }
  8763      }
  8764    }
  8765    return result, nil
  8766  }
  8767  
  8768  func ParseFchownatArgs(decoder *Decoder) (types.FchownatArgs, error) {
  8769    var result types.FchownatArgs
  8770    var err error
  8771  
  8772    var numArgs uint8
  8773    err = decoder.DecodeUint8(&numArgs)
  8774    if err != nil {
  8775      return types.FchownatArgs{}, err
  8776    }
  8777  
  8778    for arg := 0; arg < int(numArgs); arg++ {
  8779      var currArg uint8
  8780      err = decoder.DecodeUint8(&currArg)
  8781      if err != nil {
  8782        return types.FchownatArgs{}, err
  8783      }
  8784  
  8785      switch currArg {
  8786      case 0:
  8787        err = decoder.DecodeInt32(&result.Dirfd)
  8788        if err != nil {
  8789          return types.FchownatArgs{}, err
  8790        }
  8791      case 1:
  8792        result.Pathname, err = decoder.ReadStringFromBuff()
  8793        if err != nil {
  8794          return types.FchownatArgs{}, err
  8795        }
  8796      case 2:
  8797        err = decoder.DecodeInt32(&result.Owner)
  8798        if err != nil {
  8799          return types.FchownatArgs{}, err
  8800        }
  8801      case 3:
  8802        err = decoder.DecodeInt32(&result.Group)
  8803        if err != nil {
  8804          return types.FchownatArgs{}, err
  8805        }
  8806      case 4:
  8807        err = decoder.DecodeInt32(&result.Flags)
  8808        if err != nil {
  8809          return types.FchownatArgs{}, err
  8810        }
  8811      }
  8812    }
  8813    return result, nil
  8814  }
  8815  
  8816  func ParseFutimesatArgs(decoder *Decoder) (types.FutimesatArgs, error) {
  8817    var result types.FutimesatArgs
  8818    var err error
  8819  
  8820    var numArgs uint8
  8821    err = decoder.DecodeUint8(&numArgs)
  8822    if err != nil {
  8823      return types.FutimesatArgs{}, err
  8824    }
  8825  
  8826    for arg := 0; arg < int(numArgs); arg++ {
  8827      var currArg uint8
  8828      err = decoder.DecodeUint8(&currArg)
  8829      if err != nil {
  8830        return types.FutimesatArgs{}, err
  8831      }
  8832  
  8833      switch currArg {
  8834      case 0:
  8835        err = decoder.DecodeInt32(&result.Dirfd)
  8836        if err != nil {
  8837          return types.FutimesatArgs{}, err
  8838        }
  8839      case 1:
  8840        result.Pathname, err = decoder.ReadStringFromBuff()
  8841        if err != nil {
  8842          return types.FutimesatArgs{}, err
  8843        }
  8844      case 2:
  8845        var dataTimes uint64
  8846        err = decoder.DecodeUint64(&dataTimes)
  8847        if err != nil {
  8848          return types.FutimesatArgs{}, err
  8849        }
  8850        result.Times = uintptr(dataTimes)
  8851      }
  8852    }
  8853    return result, nil
  8854  }
  8855  
  8856  func ParseNewfstatatArgs(decoder *Decoder) (types.NewfstatatArgs, error) {
  8857    var result types.NewfstatatArgs
  8858    var err error
  8859  
  8860    var numArgs uint8
  8861    err = decoder.DecodeUint8(&numArgs)
  8862    if err != nil {
  8863      return types.NewfstatatArgs{}, err
  8864    }
  8865  
  8866    for arg := 0; arg < int(numArgs); arg++ {
  8867      var currArg uint8
  8868      err = decoder.DecodeUint8(&currArg)
  8869      if err != nil {
  8870        return types.NewfstatatArgs{}, err
  8871      }
  8872  
  8873      switch currArg {
  8874      case 0:
  8875        err = decoder.DecodeInt32(&result.Dirfd)
  8876        if err != nil {
  8877          return types.NewfstatatArgs{}, err
  8878        }
  8879      case 1:
  8880        result.Pathname, err = decoder.ReadStringFromBuff()
  8881        if err != nil {
  8882          return types.NewfstatatArgs{}, err
  8883        }
  8884      case 2:
  8885        var dataStatbuf uint64
  8886        err = decoder.DecodeUint64(&dataStatbuf)
  8887        if err != nil {
  8888          return types.NewfstatatArgs{}, err
  8889        }
  8890        result.Statbuf = uintptr(dataStatbuf)
  8891      case 3:
  8892        err = decoder.DecodeInt32(&result.Flags)
  8893        if err != nil {
  8894          return types.NewfstatatArgs{}, err
  8895        }
  8896      }
  8897    }
  8898    return result, nil
  8899  }
  8900  
  8901  func ParseUnlinkatArgs(decoder *Decoder) (types.UnlinkatArgs, error) {
  8902    var result types.UnlinkatArgs
  8903    var err error
  8904  
  8905    var numArgs uint8
  8906    err = decoder.DecodeUint8(&numArgs)
  8907    if err != nil {
  8908      return types.UnlinkatArgs{}, err
  8909    }
  8910  
  8911    for arg := 0; arg < int(numArgs); arg++ {
  8912      var currArg uint8
  8913      err = decoder.DecodeUint8(&currArg)
  8914      if err != nil {
  8915        return types.UnlinkatArgs{}, err
  8916      }
  8917  
  8918      switch currArg {
  8919      case 0:
  8920        err = decoder.DecodeInt32(&result.Dirfd)
  8921        if err != nil {
  8922          return types.UnlinkatArgs{}, err
  8923        }
  8924      case 1:
  8925        result.Pathname, err = decoder.ReadStringFromBuff()
  8926        if err != nil {
  8927          return types.UnlinkatArgs{}, err
  8928        }
  8929      case 2:
  8930        err = decoder.DecodeInt32(&result.Flags)
  8931        if err != nil {
  8932          return types.UnlinkatArgs{}, err
  8933        }
  8934      }
  8935    }
  8936    return result, nil
  8937  }
  8938  
  8939  func ParseRenameatArgs(decoder *Decoder) (types.RenameatArgs, error) {
  8940    var result types.RenameatArgs
  8941    var err error
  8942  
  8943    var numArgs uint8
  8944    err = decoder.DecodeUint8(&numArgs)
  8945    if err != nil {
  8946      return types.RenameatArgs{}, err
  8947    }
  8948  
  8949    for arg := 0; arg < int(numArgs); arg++ {
  8950      var currArg uint8
  8951      err = decoder.DecodeUint8(&currArg)
  8952      if err != nil {
  8953        return types.RenameatArgs{}, err
  8954      }
  8955  
  8956      switch currArg {
  8957      case 0:
  8958        err = decoder.DecodeInt32(&result.Olddirfd)
  8959        if err != nil {
  8960          return types.RenameatArgs{}, err
  8961        }
  8962      case 1:
  8963        result.Oldpath, err = decoder.ReadStringFromBuff()
  8964        if err != nil {
  8965          return types.RenameatArgs{}, err
  8966        }
  8967      case 2:
  8968        err = decoder.DecodeInt32(&result.Newdirfd)
  8969        if err != nil {
  8970          return types.RenameatArgs{}, err
  8971        }
  8972      case 3:
  8973        result.Newpath, err = decoder.ReadStringFromBuff()
  8974        if err != nil {
  8975          return types.RenameatArgs{}, err
  8976        }
  8977      }
  8978    }
  8979    return result, nil
  8980  }
  8981  
  8982  func ParseLinkatArgs(decoder *Decoder) (types.LinkatArgs, error) {
  8983    var result types.LinkatArgs
  8984    var err error
  8985  
  8986    var numArgs uint8
  8987    err = decoder.DecodeUint8(&numArgs)
  8988    if err != nil {
  8989      return types.LinkatArgs{}, err
  8990    }
  8991  
  8992    for arg := 0; arg < int(numArgs); arg++ {
  8993      var currArg uint8
  8994      err = decoder.DecodeUint8(&currArg)
  8995      if err != nil {
  8996        return types.LinkatArgs{}, err
  8997      }
  8998  
  8999      switch currArg {
  9000      case 0:
  9001        err = decoder.DecodeInt32(&result.Olddirfd)
  9002        if err != nil {
  9003          return types.LinkatArgs{}, err
  9004        }
  9005      case 1:
  9006        result.Oldpath, err = decoder.ReadStringFromBuff()
  9007        if err != nil {
  9008          return types.LinkatArgs{}, err
  9009        }
  9010      case 2:
  9011        err = decoder.DecodeInt32(&result.Newdirfd)
  9012        if err != nil {
  9013          return types.LinkatArgs{}, err
  9014        }
  9015      case 3:
  9016        result.Newpath, err = decoder.ReadStringFromBuff()
  9017        if err != nil {
  9018          return types.LinkatArgs{}, err
  9019        }
  9020      case 4:
  9021        err = decoder.DecodeUint32(&result.Flags)
  9022        if err != nil {
  9023          return types.LinkatArgs{}, err
  9024        }
  9025      }
  9026    }
  9027    return result, nil
  9028  }
  9029  
  9030  func ParseSymlinkatArgs(decoder *Decoder) (types.SymlinkatArgs, error) {
  9031    var result types.SymlinkatArgs
  9032    var err error
  9033  
  9034    var numArgs uint8
  9035    err = decoder.DecodeUint8(&numArgs)
  9036    if err != nil {
  9037      return types.SymlinkatArgs{}, err
  9038    }
  9039  
  9040    for arg := 0; arg < int(numArgs); arg++ {
  9041      var currArg uint8
  9042      err = decoder.DecodeUint8(&currArg)
  9043      if err != nil {
  9044        return types.SymlinkatArgs{}, err
  9045      }
  9046  
  9047      switch currArg {
  9048      case 0:
  9049        result.Target, err = decoder.ReadStringFromBuff()
  9050        if err != nil {
  9051          return types.SymlinkatArgs{}, err
  9052        }
  9053      case 1:
  9054        err = decoder.DecodeInt32(&result.Newdirfd)
  9055        if err != nil {
  9056          return types.SymlinkatArgs{}, err
  9057        }
  9058      case 2:
  9059        result.Linkpath, err = decoder.ReadStringFromBuff()
  9060        if err != nil {
  9061          return types.SymlinkatArgs{}, err
  9062        }
  9063      }
  9064    }
  9065    return result, nil
  9066  }
  9067  
  9068  func ParseReadlinkatArgs(decoder *Decoder) (types.ReadlinkatArgs, error) {
  9069    var result types.ReadlinkatArgs
  9070    var err error
  9071  
  9072    var numArgs uint8
  9073    err = decoder.DecodeUint8(&numArgs)
  9074    if err != nil {
  9075      return types.ReadlinkatArgs{}, err
  9076    }
  9077  
  9078    for arg := 0; arg < int(numArgs); arg++ {
  9079      var currArg uint8
  9080      err = decoder.DecodeUint8(&currArg)
  9081      if err != nil {
  9082        return types.ReadlinkatArgs{}, err
  9083      }
  9084  
  9085      switch currArg {
  9086      case 0:
  9087        err = decoder.DecodeInt32(&result.Dirfd)
  9088        if err != nil {
  9089          return types.ReadlinkatArgs{}, err
  9090        }
  9091      case 1:
  9092        result.Pathname, err = decoder.ReadStringFromBuff()
  9093        if err != nil {
  9094          return types.ReadlinkatArgs{}, err
  9095        }
  9096      case 2:
  9097        result.Buf, err = decoder.ReadStringFromBuff()
  9098        if err != nil {
  9099          return types.ReadlinkatArgs{}, err
  9100        }
  9101      case 3:
  9102        err = decoder.DecodeInt32(&result.Bufsiz)
  9103        if err != nil {
  9104          return types.ReadlinkatArgs{}, err
  9105        }
  9106      }
  9107    }
  9108    return result, nil
  9109  }
  9110  
  9111  func ParseFchmodatArgs(decoder *Decoder) (types.FchmodatArgs, error) {
  9112    var result types.FchmodatArgs
  9113    var err error
  9114  
  9115    var numArgs uint8
  9116    err = decoder.DecodeUint8(&numArgs)
  9117    if err != nil {
  9118      return types.FchmodatArgs{}, err
  9119    }
  9120  
  9121    for arg := 0; arg < int(numArgs); arg++ {
  9122      var currArg uint8
  9123      err = decoder.DecodeUint8(&currArg)
  9124      if err != nil {
  9125        return types.FchmodatArgs{}, err
  9126      }
  9127  
  9128      switch currArg {
  9129      case 0:
  9130        err = decoder.DecodeInt32(&result.Dirfd)
  9131        if err != nil {
  9132          return types.FchmodatArgs{}, err
  9133        }
  9134      case 1:
  9135        result.Pathname, err = decoder.ReadStringFromBuff()
  9136        if err != nil {
  9137          return types.FchmodatArgs{}, err
  9138        }
  9139      case 2:
  9140        err = decoder.DecodeUint32(&result.Mode)
  9141        if err != nil {
  9142          return types.FchmodatArgs{}, err
  9143        }
  9144      case 3:
  9145        err = decoder.DecodeInt32(&result.Flags)
  9146        if err != nil {
  9147          return types.FchmodatArgs{}, err
  9148        }
  9149      }
  9150    }
  9151    return result, nil
  9152  }
  9153  
  9154  func ParseFaccessatArgs(decoder *Decoder) (types.FaccessatArgs, error) {
  9155    var result types.FaccessatArgs
  9156    var err error
  9157  
  9158    var numArgs uint8
  9159    err = decoder.DecodeUint8(&numArgs)
  9160    if err != nil {
  9161      return types.FaccessatArgs{}, err
  9162    }
  9163  
  9164    for arg := 0; arg < int(numArgs); arg++ {
  9165      var currArg uint8
  9166      err = decoder.DecodeUint8(&currArg)
  9167      if err != nil {
  9168        return types.FaccessatArgs{}, err
  9169      }
  9170  
  9171      switch currArg {
  9172      case 0:
  9173        err = decoder.DecodeInt32(&result.Dirfd)
  9174        if err != nil {
  9175          return types.FaccessatArgs{}, err
  9176        }
  9177      case 1:
  9178        result.Pathname, err = decoder.ReadStringFromBuff()
  9179        if err != nil {
  9180          return types.FaccessatArgs{}, err
  9181        }
  9182      case 2:
  9183        err = decoder.DecodeInt32(&result.Mode)
  9184        if err != nil {
  9185          return types.FaccessatArgs{}, err
  9186        }
  9187      case 3:
  9188        err = decoder.DecodeInt32(&result.Flags)
  9189        if err != nil {
  9190          return types.FaccessatArgs{}, err
  9191        }
  9192      }
  9193    }
  9194    return result, nil
  9195  }
  9196  
  9197  func ParsePselect6Args(decoder *Decoder) (types.Pselect6Args, error) {
  9198    var result types.Pselect6Args
  9199    var err error
  9200  
  9201    var numArgs uint8
  9202    err = decoder.DecodeUint8(&numArgs)
  9203    if err != nil {
  9204      return types.Pselect6Args{}, err
  9205    }
  9206  
  9207    for arg := 0; arg < int(numArgs); arg++ {
  9208      var currArg uint8
  9209      err = decoder.DecodeUint8(&currArg)
  9210      if err != nil {
  9211        return types.Pselect6Args{}, err
  9212      }
  9213  
  9214      switch currArg {
  9215      case 0:
  9216        err = decoder.DecodeInt32(&result.Nfds)
  9217        if err != nil {
  9218          return types.Pselect6Args{}, err
  9219        }
  9220      case 1:
  9221        var dataReadfds uint64
  9222        err = decoder.DecodeUint64(&dataReadfds)
  9223        if err != nil {
  9224          return types.Pselect6Args{}, err
  9225        }
  9226        result.Readfds = uintptr(dataReadfds)
  9227      case 2:
  9228        var dataWritefds uint64
  9229        err = decoder.DecodeUint64(&dataWritefds)
  9230        if err != nil {
  9231          return types.Pselect6Args{}, err
  9232        }
  9233        result.Writefds = uintptr(dataWritefds)
  9234      case 3:
  9235        var dataExceptfds uint64
  9236        err = decoder.DecodeUint64(&dataExceptfds)
  9237        if err != nil {
  9238          return types.Pselect6Args{}, err
  9239        }
  9240        result.Exceptfds = uintptr(dataExceptfds)
  9241      case 4:
  9242        result.Timeout, err = decoder.ReadTimespec()
  9243        if err != nil {
  9244          return types.Pselect6Args{}, err
  9245        }
  9246      case 5:
  9247        var dataSigmask uint64
  9248        err = decoder.DecodeUint64(&dataSigmask)
  9249        if err != nil {
  9250          return types.Pselect6Args{}, err
  9251        }
  9252        result.Sigmask = uintptr(dataSigmask)
  9253      }
  9254    }
  9255    return result, nil
  9256  }
  9257  
  9258  func ParsePpollArgs(decoder *Decoder) (types.PpollArgs, error) {
  9259    var result types.PpollArgs
  9260    var err error
  9261  
  9262    var numArgs uint8
  9263    err = decoder.DecodeUint8(&numArgs)
  9264    if err != nil {
  9265      return types.PpollArgs{}, err
  9266    }
  9267  
  9268    for arg := 0; arg < int(numArgs); arg++ {
  9269      var currArg uint8
  9270      err = decoder.DecodeUint8(&currArg)
  9271      if err != nil {
  9272        return types.PpollArgs{}, err
  9273      }
  9274  
  9275      switch currArg {
  9276      case 0:
  9277        var dataFds uint64
  9278        err = decoder.DecodeUint64(&dataFds)
  9279        if err != nil {
  9280          return types.PpollArgs{}, err
  9281        }
  9282        result.Fds = uintptr(dataFds)
  9283      case 1:
  9284        err = decoder.DecodeUint32(&result.Nfds)
  9285        if err != nil {
  9286          return types.PpollArgs{}, err
  9287        }
  9288      case 2:
  9289        result.TmoP, err = decoder.ReadTimespec()
  9290        if err != nil {
  9291          return types.PpollArgs{}, err
  9292        }
  9293      case 3:
  9294        var dataSigmask uint64
  9295        err = decoder.DecodeUint64(&dataSigmask)
  9296        if err != nil {
  9297          return types.PpollArgs{}, err
  9298        }
  9299        result.Sigmask = uintptr(dataSigmask)
  9300      case 4:
  9301        err = decoder.DecodeUint64(&result.Sigsetsize)
  9302        if err != nil {
  9303          return types.PpollArgs{}, err
  9304        }
  9305      }
  9306    }
  9307    return result, nil
  9308  }
  9309  
  9310  func ParseUnshareArgs(decoder *Decoder) (types.UnshareArgs, error) {
  9311    var result types.UnshareArgs
  9312    var err error
  9313  
  9314    var numArgs uint8
  9315    err = decoder.DecodeUint8(&numArgs)
  9316    if err != nil {
  9317      return types.UnshareArgs{}, err
  9318    }
  9319  
  9320    for arg := 0; arg < int(numArgs); arg++ {
  9321      var currArg uint8
  9322      err = decoder.DecodeUint8(&currArg)
  9323      if err != nil {
  9324        return types.UnshareArgs{}, err
  9325      }
  9326  
  9327      switch currArg {
  9328      case 0:
  9329        err = decoder.DecodeInt32(&result.Flags)
  9330        if err != nil {
  9331          return types.UnshareArgs{}, err
  9332        }
  9333      }
  9334    }
  9335    return result, nil
  9336  }
  9337  
  9338  func ParseSetRobustListArgs(decoder *Decoder) (types.SetRobustListArgs, error) {
  9339    var result types.SetRobustListArgs
  9340    var err error
  9341  
  9342    var numArgs uint8
  9343    err = decoder.DecodeUint8(&numArgs)
  9344    if err != nil {
  9345      return types.SetRobustListArgs{}, err
  9346    }
  9347  
  9348    for arg := 0; arg < int(numArgs); arg++ {
  9349      var currArg uint8
  9350      err = decoder.DecodeUint8(&currArg)
  9351      if err != nil {
  9352        return types.SetRobustListArgs{}, err
  9353      }
  9354  
  9355      switch currArg {
  9356      case 0:
  9357        var dataHead uint64
  9358        err = decoder.DecodeUint64(&dataHead)
  9359        if err != nil {
  9360          return types.SetRobustListArgs{}, err
  9361        }
  9362        result.Head = uintptr(dataHead)
  9363      case 1:
  9364        err = decoder.DecodeUint64(&result.Len)
  9365        if err != nil {
  9366          return types.SetRobustListArgs{}, err
  9367        }
  9368      }
  9369    }
  9370    return result, nil
  9371  }
  9372  
  9373  func ParseGetRobustListArgs(decoder *Decoder) (types.GetRobustListArgs, error) {
  9374    var result types.GetRobustListArgs
  9375    var err error
  9376  
  9377    var numArgs uint8
  9378    err = decoder.DecodeUint8(&numArgs)
  9379    if err != nil {
  9380      return types.GetRobustListArgs{}, err
  9381    }
  9382  
  9383    for arg := 0; arg < int(numArgs); arg++ {
  9384      var currArg uint8
  9385      err = decoder.DecodeUint8(&currArg)
  9386      if err != nil {
  9387        return types.GetRobustListArgs{}, err
  9388      }
  9389  
  9390      switch currArg {
  9391      case 0:
  9392        err = decoder.DecodeInt32(&result.Pid)
  9393        if err != nil {
  9394          return types.GetRobustListArgs{}, err
  9395        }
  9396      case 1:
  9397        var dataHeadPtr uint64
  9398        err = decoder.DecodeUint64(&dataHeadPtr)
  9399        if err != nil {
  9400          return types.GetRobustListArgs{}, err
  9401        }
  9402        result.HeadPtr = uintptr(dataHeadPtr)
  9403      case 2:
  9404        var dataLenPtr uint64
  9405        err = decoder.DecodeUint64(&dataLenPtr)
  9406        if err != nil {
  9407          return types.GetRobustListArgs{}, err
  9408        }
  9409        result.LenPtr = uintptr(dataLenPtr)
  9410      }
  9411    }
  9412    return result, nil
  9413  }
  9414  
  9415  func ParseSpliceArgs(decoder *Decoder) (types.SpliceArgs, error) {
  9416    var result types.SpliceArgs
  9417    var err error
  9418  
  9419    var numArgs uint8
  9420    err = decoder.DecodeUint8(&numArgs)
  9421    if err != nil {
  9422      return types.SpliceArgs{}, err
  9423    }
  9424  
  9425    for arg := 0; arg < int(numArgs); arg++ {
  9426      var currArg uint8
  9427      err = decoder.DecodeUint8(&currArg)
  9428      if err != nil {
  9429        return types.SpliceArgs{}, err
  9430      }
  9431  
  9432      switch currArg {
  9433      case 0:
  9434        err = decoder.DecodeInt32(&result.FdIn)
  9435        if err != nil {
  9436          return types.SpliceArgs{}, err
  9437        }
  9438      case 1:
  9439        var dataOffIn uint64
  9440        err = decoder.DecodeUint64(&dataOffIn)
  9441        if err != nil {
  9442          return types.SpliceArgs{}, err
  9443        }
  9444        result.OffIn = uintptr(dataOffIn)
  9445      case 2:
  9446        err = decoder.DecodeInt32(&result.FdOut)
  9447        if err != nil {
  9448          return types.SpliceArgs{}, err
  9449        }
  9450      case 3:
  9451        var dataOffOut uint64
  9452        err = decoder.DecodeUint64(&dataOffOut)
  9453        if err != nil {
  9454          return types.SpliceArgs{}, err
  9455        }
  9456        result.OffOut = uintptr(dataOffOut)
  9457      case 4:
  9458        err = decoder.DecodeUint64(&result.Len)
  9459        if err != nil {
  9460          return types.SpliceArgs{}, err
  9461        }
  9462      case 5:
  9463        err = decoder.DecodeUint32(&result.Flags)
  9464        if err != nil {
  9465          return types.SpliceArgs{}, err
  9466        }
  9467      }
  9468    }
  9469    return result, nil
  9470  }
  9471  
  9472  func ParseTeeArgs(decoder *Decoder) (types.TeeArgs, error) {
  9473    var result types.TeeArgs
  9474    var err error
  9475  
  9476    var numArgs uint8
  9477    err = decoder.DecodeUint8(&numArgs)
  9478    if err != nil {
  9479      return types.TeeArgs{}, err
  9480    }
  9481  
  9482    for arg := 0; arg < int(numArgs); arg++ {
  9483      var currArg uint8
  9484      err = decoder.DecodeUint8(&currArg)
  9485      if err != nil {
  9486        return types.TeeArgs{}, err
  9487      }
  9488  
  9489      switch currArg {
  9490      case 0:
  9491        err = decoder.DecodeInt32(&result.FdIn)
  9492        if err != nil {
  9493          return types.TeeArgs{}, err
  9494        }
  9495      case 1:
  9496        err = decoder.DecodeInt32(&result.FdOut)
  9497        if err != nil {
  9498          return types.TeeArgs{}, err
  9499        }
  9500      case 2:
  9501        err = decoder.DecodeUint64(&result.Len)
  9502        if err != nil {
  9503          return types.TeeArgs{}, err
  9504        }
  9505      case 3:
  9506        err = decoder.DecodeUint32(&result.Flags)
  9507        if err != nil {
  9508          return types.TeeArgs{}, err
  9509        }
  9510      }
  9511    }
  9512    return result, nil
  9513  }
  9514  
  9515  func ParseSyncFileRangeArgs(decoder *Decoder) (types.SyncFileRangeArgs, error) {
  9516    var result types.SyncFileRangeArgs
  9517    var err error
  9518  
  9519    var numArgs uint8
  9520    err = decoder.DecodeUint8(&numArgs)
  9521    if err != nil {
  9522      return types.SyncFileRangeArgs{}, err
  9523    }
  9524  
  9525    for arg := 0; arg < int(numArgs); arg++ {
  9526      var currArg uint8
  9527      err = decoder.DecodeUint8(&currArg)
  9528      if err != nil {
  9529        return types.SyncFileRangeArgs{}, err
  9530      }
  9531  
  9532      switch currArg {
  9533      case 0:
  9534        err = decoder.DecodeInt32(&result.Fd)
  9535        if err != nil {
  9536          return types.SyncFileRangeArgs{}, err
  9537        }
  9538      case 1:
  9539        err = decoder.DecodeUint64(&result.Offset)
  9540        if err != nil {
  9541          return types.SyncFileRangeArgs{}, err
  9542        }
  9543      case 2:
  9544        err = decoder.DecodeUint64(&result.Nbytes)
  9545        if err != nil {
  9546          return types.SyncFileRangeArgs{}, err
  9547        }
  9548      case 3:
  9549        err = decoder.DecodeUint32(&result.Flags)
  9550        if err != nil {
  9551          return types.SyncFileRangeArgs{}, err
  9552        }
  9553      }
  9554    }
  9555    return result, nil
  9556  }
  9557  
  9558  func ParseVmspliceArgs(decoder *Decoder) (types.VmspliceArgs, error) {
  9559    var result types.VmspliceArgs
  9560    var err error
  9561  
  9562    var numArgs uint8
  9563    err = decoder.DecodeUint8(&numArgs)
  9564    if err != nil {
  9565      return types.VmspliceArgs{}, err
  9566    }
  9567  
  9568    for arg := 0; arg < int(numArgs); arg++ {
  9569      var currArg uint8
  9570      err = decoder.DecodeUint8(&currArg)
  9571      if err != nil {
  9572        return types.VmspliceArgs{}, err
  9573      }
  9574  
  9575      switch currArg {
  9576      case 0:
  9577        err = decoder.DecodeInt32(&result.Fd)
  9578        if err != nil {
  9579          return types.VmspliceArgs{}, err
  9580        }
  9581      case 1:
  9582        var dataIov uint64
  9583        err = decoder.DecodeUint64(&dataIov)
  9584        if err != nil {
  9585          return types.VmspliceArgs{}, err
  9586        }
  9587        result.Iov = uintptr(dataIov)
  9588      case 2:
  9589        err = decoder.DecodeUint64(&result.NrSegs)
  9590        if err != nil {
  9591          return types.VmspliceArgs{}, err
  9592        }
  9593      case 3:
  9594        err = decoder.DecodeUint32(&result.Flags)
  9595        if err != nil {
  9596          return types.VmspliceArgs{}, err
  9597        }
  9598      }
  9599    }
  9600    return result, nil
  9601  }
  9602  
  9603  func ParseMovePagesArgs(decoder *Decoder) (types.MovePagesArgs, error) {
  9604    var result types.MovePagesArgs
  9605    var err error
  9606  
  9607    var numArgs uint8
  9608    err = decoder.DecodeUint8(&numArgs)
  9609    if err != nil {
  9610      return types.MovePagesArgs{}, err
  9611    }
  9612  
  9613    for arg := 0; arg < int(numArgs); arg++ {
  9614      var currArg uint8
  9615      err = decoder.DecodeUint8(&currArg)
  9616      if err != nil {
  9617        return types.MovePagesArgs{}, err
  9618      }
  9619  
  9620      switch currArg {
  9621      case 0:
  9622        err = decoder.DecodeInt32(&result.Pid)
  9623        if err != nil {
  9624          return types.MovePagesArgs{}, err
  9625        }
  9626      case 1:
  9627        err = decoder.DecodeUint64(&result.Count)
  9628        if err != nil {
  9629          return types.MovePagesArgs{}, err
  9630        }
  9631      case 2:
  9632        var dataPages uint64
  9633        err = decoder.DecodeUint64(&dataPages)
  9634        if err != nil {
  9635          return types.MovePagesArgs{}, err
  9636        }
  9637        result.Pages = uintptr(dataPages)
  9638      case 3:
  9639        var dataNodes uint64
  9640        err = decoder.DecodeUint64(&dataNodes)
  9641        if err != nil {
  9642          return types.MovePagesArgs{}, err
  9643        }
  9644        result.Nodes = uintptr(dataNodes)
  9645      case 4:
  9646        var dataStatus uint64
  9647        err = decoder.DecodeUint64(&dataStatus)
  9648        if err != nil {
  9649          return types.MovePagesArgs{}, err
  9650        }
  9651        result.Status = uintptr(dataStatus)
  9652      case 5:
  9653        err = decoder.DecodeInt32(&result.Flags)
  9654        if err != nil {
  9655          return types.MovePagesArgs{}, err
  9656        }
  9657      }
  9658    }
  9659    return result, nil
  9660  }
  9661  
  9662  func ParseUtimensatArgs(decoder *Decoder) (types.UtimensatArgs, error) {
  9663    var result types.UtimensatArgs
  9664    var err error
  9665  
  9666    var numArgs uint8
  9667    err = decoder.DecodeUint8(&numArgs)
  9668    if err != nil {
  9669      return types.UtimensatArgs{}, err
  9670    }
  9671  
  9672    for arg := 0; arg < int(numArgs); arg++ {
  9673      var currArg uint8
  9674      err = decoder.DecodeUint8(&currArg)
  9675      if err != nil {
  9676        return types.UtimensatArgs{}, err
  9677      }
  9678  
  9679      switch currArg {
  9680      case 0:
  9681        err = decoder.DecodeInt32(&result.Dirfd)
  9682        if err != nil {
  9683          return types.UtimensatArgs{}, err
  9684        }
  9685      case 1:
  9686        result.Pathname, err = decoder.ReadStringFromBuff()
  9687        if err != nil {
  9688          return types.UtimensatArgs{}, err
  9689        }
  9690      case 2:
  9691        result.Times, err = decoder.ReadTimespec()
  9692        if err != nil {
  9693          return types.UtimensatArgs{}, err
  9694        }
  9695      case 3:
  9696        err = decoder.DecodeInt32(&result.Flags)
  9697        if err != nil {
  9698          return types.UtimensatArgs{}, err
  9699        }
  9700      }
  9701    }
  9702    return result, nil
  9703  }
  9704  
  9705  func ParseEpollPwaitArgs(decoder *Decoder) (types.EpollPwaitArgs, error) {
  9706    var result types.EpollPwaitArgs
  9707    var err error
  9708  
  9709    var numArgs uint8
  9710    err = decoder.DecodeUint8(&numArgs)
  9711    if err != nil {
  9712      return types.EpollPwaitArgs{}, err
  9713    }
  9714  
  9715    for arg := 0; arg < int(numArgs); arg++ {
  9716      var currArg uint8
  9717      err = decoder.DecodeUint8(&currArg)
  9718      if err != nil {
  9719        return types.EpollPwaitArgs{}, err
  9720      }
  9721  
  9722      switch currArg {
  9723      case 0:
  9724        err = decoder.DecodeInt32(&result.Epfd)
  9725        if err != nil {
  9726          return types.EpollPwaitArgs{}, err
  9727        }
  9728      case 1:
  9729        var dataEvents uint64
  9730        err = decoder.DecodeUint64(&dataEvents)
  9731        if err != nil {
  9732          return types.EpollPwaitArgs{}, err
  9733        }
  9734        result.Events = uintptr(dataEvents)
  9735      case 2:
  9736        err = decoder.DecodeInt32(&result.Maxevents)
  9737        if err != nil {
  9738          return types.EpollPwaitArgs{}, err
  9739        }
  9740      case 3:
  9741        err = decoder.DecodeInt32(&result.Timeout)
  9742        if err != nil {
  9743          return types.EpollPwaitArgs{}, err
  9744        }
  9745      case 4:
  9746        var dataSigmask uint64
  9747        err = decoder.DecodeUint64(&dataSigmask)
  9748        if err != nil {
  9749          return types.EpollPwaitArgs{}, err
  9750        }
  9751        result.Sigmask = uintptr(dataSigmask)
  9752      case 5:
  9753        err = decoder.DecodeUint64(&result.Sigsetsize)
  9754        if err != nil {
  9755          return types.EpollPwaitArgs{}, err
  9756        }
  9757      }
  9758    }
  9759    return result, nil
  9760  }
  9761  
  9762  func ParseSignalfdArgs(decoder *Decoder) (types.SignalfdArgs, error) {
  9763    var result types.SignalfdArgs
  9764    var err error
  9765  
  9766    var numArgs uint8
  9767    err = decoder.DecodeUint8(&numArgs)
  9768    if err != nil {
  9769      return types.SignalfdArgs{}, err
  9770    }
  9771  
  9772    for arg := 0; arg < int(numArgs); arg++ {
  9773      var currArg uint8
  9774      err = decoder.DecodeUint8(&currArg)
  9775      if err != nil {
  9776        return types.SignalfdArgs{}, err
  9777      }
  9778  
  9779      switch currArg {
  9780      case 0:
  9781        err = decoder.DecodeInt32(&result.Fd)
  9782        if err != nil {
  9783          return types.SignalfdArgs{}, err
  9784        }
  9785      case 1:
  9786        var dataMask uint64
  9787        err = decoder.DecodeUint64(&dataMask)
  9788        if err != nil {
  9789          return types.SignalfdArgs{}, err
  9790        }
  9791        result.Mask = uintptr(dataMask)
  9792      case 2:
  9793        err = decoder.DecodeInt32(&result.Flags)
  9794        if err != nil {
  9795          return types.SignalfdArgs{}, err
  9796        }
  9797      }
  9798    }
  9799    return result, nil
  9800  }
  9801  
  9802  func ParseTimerfdCreateArgs(decoder *Decoder) (types.TimerfdCreateArgs, error) {
  9803    var result types.TimerfdCreateArgs
  9804    var err error
  9805  
  9806    var numArgs uint8
  9807    err = decoder.DecodeUint8(&numArgs)
  9808    if err != nil {
  9809      return types.TimerfdCreateArgs{}, err
  9810    }
  9811  
  9812    for arg := 0; arg < int(numArgs); arg++ {
  9813      var currArg uint8
  9814      err = decoder.DecodeUint8(&currArg)
  9815      if err != nil {
  9816        return types.TimerfdCreateArgs{}, err
  9817      }
  9818  
  9819      switch currArg {
  9820      case 0:
  9821        err = decoder.DecodeInt32(&result.Clockid)
  9822        if err != nil {
  9823          return types.TimerfdCreateArgs{}, err
  9824        }
  9825      case 1:
  9826        err = decoder.DecodeInt32(&result.Flags)
  9827        if err != nil {
  9828          return types.TimerfdCreateArgs{}, err
  9829        }
  9830      }
  9831    }
  9832    return result, nil
  9833  }
  9834  
  9835  func ParseEventfdArgs(decoder *Decoder) (types.EventfdArgs, error) {
  9836    var result types.EventfdArgs
  9837    var err error
  9838  
  9839    var numArgs uint8
  9840    err = decoder.DecodeUint8(&numArgs)
  9841    if err != nil {
  9842      return types.EventfdArgs{}, err
  9843    }
  9844  
  9845    for arg := 0; arg < int(numArgs); arg++ {
  9846      var currArg uint8
  9847      err = decoder.DecodeUint8(&currArg)
  9848      if err != nil {
  9849        return types.EventfdArgs{}, err
  9850      }
  9851  
  9852      switch currArg {
  9853      case 0:
  9854        err = decoder.DecodeUint32(&result.Initval)
  9855        if err != nil {
  9856          return types.EventfdArgs{}, err
  9857        }
  9858      case 1:
  9859        err = decoder.DecodeInt32(&result.Flags)
  9860        if err != nil {
  9861          return types.EventfdArgs{}, err
  9862        }
  9863      }
  9864    }
  9865    return result, nil
  9866  }
  9867  
  9868  func ParseFallocateArgs(decoder *Decoder) (types.FallocateArgs, error) {
  9869    var result types.FallocateArgs
  9870    var err error
  9871  
  9872    var numArgs uint8
  9873    err = decoder.DecodeUint8(&numArgs)
  9874    if err != nil {
  9875      return types.FallocateArgs{}, err
  9876    }
  9877  
  9878    for arg := 0; arg < int(numArgs); arg++ {
  9879      var currArg uint8
  9880      err = decoder.DecodeUint8(&currArg)
  9881      if err != nil {
  9882        return types.FallocateArgs{}, err
  9883      }
  9884  
  9885      switch currArg {
  9886      case 0:
  9887        err = decoder.DecodeInt32(&result.Fd)
  9888        if err != nil {
  9889          return types.FallocateArgs{}, err
  9890        }
  9891      case 1:
  9892        err = decoder.DecodeInt32(&result.Mode)
  9893        if err != nil {
  9894          return types.FallocateArgs{}, err
  9895        }
  9896      case 2:
  9897        err = decoder.DecodeUint64(&result.Offset)
  9898        if err != nil {
  9899          return types.FallocateArgs{}, err
  9900        }
  9901      case 3:
  9902        err = decoder.DecodeUint64(&result.Len)
  9903        if err != nil {
  9904          return types.FallocateArgs{}, err
  9905        }
  9906      }
  9907    }
  9908    return result, nil
  9909  }
  9910  
  9911  func ParseTimerfdSettimeArgs(decoder *Decoder) (types.TimerfdSettimeArgs, error) {
  9912    var result types.TimerfdSettimeArgs
  9913    var err error
  9914  
  9915    var numArgs uint8
  9916    err = decoder.DecodeUint8(&numArgs)
  9917    if err != nil {
  9918      return types.TimerfdSettimeArgs{}, err
  9919    }
  9920  
  9921    for arg := 0; arg < int(numArgs); arg++ {
  9922      var currArg uint8
  9923      err = decoder.DecodeUint8(&currArg)
  9924      if err != nil {
  9925        return types.TimerfdSettimeArgs{}, err
  9926      }
  9927  
  9928      switch currArg {
  9929      case 0:
  9930        err = decoder.DecodeInt32(&result.Fd)
  9931        if err != nil {
  9932          return types.TimerfdSettimeArgs{}, err
  9933        }
  9934      case 1:
  9935        err = decoder.DecodeInt32(&result.Flags)
  9936        if err != nil {
  9937          return types.TimerfdSettimeArgs{}, err
  9938        }
  9939      case 2:
  9940        var dataNewValue uint64
  9941        err = decoder.DecodeUint64(&dataNewValue)
  9942        if err != nil {
  9943          return types.TimerfdSettimeArgs{}, err
  9944        }
  9945        result.NewValue = uintptr(dataNewValue)
  9946      case 3:
  9947        var dataOldValue uint64
  9948        err = decoder.DecodeUint64(&dataOldValue)
  9949        if err != nil {
  9950          return types.TimerfdSettimeArgs{}, err
  9951        }
  9952        result.OldValue = uintptr(dataOldValue)
  9953      }
  9954    }
  9955    return result, nil
  9956  }
  9957  
  9958  func ParseTimerfdGettimeArgs(decoder *Decoder) (types.TimerfdGettimeArgs, error) {
  9959    var result types.TimerfdGettimeArgs
  9960    var err error
  9961  
  9962    var numArgs uint8
  9963    err = decoder.DecodeUint8(&numArgs)
  9964    if err != nil {
  9965      return types.TimerfdGettimeArgs{}, err
  9966    }
  9967  
  9968    for arg := 0; arg < int(numArgs); arg++ {
  9969      var currArg uint8
  9970      err = decoder.DecodeUint8(&currArg)
  9971      if err != nil {
  9972        return types.TimerfdGettimeArgs{}, err
  9973      }
  9974  
  9975      switch currArg {
  9976      case 0:
  9977        err = decoder.DecodeInt32(&result.Fd)
  9978        if err != nil {
  9979          return types.TimerfdGettimeArgs{}, err
  9980        }
  9981      case 1:
  9982        var dataCurrValue uint64
  9983        err = decoder.DecodeUint64(&dataCurrValue)
  9984        if err != nil {
  9985          return types.TimerfdGettimeArgs{}, err
  9986        }
  9987        result.CurrValue = uintptr(dataCurrValue)
  9988      }
  9989    }
  9990    return result, nil
  9991  }
  9992  
  9993  func ParseAccept4Args(decoder *Decoder) (types.Accept4Args, error) {
  9994    var result types.Accept4Args
  9995    var err error
  9996  
  9997    var numArgs uint8
  9998    err = decoder.DecodeUint8(&numArgs)
  9999    if err != nil {
 10000      return types.Accept4Args{}, err
 10001    }
 10002  
 10003    for arg := 0; arg < int(numArgs); arg++ {
 10004      var currArg uint8
 10005      err = decoder.DecodeUint8(&currArg)
 10006      if err != nil {
 10007        return types.Accept4Args{}, err
 10008      }
 10009  
 10010      switch currArg {
 10011      case 0:
 10012        err = decoder.DecodeInt32(&result.Sockfd)
 10013        if err != nil {
 10014          return types.Accept4Args{}, err
 10015        }
 10016      case 1:
 10017        result.Addr, err = decoder.ReadSockaddrFromBuff()
 10018        if err != nil {
 10019          return types.Accept4Args{}, err
 10020        }
 10021      case 2:
 10022        var dataAddrlen uint64
 10023        err = decoder.DecodeUint64(&dataAddrlen)
 10024        if err != nil {
 10025          return types.Accept4Args{}, err
 10026        }
 10027        result.Addrlen = uintptr(dataAddrlen)
 10028      case 3:
 10029        err = decoder.DecodeInt32(&result.Flags)
 10030        if err != nil {
 10031          return types.Accept4Args{}, err
 10032        }
 10033      }
 10034    }
 10035    return result, nil
 10036  }
 10037  
 10038  func ParseSignalfd4Args(decoder *Decoder) (types.Signalfd4Args, error) {
 10039    var result types.Signalfd4Args
 10040    var err error
 10041  
 10042    var numArgs uint8
 10043    err = decoder.DecodeUint8(&numArgs)
 10044    if err != nil {
 10045      return types.Signalfd4Args{}, err
 10046    }
 10047  
 10048    for arg := 0; arg < int(numArgs); arg++ {
 10049      var currArg uint8
 10050      err = decoder.DecodeUint8(&currArg)
 10051      if err != nil {
 10052        return types.Signalfd4Args{}, err
 10053      }
 10054  
 10055      switch currArg {
 10056      case 0:
 10057        err = decoder.DecodeInt32(&result.Fd)
 10058        if err != nil {
 10059          return types.Signalfd4Args{}, err
 10060        }
 10061      case 1:
 10062        var dataMask uint64
 10063        err = decoder.DecodeUint64(&dataMask)
 10064        if err != nil {
 10065          return types.Signalfd4Args{}, err
 10066        }
 10067        result.Mask = uintptr(dataMask)
 10068      case 2:
 10069        err = decoder.DecodeUint64(&result.Sizemask)
 10070        if err != nil {
 10071          return types.Signalfd4Args{}, err
 10072        }
 10073      case 3:
 10074        err = decoder.DecodeInt32(&result.Flags)
 10075        if err != nil {
 10076          return types.Signalfd4Args{}, err
 10077        }
 10078      }
 10079    }
 10080    return result, nil
 10081  }
 10082  
 10083  func ParseEventfd2Args(decoder *Decoder) (types.Eventfd2Args, error) {
 10084    var result types.Eventfd2Args
 10085    var err error
 10086  
 10087    var numArgs uint8
 10088    err = decoder.DecodeUint8(&numArgs)
 10089    if err != nil {
 10090      return types.Eventfd2Args{}, err
 10091    }
 10092  
 10093    for arg := 0; arg < int(numArgs); arg++ {
 10094      var currArg uint8
 10095      err = decoder.DecodeUint8(&currArg)
 10096      if err != nil {
 10097        return types.Eventfd2Args{}, err
 10098      }
 10099  
 10100      switch currArg {
 10101      case 0:
 10102        err = decoder.DecodeUint32(&result.Initval)
 10103        if err != nil {
 10104          return types.Eventfd2Args{}, err
 10105        }
 10106      case 1:
 10107        err = decoder.DecodeInt32(&result.Flags)
 10108        if err != nil {
 10109          return types.Eventfd2Args{}, err
 10110        }
 10111      }
 10112    }
 10113    return result, nil
 10114  }
 10115  
 10116  func ParseEpollCreate1Args(decoder *Decoder) (types.EpollCreate1Args, error) {
 10117    var result types.EpollCreate1Args
 10118    var err error
 10119  
 10120    var numArgs uint8
 10121    err = decoder.DecodeUint8(&numArgs)
 10122    if err != nil {
 10123      return types.EpollCreate1Args{}, err
 10124    }
 10125  
 10126    for arg := 0; arg < int(numArgs); arg++ {
 10127      var currArg uint8
 10128      err = decoder.DecodeUint8(&currArg)
 10129      if err != nil {
 10130        return types.EpollCreate1Args{}, err
 10131      }
 10132  
 10133      switch currArg {
 10134      case 0:
 10135        err = decoder.DecodeInt32(&result.Flags)
 10136        if err != nil {
 10137          return types.EpollCreate1Args{}, err
 10138        }
 10139      }
 10140    }
 10141    return result, nil
 10142  }
 10143  
 10144  func ParseDup3Args(decoder *Decoder) (types.Dup3Args, error) {
 10145    var result types.Dup3Args
 10146    var err error
 10147  
 10148    var numArgs uint8
 10149    err = decoder.DecodeUint8(&numArgs)
 10150    if err != nil {
 10151      return types.Dup3Args{}, err
 10152    }
 10153  
 10154    for arg := 0; arg < int(numArgs); arg++ {
 10155      var currArg uint8
 10156      err = decoder.DecodeUint8(&currArg)
 10157      if err != nil {
 10158        return types.Dup3Args{}, err
 10159      }
 10160  
 10161      switch currArg {
 10162      case 0:
 10163        err = decoder.DecodeInt32(&result.Oldfd)
 10164        if err != nil {
 10165          return types.Dup3Args{}, err
 10166        }
 10167      case 1:
 10168        err = decoder.DecodeInt32(&result.Newfd)
 10169        if err != nil {
 10170          return types.Dup3Args{}, err
 10171        }
 10172      case 2:
 10173        err = decoder.DecodeInt32(&result.Flags)
 10174        if err != nil {
 10175          return types.Dup3Args{}, err
 10176        }
 10177      }
 10178    }
 10179    return result, nil
 10180  }
 10181  
 10182  func ParsePipe2Args(decoder *Decoder) (types.Pipe2Args, error) {
 10183    var result types.Pipe2Args
 10184    var err error
 10185  
 10186    var numArgs uint8
 10187    err = decoder.DecodeUint8(&numArgs)
 10188    if err != nil {
 10189      return types.Pipe2Args{}, err
 10190    }
 10191  
 10192    for arg := 0; arg < int(numArgs); arg++ {
 10193      var currArg uint8
 10194      err = decoder.DecodeUint8(&currArg)
 10195      if err != nil {
 10196        return types.Pipe2Args{}, err
 10197      }
 10198  
 10199      switch currArg {
 10200      case 0:
 10201        err = decoder.DecodeIntArray(result.Pipefd[:], 2)
 10202        if err != nil {
 10203          return types.Pipe2Args{}, err
 10204        }
 10205      case 1:
 10206        err = decoder.DecodeInt32(&result.Flags)
 10207        if err != nil {
 10208          return types.Pipe2Args{}, err
 10209        }
 10210      }
 10211    }
 10212    return result, nil
 10213  }
 10214  
 10215  func ParseInotifyInit1Args(decoder *Decoder) (types.InotifyInit1Args, error) {
 10216    var result types.InotifyInit1Args
 10217    var err error
 10218  
 10219    var numArgs uint8
 10220    err = decoder.DecodeUint8(&numArgs)
 10221    if err != nil {
 10222      return types.InotifyInit1Args{}, err
 10223    }
 10224  
 10225    for arg := 0; arg < int(numArgs); arg++ {
 10226      var currArg uint8
 10227      err = decoder.DecodeUint8(&currArg)
 10228      if err != nil {
 10229        return types.InotifyInit1Args{}, err
 10230      }
 10231  
 10232      switch currArg {
 10233      case 0:
 10234        err = decoder.DecodeInt32(&result.Flags)
 10235        if err != nil {
 10236          return types.InotifyInit1Args{}, err
 10237        }
 10238      }
 10239    }
 10240    return result, nil
 10241  }
 10242  
 10243  func ParsePreadvArgs(decoder *Decoder) (types.PreadvArgs, error) {
 10244    var result types.PreadvArgs
 10245    var err error
 10246  
 10247    var numArgs uint8
 10248    err = decoder.DecodeUint8(&numArgs)
 10249    if err != nil {
 10250      return types.PreadvArgs{}, err
 10251    }
 10252  
 10253    for arg := 0; arg < int(numArgs); arg++ {
 10254      var currArg uint8
 10255      err = decoder.DecodeUint8(&currArg)
 10256      if err != nil {
 10257        return types.PreadvArgs{}, err
 10258      }
 10259  
 10260      switch currArg {
 10261      case 0:
 10262        err = decoder.DecodeInt32(&result.Fd)
 10263        if err != nil {
 10264          return types.PreadvArgs{}, err
 10265        }
 10266      case 1:
 10267        var dataIov uint64
 10268        err = decoder.DecodeUint64(&dataIov)
 10269        if err != nil {
 10270          return types.PreadvArgs{}, err
 10271        }
 10272        result.Iov = uintptr(dataIov)
 10273      case 2:
 10274        err = decoder.DecodeUint64(&result.Iovcnt)
 10275        if err != nil {
 10276          return types.PreadvArgs{}, err
 10277        }
 10278      case 3:
 10279        err = decoder.DecodeUint64(&result.PosL)
 10280        if err != nil {
 10281          return types.PreadvArgs{}, err
 10282        }
 10283      case 4:
 10284        err = decoder.DecodeUint64(&result.PosH)
 10285        if err != nil {
 10286          return types.PreadvArgs{}, err
 10287        }
 10288      }
 10289    }
 10290    return result, nil
 10291  }
 10292  
 10293  func ParsePwritevArgs(decoder *Decoder) (types.PwritevArgs, error) {
 10294    var result types.PwritevArgs
 10295    var err error
 10296  
 10297    var numArgs uint8
 10298    err = decoder.DecodeUint8(&numArgs)
 10299    if err != nil {
 10300      return types.PwritevArgs{}, err
 10301    }
 10302  
 10303    for arg := 0; arg < int(numArgs); arg++ {
 10304      var currArg uint8
 10305      err = decoder.DecodeUint8(&currArg)
 10306      if err != nil {
 10307        return types.PwritevArgs{}, err
 10308      }
 10309  
 10310      switch currArg {
 10311      case 0:
 10312        err = decoder.DecodeInt32(&result.Fd)
 10313        if err != nil {
 10314          return types.PwritevArgs{}, err
 10315        }
 10316      case 1:
 10317        var dataIov uint64
 10318        err = decoder.DecodeUint64(&dataIov)
 10319        if err != nil {
 10320          return types.PwritevArgs{}, err
 10321        }
 10322        result.Iov = uintptr(dataIov)
 10323      case 2:
 10324        err = decoder.DecodeUint64(&result.Iovcnt)
 10325        if err != nil {
 10326          return types.PwritevArgs{}, err
 10327        }
 10328      case 3:
 10329        err = decoder.DecodeUint64(&result.PosL)
 10330        if err != nil {
 10331          return types.PwritevArgs{}, err
 10332        }
 10333      case 4:
 10334        err = decoder.DecodeUint64(&result.PosH)
 10335        if err != nil {
 10336          return types.PwritevArgs{}, err
 10337        }
 10338      }
 10339    }
 10340    return result, nil
 10341  }
 10342  
 10343  func ParseRtTgsigqueueinfoArgs(decoder *Decoder) (types.RtTgsigqueueinfoArgs, error) {
 10344    var result types.RtTgsigqueueinfoArgs
 10345    var err error
 10346  
 10347    var numArgs uint8
 10348    err = decoder.DecodeUint8(&numArgs)
 10349    if err != nil {
 10350      return types.RtTgsigqueueinfoArgs{}, err
 10351    }
 10352  
 10353    for arg := 0; arg < int(numArgs); arg++ {
 10354      var currArg uint8
 10355      err = decoder.DecodeUint8(&currArg)
 10356      if err != nil {
 10357        return types.RtTgsigqueueinfoArgs{}, err
 10358      }
 10359  
 10360      switch currArg {
 10361      case 0:
 10362        err = decoder.DecodeInt32(&result.Tgid)
 10363        if err != nil {
 10364          return types.RtTgsigqueueinfoArgs{}, err
 10365        }
 10366      case 1:
 10367        err = decoder.DecodeInt32(&result.Tid)
 10368        if err != nil {
 10369          return types.RtTgsigqueueinfoArgs{}, err
 10370        }
 10371      case 2:
 10372        err = decoder.DecodeInt32(&result.Sig)
 10373        if err != nil {
 10374          return types.RtTgsigqueueinfoArgs{}, err
 10375        }
 10376      case 3:
 10377        var dataInfo uint64
 10378        err = decoder.DecodeUint64(&dataInfo)
 10379        if err != nil {
 10380          return types.RtTgsigqueueinfoArgs{}, err
 10381        }
 10382        result.Info = uintptr(dataInfo)
 10383      }
 10384    }
 10385    return result, nil
 10386  }
 10387  
 10388  func ParsePerfEventOpenArgs(decoder *Decoder) (types.PerfEventOpenArgs, error) {
 10389    var result types.PerfEventOpenArgs
 10390    var err error
 10391  
 10392    var numArgs uint8
 10393    err = decoder.DecodeUint8(&numArgs)
 10394    if err != nil {
 10395      return types.PerfEventOpenArgs{}, err
 10396    }
 10397  
 10398    for arg := 0; arg < int(numArgs); arg++ {
 10399      var currArg uint8
 10400      err = decoder.DecodeUint8(&currArg)
 10401      if err != nil {
 10402        return types.PerfEventOpenArgs{}, err
 10403      }
 10404  
 10405      switch currArg {
 10406      case 0:
 10407        var dataAttr uint64
 10408        err = decoder.DecodeUint64(&dataAttr)
 10409        if err != nil {
 10410          return types.PerfEventOpenArgs{}, err
 10411        }
 10412        result.Attr = uintptr(dataAttr)
 10413      case 1:
 10414        err = decoder.DecodeInt32(&result.Pid)
 10415        if err != nil {
 10416          return types.PerfEventOpenArgs{}, err
 10417        }
 10418      case 2:
 10419        err = decoder.DecodeInt32(&result.Cpu)
 10420        if err != nil {
 10421          return types.PerfEventOpenArgs{}, err
 10422        }
 10423      case 3:
 10424        err = decoder.DecodeInt32(&result.GroupFd)
 10425        if err != nil {
 10426          return types.PerfEventOpenArgs{}, err
 10427        }
 10428      case 4:
 10429        err = decoder.DecodeUint64(&result.Flags)
 10430        if err != nil {
 10431          return types.PerfEventOpenArgs{}, err
 10432        }
 10433      }
 10434    }
 10435    return result, nil
 10436  }
 10437  
 10438  func ParseRecvmmsgArgs(decoder *Decoder) (types.RecvmmsgArgs, error) {
 10439    var result types.RecvmmsgArgs
 10440    var err error
 10441  
 10442    var numArgs uint8
 10443    err = decoder.DecodeUint8(&numArgs)
 10444    if err != nil {
 10445      return types.RecvmmsgArgs{}, err
 10446    }
 10447  
 10448    for arg := 0; arg < int(numArgs); arg++ {
 10449      var currArg uint8
 10450      err = decoder.DecodeUint8(&currArg)
 10451      if err != nil {
 10452        return types.RecvmmsgArgs{}, err
 10453      }
 10454  
 10455      switch currArg {
 10456      case 0:
 10457        err = decoder.DecodeInt32(&result.Sockfd)
 10458        if err != nil {
 10459          return types.RecvmmsgArgs{}, err
 10460        }
 10461      case 1:
 10462        var dataMsgvec uint64
 10463        err = decoder.DecodeUint64(&dataMsgvec)
 10464        if err != nil {
 10465          return types.RecvmmsgArgs{}, err
 10466        }
 10467        result.Msgvec = uintptr(dataMsgvec)
 10468      case 2:
 10469        err = decoder.DecodeUint32(&result.Vlen)
 10470        if err != nil {
 10471          return types.RecvmmsgArgs{}, err
 10472        }
 10473      case 3:
 10474        err = decoder.DecodeInt32(&result.Flags)
 10475        if err != nil {
 10476          return types.RecvmmsgArgs{}, err
 10477        }
 10478      case 4:
 10479        result.Timeout, err = decoder.ReadTimespec()
 10480        if err != nil {
 10481          return types.RecvmmsgArgs{}, err
 10482        }
 10483      }
 10484    }
 10485    return result, nil
 10486  }
 10487  
 10488  func ParseFanotifyInitArgs(decoder *Decoder) (types.FanotifyInitArgs, error) {
 10489    var result types.FanotifyInitArgs
 10490    var err error
 10491  
 10492    var numArgs uint8
 10493    err = decoder.DecodeUint8(&numArgs)
 10494    if err != nil {
 10495      return types.FanotifyInitArgs{}, err
 10496    }
 10497  
 10498    for arg := 0; arg < int(numArgs); arg++ {
 10499      var currArg uint8
 10500      err = decoder.DecodeUint8(&currArg)
 10501      if err != nil {
 10502        return types.FanotifyInitArgs{}, err
 10503      }
 10504  
 10505      switch currArg {
 10506      case 0:
 10507        err = decoder.DecodeUint32(&result.Flags)
 10508        if err != nil {
 10509          return types.FanotifyInitArgs{}, err
 10510        }
 10511      case 1:
 10512        err = decoder.DecodeUint32(&result.EventFFlags)
 10513        if err != nil {
 10514          return types.FanotifyInitArgs{}, err
 10515        }
 10516      }
 10517    }
 10518    return result, nil
 10519  }
 10520  
 10521  func ParseFanotifyMarkArgs(decoder *Decoder) (types.FanotifyMarkArgs, error) {
 10522    var result types.FanotifyMarkArgs
 10523    var err error
 10524  
 10525    var numArgs uint8
 10526    err = decoder.DecodeUint8(&numArgs)
 10527    if err != nil {
 10528      return types.FanotifyMarkArgs{}, err
 10529    }
 10530  
 10531    for arg := 0; arg < int(numArgs); arg++ {
 10532      var currArg uint8
 10533      err = decoder.DecodeUint8(&currArg)
 10534      if err != nil {
 10535        return types.FanotifyMarkArgs{}, err
 10536      }
 10537  
 10538      switch currArg {
 10539      case 0:
 10540        err = decoder.DecodeInt32(&result.FanotifyFd)
 10541        if err != nil {
 10542          return types.FanotifyMarkArgs{}, err
 10543        }
 10544      case 1:
 10545        err = decoder.DecodeUint32(&result.Flags)
 10546        if err != nil {
 10547          return types.FanotifyMarkArgs{}, err
 10548        }
 10549      case 2:
 10550        err = decoder.DecodeUint64(&result.Mask)
 10551        if err != nil {
 10552          return types.FanotifyMarkArgs{}, err
 10553        }
 10554      case 3:
 10555        err = decoder.DecodeInt32(&result.Dirfd)
 10556        if err != nil {
 10557          return types.FanotifyMarkArgs{}, err
 10558        }
 10559      case 4:
 10560        result.Pathname, err = decoder.ReadStringFromBuff()
 10561        if err != nil {
 10562          return types.FanotifyMarkArgs{}, err
 10563        }
 10564      }
 10565    }
 10566    return result, nil
 10567  }
 10568  
 10569  func ParsePrlimit64Args(decoder *Decoder) (types.Prlimit64Args, error) {
 10570    var result types.Prlimit64Args
 10571    var err error
 10572  
 10573    var numArgs uint8
 10574    err = decoder.DecodeUint8(&numArgs)
 10575    if err != nil {
 10576      return types.Prlimit64Args{}, err
 10577    }
 10578  
 10579    for arg := 0; arg < int(numArgs); arg++ {
 10580      var currArg uint8
 10581      err = decoder.DecodeUint8(&currArg)
 10582      if err != nil {
 10583        return types.Prlimit64Args{}, err
 10584      }
 10585  
 10586      switch currArg {
 10587      case 0:
 10588        err = decoder.DecodeInt32(&result.Pid)
 10589        if err != nil {
 10590          return types.Prlimit64Args{}, err
 10591        }
 10592      case 1:
 10593        err = decoder.DecodeInt32(&result.Resource)
 10594        if err != nil {
 10595          return types.Prlimit64Args{}, err
 10596        }
 10597      case 2:
 10598        var dataNewLimit uint64
 10599        err = decoder.DecodeUint64(&dataNewLimit)
 10600        if err != nil {
 10601          return types.Prlimit64Args{}, err
 10602        }
 10603        result.NewLimit = uintptr(dataNewLimit)
 10604      case 3:
 10605        var dataOldLimit uint64
 10606        err = decoder.DecodeUint64(&dataOldLimit)
 10607        if err != nil {
 10608          return types.Prlimit64Args{}, err
 10609        }
 10610        result.OldLimit = uintptr(dataOldLimit)
 10611      }
 10612    }
 10613    return result, nil
 10614  }
 10615  
 10616  func ParseNameToHandleAtArgs(decoder *Decoder) (types.NameToHandleAtArgs, error) {
 10617    var result types.NameToHandleAtArgs
 10618    var err error
 10619  
 10620    var numArgs uint8
 10621    err = decoder.DecodeUint8(&numArgs)
 10622    if err != nil {
 10623      return types.NameToHandleAtArgs{}, err
 10624    }
 10625  
 10626    for arg := 0; arg < int(numArgs); arg++ {
 10627      var currArg uint8
 10628      err = decoder.DecodeUint8(&currArg)
 10629      if err != nil {
 10630        return types.NameToHandleAtArgs{}, err
 10631      }
 10632  
 10633      switch currArg {
 10634      case 0:
 10635        err = decoder.DecodeInt32(&result.Dirfd)
 10636        if err != nil {
 10637          return types.NameToHandleAtArgs{}, err
 10638        }
 10639      case 1:
 10640        result.Pathname, err = decoder.ReadStringFromBuff()
 10641        if err != nil {
 10642          return types.NameToHandleAtArgs{}, err
 10643        }
 10644      case 2:
 10645        var dataHandle uint64
 10646        err = decoder.DecodeUint64(&dataHandle)
 10647        if err != nil {
 10648          return types.NameToHandleAtArgs{}, err
 10649        }
 10650        result.Handle = uintptr(dataHandle)
 10651      case 3:
 10652        var dataMountId uint64
 10653        err = decoder.DecodeUint64(&dataMountId)
 10654        if err != nil {
 10655          return types.NameToHandleAtArgs{}, err
 10656        }
 10657        result.MountId = uintptr(dataMountId)
 10658      case 4:
 10659        err = decoder.DecodeInt32(&result.Flags)
 10660        if err != nil {
 10661          return types.NameToHandleAtArgs{}, err
 10662        }
 10663      }
 10664    }
 10665    return result, nil
 10666  }
 10667  
 10668  func ParseOpenByHandleAtArgs(decoder *Decoder) (types.OpenByHandleAtArgs, error) {
 10669    var result types.OpenByHandleAtArgs
 10670    var err error
 10671  
 10672    var numArgs uint8
 10673    err = decoder.DecodeUint8(&numArgs)
 10674    if err != nil {
 10675      return types.OpenByHandleAtArgs{}, err
 10676    }
 10677  
 10678    for arg := 0; arg < int(numArgs); arg++ {
 10679      var currArg uint8
 10680      err = decoder.DecodeUint8(&currArg)
 10681      if err != nil {
 10682        return types.OpenByHandleAtArgs{}, err
 10683      }
 10684  
 10685      switch currArg {
 10686      case 0:
 10687        err = decoder.DecodeInt32(&result.MountFd)
 10688        if err != nil {
 10689          return types.OpenByHandleAtArgs{}, err
 10690        }
 10691      case 1:
 10692        var dataHandle uint64
 10693        err = decoder.DecodeUint64(&dataHandle)
 10694        if err != nil {
 10695          return types.OpenByHandleAtArgs{}, err
 10696        }
 10697        result.Handle = uintptr(dataHandle)
 10698      case 2:
 10699        err = decoder.DecodeInt32(&result.Flags)
 10700        if err != nil {
 10701          return types.OpenByHandleAtArgs{}, err
 10702        }
 10703      }
 10704    }
 10705    return result, nil
 10706  }
 10707  
 10708  func ParseClockAdjtimeArgs(decoder *Decoder) (types.ClockAdjtimeArgs, error) {
 10709    var result types.ClockAdjtimeArgs
 10710    var err error
 10711  
 10712    var numArgs uint8
 10713    err = decoder.DecodeUint8(&numArgs)
 10714    if err != nil {
 10715      return types.ClockAdjtimeArgs{}, err
 10716    }
 10717  
 10718    for arg := 0; arg < int(numArgs); arg++ {
 10719      var currArg uint8
 10720      err = decoder.DecodeUint8(&currArg)
 10721      if err != nil {
 10722        return types.ClockAdjtimeArgs{}, err
 10723      }
 10724  
 10725      switch currArg {
 10726      case 0:
 10727        err = decoder.DecodeInt32(&result.ClkId)
 10728        if err != nil {
 10729          return types.ClockAdjtimeArgs{}, err
 10730        }
 10731      case 1:
 10732        var dataBuf uint64
 10733        err = decoder.DecodeUint64(&dataBuf)
 10734        if err != nil {
 10735          return types.ClockAdjtimeArgs{}, err
 10736        }
 10737        result.Buf = uintptr(dataBuf)
 10738      }
 10739    }
 10740    return result, nil
 10741  }
 10742  
 10743  func ParseSyncfsArgs(decoder *Decoder) (types.SyncfsArgs, error) {
 10744    var result types.SyncfsArgs
 10745    var err error
 10746  
 10747    var numArgs uint8
 10748    err = decoder.DecodeUint8(&numArgs)
 10749    if err != nil {
 10750      return types.SyncfsArgs{}, err
 10751    }
 10752  
 10753    for arg := 0; arg < int(numArgs); arg++ {
 10754      var currArg uint8
 10755      err = decoder.DecodeUint8(&currArg)
 10756      if err != nil {
 10757        return types.SyncfsArgs{}, err
 10758      }
 10759  
 10760      switch currArg {
 10761      case 0:
 10762        err = decoder.DecodeInt32(&result.Fd)
 10763        if err != nil {
 10764          return types.SyncfsArgs{}, err
 10765        }
 10766      }
 10767    }
 10768    return result, nil
 10769  }
 10770  
 10771  func ParseSendmmsgArgs(decoder *Decoder) (types.SendmmsgArgs, error) {
 10772    var result types.SendmmsgArgs
 10773    var err error
 10774  
 10775    var numArgs uint8
 10776    err = decoder.DecodeUint8(&numArgs)
 10777    if err != nil {
 10778      return types.SendmmsgArgs{}, err
 10779    }
 10780  
 10781    for arg := 0; arg < int(numArgs); arg++ {
 10782      var currArg uint8
 10783      err = decoder.DecodeUint8(&currArg)
 10784      if err != nil {
 10785        return types.SendmmsgArgs{}, err
 10786      }
 10787  
 10788      switch currArg {
 10789      case 0:
 10790        err = decoder.DecodeInt32(&result.Sockfd)
 10791        if err != nil {
 10792          return types.SendmmsgArgs{}, err
 10793        }
 10794      case 1:
 10795        var dataMsgvec uint64
 10796        err = decoder.DecodeUint64(&dataMsgvec)
 10797        if err != nil {
 10798          return types.SendmmsgArgs{}, err
 10799        }
 10800        result.Msgvec = uintptr(dataMsgvec)
 10801      case 2:
 10802        err = decoder.DecodeUint32(&result.Vlen)
 10803        if err != nil {
 10804          return types.SendmmsgArgs{}, err
 10805        }
 10806      case 3:
 10807        err = decoder.DecodeInt32(&result.Flags)
 10808        if err != nil {
 10809          return types.SendmmsgArgs{}, err
 10810        }
 10811      }
 10812    }
 10813    return result, nil
 10814  }
 10815  
 10816  func ParseSetnsArgs(decoder *Decoder) (types.SetnsArgs, error) {
 10817    var result types.SetnsArgs
 10818    var err error
 10819  
 10820    var numArgs uint8
 10821    err = decoder.DecodeUint8(&numArgs)
 10822    if err != nil {
 10823      return types.SetnsArgs{}, err
 10824    }
 10825  
 10826    for arg := 0; arg < int(numArgs); arg++ {
 10827      var currArg uint8
 10828      err = decoder.DecodeUint8(&currArg)
 10829      if err != nil {
 10830        return types.SetnsArgs{}, err
 10831      }
 10832  
 10833      switch currArg {
 10834      case 0:
 10835        err = decoder.DecodeInt32(&result.Fd)
 10836        if err != nil {
 10837          return types.SetnsArgs{}, err
 10838        }
 10839      case 1:
 10840        err = decoder.DecodeInt32(&result.Nstype)
 10841        if err != nil {
 10842          return types.SetnsArgs{}, err
 10843        }
 10844      }
 10845    }
 10846    return result, nil
 10847  }
 10848  
 10849  func ParseGetcpuArgs(decoder *Decoder) (types.GetcpuArgs, error) {
 10850    var result types.GetcpuArgs
 10851    var err error
 10852  
 10853    var numArgs uint8
 10854    err = decoder.DecodeUint8(&numArgs)
 10855    if err != nil {
 10856      return types.GetcpuArgs{}, err
 10857    }
 10858  
 10859    for arg := 0; arg < int(numArgs); arg++ {
 10860      var currArg uint8
 10861      err = decoder.DecodeUint8(&currArg)
 10862      if err != nil {
 10863        return types.GetcpuArgs{}, err
 10864      }
 10865  
 10866      switch currArg {
 10867      case 0:
 10868        var dataCpu uint64
 10869        err = decoder.DecodeUint64(&dataCpu)
 10870        if err != nil {
 10871          return types.GetcpuArgs{}, err
 10872        }
 10873        result.Cpu = uintptr(dataCpu)
 10874      case 1:
 10875        var dataNode uint64
 10876        err = decoder.DecodeUint64(&dataNode)
 10877        if err != nil {
 10878          return types.GetcpuArgs{}, err
 10879        }
 10880        result.Node = uintptr(dataNode)
 10881      case 2:
 10882        var dataTcache uint64
 10883        err = decoder.DecodeUint64(&dataTcache)
 10884        if err != nil {
 10885          return types.GetcpuArgs{}, err
 10886        }
 10887        result.Tcache = uintptr(dataTcache)
 10888      }
 10889    }
 10890    return result, nil
 10891  }
 10892  
 10893  func ParseProcessVmReadvArgs(decoder *Decoder) (types.ProcessVmReadvArgs, error) {
 10894    var result types.ProcessVmReadvArgs
 10895    var err error
 10896  
 10897    var numArgs uint8
 10898    err = decoder.DecodeUint8(&numArgs)
 10899    if err != nil {
 10900      return types.ProcessVmReadvArgs{}, err
 10901    }
 10902  
 10903    for arg := 0; arg < int(numArgs); arg++ {
 10904      var currArg uint8
 10905      err = decoder.DecodeUint8(&currArg)
 10906      if err != nil {
 10907        return types.ProcessVmReadvArgs{}, err
 10908      }
 10909  
 10910      switch currArg {
 10911      case 0:
 10912        err = decoder.DecodeInt32(&result.Pid)
 10913        if err != nil {
 10914          return types.ProcessVmReadvArgs{}, err
 10915        }
 10916      case 1:
 10917        var dataLocalIov uint64
 10918        err = decoder.DecodeUint64(&dataLocalIov)
 10919        if err != nil {
 10920          return types.ProcessVmReadvArgs{}, err
 10921        }
 10922        result.LocalIov = uintptr(dataLocalIov)
 10923      case 2:
 10924        err = decoder.DecodeUint64(&result.Liovcnt)
 10925        if err != nil {
 10926          return types.ProcessVmReadvArgs{}, err
 10927        }
 10928      case 3:
 10929        var dataRemoteIov uint64
 10930        err = decoder.DecodeUint64(&dataRemoteIov)
 10931        if err != nil {
 10932          return types.ProcessVmReadvArgs{}, err
 10933        }
 10934        result.RemoteIov = uintptr(dataRemoteIov)
 10935      case 4:
 10936        err = decoder.DecodeUint64(&result.Riovcnt)
 10937        if err != nil {
 10938          return types.ProcessVmReadvArgs{}, err
 10939        }
 10940      case 5:
 10941        err = decoder.DecodeUint64(&result.Flags)
 10942        if err != nil {
 10943          return types.ProcessVmReadvArgs{}, err
 10944        }
 10945      }
 10946    }
 10947    return result, nil
 10948  }
 10949  
 10950  func ParseProcessVmWritevArgs(decoder *Decoder) (types.ProcessVmWritevArgs, error) {
 10951    var result types.ProcessVmWritevArgs
 10952    var err error
 10953  
 10954    var numArgs uint8
 10955    err = decoder.DecodeUint8(&numArgs)
 10956    if err != nil {
 10957      return types.ProcessVmWritevArgs{}, err
 10958    }
 10959  
 10960    for arg := 0; arg < int(numArgs); arg++ {
 10961      var currArg uint8
 10962      err = decoder.DecodeUint8(&currArg)
 10963      if err != nil {
 10964        return types.ProcessVmWritevArgs{}, err
 10965      }
 10966  
 10967      switch currArg {
 10968      case 0:
 10969        err = decoder.DecodeInt32(&result.Pid)
 10970        if err != nil {
 10971          return types.ProcessVmWritevArgs{}, err
 10972        }
 10973      case 1:
 10974        var dataLocalIov uint64
 10975        err = decoder.DecodeUint64(&dataLocalIov)
 10976        if err != nil {
 10977          return types.ProcessVmWritevArgs{}, err
 10978        }
 10979        result.LocalIov = uintptr(dataLocalIov)
 10980      case 2:
 10981        err = decoder.DecodeUint64(&result.Liovcnt)
 10982        if err != nil {
 10983          return types.ProcessVmWritevArgs{}, err
 10984        }
 10985      case 3:
 10986        var dataRemoteIov uint64
 10987        err = decoder.DecodeUint64(&dataRemoteIov)
 10988        if err != nil {
 10989          return types.ProcessVmWritevArgs{}, err
 10990        }
 10991        result.RemoteIov = uintptr(dataRemoteIov)
 10992      case 4:
 10993        err = decoder.DecodeUint64(&result.Riovcnt)
 10994        if err != nil {
 10995          return types.ProcessVmWritevArgs{}, err
 10996        }
 10997      case 5:
 10998        err = decoder.DecodeUint64(&result.Flags)
 10999        if err != nil {
 11000          return types.ProcessVmWritevArgs{}, err
 11001        }
 11002      }
 11003    }
 11004    return result, nil
 11005  }
 11006  
 11007  func ParseKcmpArgs(decoder *Decoder) (types.KcmpArgs, error) {
 11008    var result types.KcmpArgs
 11009    var err error
 11010  
 11011    var numArgs uint8
 11012    err = decoder.DecodeUint8(&numArgs)
 11013    if err != nil {
 11014      return types.KcmpArgs{}, err
 11015    }
 11016  
 11017    for arg := 0; arg < int(numArgs); arg++ {
 11018      var currArg uint8
 11019      err = decoder.DecodeUint8(&currArg)
 11020      if err != nil {
 11021        return types.KcmpArgs{}, err
 11022      }
 11023  
 11024      switch currArg {
 11025      case 0:
 11026        err = decoder.DecodeInt32(&result.Pid1)
 11027        if err != nil {
 11028          return types.KcmpArgs{}, err
 11029        }
 11030      case 1:
 11031        err = decoder.DecodeInt32(&result.Pid2)
 11032        if err != nil {
 11033          return types.KcmpArgs{}, err
 11034        }
 11035      case 2:
 11036        err = decoder.DecodeInt32(&result.Type)
 11037        if err != nil {
 11038          return types.KcmpArgs{}, err
 11039        }
 11040      case 3:
 11041        err = decoder.DecodeUint64(&result.Idx1)
 11042        if err != nil {
 11043          return types.KcmpArgs{}, err
 11044        }
 11045      case 4:
 11046        err = decoder.DecodeUint64(&result.Idx2)
 11047        if err != nil {
 11048          return types.KcmpArgs{}, err
 11049        }
 11050      }
 11051    }
 11052    return result, nil
 11053  }
 11054  
 11055  func ParseFinitModuleArgs(decoder *Decoder) (types.FinitModuleArgs, error) {
 11056    var result types.FinitModuleArgs
 11057    var err error
 11058  
 11059    var numArgs uint8
 11060    err = decoder.DecodeUint8(&numArgs)
 11061    if err != nil {
 11062      return types.FinitModuleArgs{}, err
 11063    }
 11064  
 11065    for arg := 0; arg < int(numArgs); arg++ {
 11066      var currArg uint8
 11067      err = decoder.DecodeUint8(&currArg)
 11068      if err != nil {
 11069        return types.FinitModuleArgs{}, err
 11070      }
 11071  
 11072      switch currArg {
 11073      case 0:
 11074        err = decoder.DecodeInt32(&result.Fd)
 11075        if err != nil {
 11076          return types.FinitModuleArgs{}, err
 11077        }
 11078      case 1:
 11079        result.ParamValues, err = decoder.ReadStringFromBuff()
 11080        if err != nil {
 11081          return types.FinitModuleArgs{}, err
 11082        }
 11083      case 2:
 11084        err = decoder.DecodeInt32(&result.Flags)
 11085        if err != nil {
 11086          return types.FinitModuleArgs{}, err
 11087        }
 11088      }
 11089    }
 11090    return result, nil
 11091  }
 11092  
 11093  func ParseSchedSetattrArgs(decoder *Decoder) (types.SchedSetattrArgs, error) {
 11094    var result types.SchedSetattrArgs
 11095    var err error
 11096  
 11097    var numArgs uint8
 11098    err = decoder.DecodeUint8(&numArgs)
 11099    if err != nil {
 11100      return types.SchedSetattrArgs{}, err
 11101    }
 11102  
 11103    for arg := 0; arg < int(numArgs); arg++ {
 11104      var currArg uint8
 11105      err = decoder.DecodeUint8(&currArg)
 11106      if err != nil {
 11107        return types.SchedSetattrArgs{}, err
 11108      }
 11109  
 11110      switch currArg {
 11111      case 0:
 11112        err = decoder.DecodeInt32(&result.Pid)
 11113        if err != nil {
 11114          return types.SchedSetattrArgs{}, err
 11115        }
 11116      case 1:
 11117        var dataAttr uint64
 11118        err = decoder.DecodeUint64(&dataAttr)
 11119        if err != nil {
 11120          return types.SchedSetattrArgs{}, err
 11121        }
 11122        result.Attr = uintptr(dataAttr)
 11123      case 2:
 11124        err = decoder.DecodeUint32(&result.Flags)
 11125        if err != nil {
 11126          return types.SchedSetattrArgs{}, err
 11127        }
 11128      }
 11129    }
 11130    return result, nil
 11131  }
 11132  
 11133  func ParseSchedGetattrArgs(decoder *Decoder) (types.SchedGetattrArgs, error) {
 11134    var result types.SchedGetattrArgs
 11135    var err error
 11136  
 11137    var numArgs uint8
 11138    err = decoder.DecodeUint8(&numArgs)
 11139    if err != nil {
 11140      return types.SchedGetattrArgs{}, err
 11141    }
 11142  
 11143    for arg := 0; arg < int(numArgs); arg++ {
 11144      var currArg uint8
 11145      err = decoder.DecodeUint8(&currArg)
 11146      if err != nil {
 11147        return types.SchedGetattrArgs{}, err
 11148      }
 11149  
 11150      switch currArg {
 11151      case 0:
 11152        err = decoder.DecodeInt32(&result.Pid)
 11153        if err != nil {
 11154          return types.SchedGetattrArgs{}, err
 11155        }
 11156      case 1:
 11157        var dataAttr uint64
 11158        err = decoder.DecodeUint64(&dataAttr)
 11159        if err != nil {
 11160          return types.SchedGetattrArgs{}, err
 11161        }
 11162        result.Attr = uintptr(dataAttr)
 11163      case 2:
 11164        err = decoder.DecodeUint32(&result.Size)
 11165        if err != nil {
 11166          return types.SchedGetattrArgs{}, err
 11167        }
 11168      case 3:
 11169        err = decoder.DecodeUint32(&result.Flags)
 11170        if err != nil {
 11171          return types.SchedGetattrArgs{}, err
 11172        }
 11173      }
 11174    }
 11175    return result, nil
 11176  }
 11177  
 11178  func ParseRenameat2Args(decoder *Decoder) (types.Renameat2Args, error) {
 11179    var result types.Renameat2Args
 11180    var err error
 11181  
 11182    var numArgs uint8
 11183    err = decoder.DecodeUint8(&numArgs)
 11184    if err != nil {
 11185      return types.Renameat2Args{}, err
 11186    }
 11187  
 11188    for arg := 0; arg < int(numArgs); arg++ {
 11189      var currArg uint8
 11190      err = decoder.DecodeUint8(&currArg)
 11191      if err != nil {
 11192        return types.Renameat2Args{}, err
 11193      }
 11194  
 11195      switch currArg {
 11196      case 0:
 11197        err = decoder.DecodeInt32(&result.Olddirfd)
 11198        if err != nil {
 11199          return types.Renameat2Args{}, err
 11200        }
 11201      case 1:
 11202        result.Oldpath, err = decoder.ReadStringFromBuff()
 11203        if err != nil {
 11204          return types.Renameat2Args{}, err
 11205        }
 11206      case 2:
 11207        err = decoder.DecodeInt32(&result.Newdirfd)
 11208        if err != nil {
 11209          return types.Renameat2Args{}, err
 11210        }
 11211      case 3:
 11212        result.Newpath, err = decoder.ReadStringFromBuff()
 11213        if err != nil {
 11214          return types.Renameat2Args{}, err
 11215        }
 11216      case 4:
 11217        err = decoder.DecodeUint32(&result.Flags)
 11218        if err != nil {
 11219          return types.Renameat2Args{}, err
 11220        }
 11221      }
 11222    }
 11223    return result, nil
 11224  }
 11225  
 11226  func ParseSeccompArgs(decoder *Decoder) (types.SeccompArgs, error) {
 11227    var result types.SeccompArgs
 11228    var err error
 11229  
 11230    var numArgs uint8
 11231    err = decoder.DecodeUint8(&numArgs)
 11232    if err != nil {
 11233      return types.SeccompArgs{}, err
 11234    }
 11235  
 11236    for arg := 0; arg < int(numArgs); arg++ {
 11237      var currArg uint8
 11238      err = decoder.DecodeUint8(&currArg)
 11239      if err != nil {
 11240        return types.SeccompArgs{}, err
 11241      }
 11242  
 11243      switch currArg {
 11244      case 0:
 11245        err = decoder.DecodeUint32(&result.Operation)
 11246        if err != nil {
 11247          return types.SeccompArgs{}, err
 11248        }
 11249      case 1:
 11250        err = decoder.DecodeUint32(&result.Flags)
 11251        if err != nil {
 11252          return types.SeccompArgs{}, err
 11253        }
 11254      case 2:
 11255        var dataArgs uint64
 11256        err = decoder.DecodeUint64(&dataArgs)
 11257        if err != nil {
 11258          return types.SeccompArgs{}, err
 11259        }
 11260        result.Args = uintptr(dataArgs)
 11261      }
 11262    }
 11263    return result, nil
 11264  }
 11265  
 11266  func ParseGetrandomArgs(decoder *Decoder) (types.GetrandomArgs, error) {
 11267    var result types.GetrandomArgs
 11268    var err error
 11269  
 11270    var numArgs uint8
 11271    err = decoder.DecodeUint8(&numArgs)
 11272    if err != nil {
 11273      return types.GetrandomArgs{}, err
 11274    }
 11275  
 11276    for arg := 0; arg < int(numArgs); arg++ {
 11277      var currArg uint8
 11278      err = decoder.DecodeUint8(&currArg)
 11279      if err != nil {
 11280        return types.GetrandomArgs{}, err
 11281      }
 11282  
 11283      switch currArg {
 11284      case 0:
 11285        var dataBuf uint64
 11286        err = decoder.DecodeUint64(&dataBuf)
 11287        if err != nil {
 11288          return types.GetrandomArgs{}, err
 11289        }
 11290        result.Buf = uintptr(dataBuf)
 11291      case 1:
 11292        err = decoder.DecodeUint64(&result.Buflen)
 11293        if err != nil {
 11294          return types.GetrandomArgs{}, err
 11295        }
 11296      case 2:
 11297        err = decoder.DecodeUint32(&result.Flags)
 11298        if err != nil {
 11299          return types.GetrandomArgs{}, err
 11300        }
 11301      }
 11302    }
 11303    return result, nil
 11304  }
 11305  
 11306  func ParseMemfdCreateArgs(decoder *Decoder) (types.MemfdCreateArgs, error) {
 11307    var result types.MemfdCreateArgs
 11308    var err error
 11309  
 11310    var numArgs uint8
 11311    err = decoder.DecodeUint8(&numArgs)
 11312    if err != nil {
 11313      return types.MemfdCreateArgs{}, err
 11314    }
 11315  
 11316    for arg := 0; arg < int(numArgs); arg++ {
 11317      var currArg uint8
 11318      err = decoder.DecodeUint8(&currArg)
 11319      if err != nil {
 11320        return types.MemfdCreateArgs{}, err
 11321      }
 11322  
 11323      switch currArg {
 11324      case 0:
 11325        result.Name, err = decoder.ReadStringFromBuff()
 11326        if err != nil {
 11327          return types.MemfdCreateArgs{}, err
 11328        }
 11329      case 1:
 11330        err = decoder.DecodeUint32(&result.Flags)
 11331        if err != nil {
 11332          return types.MemfdCreateArgs{}, err
 11333        }
 11334      }
 11335    }
 11336    return result, nil
 11337  }
 11338  
 11339  func ParseKexecFileLoadArgs(decoder *Decoder) (types.KexecFileLoadArgs, error) {
 11340    var result types.KexecFileLoadArgs
 11341    var err error
 11342  
 11343    var numArgs uint8
 11344    err = decoder.DecodeUint8(&numArgs)
 11345    if err != nil {
 11346      return types.KexecFileLoadArgs{}, err
 11347    }
 11348  
 11349    for arg := 0; arg < int(numArgs); arg++ {
 11350      var currArg uint8
 11351      err = decoder.DecodeUint8(&currArg)
 11352      if err != nil {
 11353        return types.KexecFileLoadArgs{}, err
 11354      }
 11355  
 11356      switch currArg {
 11357      case 0:
 11358        err = decoder.DecodeInt32(&result.KernelFd)
 11359        if err != nil {
 11360          return types.KexecFileLoadArgs{}, err
 11361        }
 11362      case 1:
 11363        err = decoder.DecodeInt32(&result.InitrdFd)
 11364        if err != nil {
 11365          return types.KexecFileLoadArgs{}, err
 11366        }
 11367      case 2:
 11368        err = decoder.DecodeUint64(&result.CmdlineLen)
 11369        if err != nil {
 11370          return types.KexecFileLoadArgs{}, err
 11371        }
 11372      case 3:
 11373        result.Cmdline, err = decoder.ReadStringFromBuff()
 11374        if err != nil {
 11375          return types.KexecFileLoadArgs{}, err
 11376        }
 11377      case 4:
 11378        err = decoder.DecodeUint64(&result.Flags)
 11379        if err != nil {
 11380          return types.KexecFileLoadArgs{}, err
 11381        }
 11382      }
 11383    }
 11384    return result, nil
 11385  }
 11386  
 11387  func ParseBpfArgs(decoder *Decoder) (types.BpfArgs, error) {
 11388    var result types.BpfArgs
 11389    var err error
 11390  
 11391    var numArgs uint8
 11392    err = decoder.DecodeUint8(&numArgs)
 11393    if err != nil {
 11394      return types.BpfArgs{}, err
 11395    }
 11396  
 11397    for arg := 0; arg < int(numArgs); arg++ {
 11398      var currArg uint8
 11399      err = decoder.DecodeUint8(&currArg)
 11400      if err != nil {
 11401        return types.BpfArgs{}, err
 11402      }
 11403  
 11404      switch currArg {
 11405      case 0:
 11406        err = decoder.DecodeInt32(&result.Cmd)
 11407        if err != nil {
 11408          return types.BpfArgs{}, err
 11409        }
 11410      case 1:
 11411        var dataAttr uint64
 11412        err = decoder.DecodeUint64(&dataAttr)
 11413        if err != nil {
 11414          return types.BpfArgs{}, err
 11415        }
 11416        result.Attr = uintptr(dataAttr)
 11417      case 2:
 11418        err = decoder.DecodeUint32(&result.Size)
 11419        if err != nil {
 11420          return types.BpfArgs{}, err
 11421        }
 11422      }
 11423    }
 11424    return result, nil
 11425  }
 11426  
 11427  func ParseExecveatArgs(decoder *Decoder) (types.ExecveatArgs, error) {
 11428    var result types.ExecveatArgs
 11429    var err error
 11430  
 11431    var numArgs uint8
 11432    err = decoder.DecodeUint8(&numArgs)
 11433    if err != nil {
 11434      return types.ExecveatArgs{}, err
 11435    }
 11436  
 11437    for arg := 0; arg < int(numArgs); arg++ {
 11438      var currArg uint8
 11439      err = decoder.DecodeUint8(&currArg)
 11440      if err != nil {
 11441        return types.ExecveatArgs{}, err
 11442      }
 11443  
 11444      switch currArg {
 11445      case 0:
 11446        err = decoder.DecodeInt32(&result.Dirfd)
 11447        if err != nil {
 11448          return types.ExecveatArgs{}, err
 11449        }
 11450      case 1:
 11451        result.Pathname, err = decoder.ReadStringFromBuff()
 11452        if err != nil {
 11453          return types.ExecveatArgs{}, err
 11454        }
 11455      case 2:
 11456        result.Argv, err = decoder.ReadStringArrayFromBuff()
 11457        if err != nil {
 11458          return types.ExecveatArgs{}, err
 11459        }
 11460      case 3:
 11461        result.Envp, err = decoder.ReadStringArrayFromBuff()
 11462        if err != nil {
 11463          return types.ExecveatArgs{}, err
 11464        }
 11465      case 4:
 11466        err = decoder.DecodeInt32(&result.Flags)
 11467        if err != nil {
 11468          return types.ExecveatArgs{}, err
 11469        }
 11470      }
 11471    }
 11472    return result, nil
 11473  }
 11474  
 11475  func ParseUserfaultfdArgs(decoder *Decoder) (types.UserfaultfdArgs, error) {
 11476    var result types.UserfaultfdArgs
 11477    var err error
 11478  
 11479    var numArgs uint8
 11480    err = decoder.DecodeUint8(&numArgs)
 11481    if err != nil {
 11482      return types.UserfaultfdArgs{}, err
 11483    }
 11484  
 11485    for arg := 0; arg < int(numArgs); arg++ {
 11486      var currArg uint8
 11487      err = decoder.DecodeUint8(&currArg)
 11488      if err != nil {
 11489        return types.UserfaultfdArgs{}, err
 11490      }
 11491  
 11492      switch currArg {
 11493      case 0:
 11494        err = decoder.DecodeInt32(&result.Flags)
 11495        if err != nil {
 11496          return types.UserfaultfdArgs{}, err
 11497        }
 11498      }
 11499    }
 11500    return result, nil
 11501  }
 11502  
 11503  func ParseMembarrierArgs(decoder *Decoder) (types.MembarrierArgs, error) {
 11504    var result types.MembarrierArgs
 11505    var err error
 11506  
 11507    var numArgs uint8
 11508    err = decoder.DecodeUint8(&numArgs)
 11509    if err != nil {
 11510      return types.MembarrierArgs{}, err
 11511    }
 11512  
 11513    for arg := 0; arg < int(numArgs); arg++ {
 11514      var currArg uint8
 11515      err = decoder.DecodeUint8(&currArg)
 11516      if err != nil {
 11517        return types.MembarrierArgs{}, err
 11518      }
 11519  
 11520      switch currArg {
 11521      case 0:
 11522        err = decoder.DecodeInt32(&result.Cmd)
 11523        if err != nil {
 11524          return types.MembarrierArgs{}, err
 11525        }
 11526      case 1:
 11527        err = decoder.DecodeInt32(&result.Flags)
 11528        if err != nil {
 11529          return types.MembarrierArgs{}, err
 11530        }
 11531      }
 11532    }
 11533    return result, nil
 11534  }
 11535  
 11536  func ParseMlock2Args(decoder *Decoder) (types.Mlock2Args, error) {
 11537    var result types.Mlock2Args
 11538    var err error
 11539  
 11540    var numArgs uint8
 11541    err = decoder.DecodeUint8(&numArgs)
 11542    if err != nil {
 11543      return types.Mlock2Args{}, err
 11544    }
 11545  
 11546    for arg := 0; arg < int(numArgs); arg++ {
 11547      var currArg uint8
 11548      err = decoder.DecodeUint8(&currArg)
 11549      if err != nil {
 11550        return types.Mlock2Args{}, err
 11551      }
 11552  
 11553      switch currArg {
 11554      case 0:
 11555        var dataAddr uint64
 11556        err = decoder.DecodeUint64(&dataAddr)
 11557        if err != nil {
 11558          return types.Mlock2Args{}, err
 11559        }
 11560        result.Addr = uintptr(dataAddr)
 11561      case 1:
 11562        err = decoder.DecodeUint64(&result.Len)
 11563        if err != nil {
 11564          return types.Mlock2Args{}, err
 11565        }
 11566      case 2:
 11567        err = decoder.DecodeInt32(&result.Flags)
 11568        if err != nil {
 11569          return types.Mlock2Args{}, err
 11570        }
 11571      }
 11572    }
 11573    return result, nil
 11574  }
 11575  
 11576  func ParseCopyFileRangeArgs(decoder *Decoder) (types.CopyFileRangeArgs, error) {
 11577    var result types.CopyFileRangeArgs
 11578    var err error
 11579  
 11580    var numArgs uint8
 11581    err = decoder.DecodeUint8(&numArgs)
 11582    if err != nil {
 11583      return types.CopyFileRangeArgs{}, err
 11584    }
 11585  
 11586    for arg := 0; arg < int(numArgs); arg++ {
 11587      var currArg uint8
 11588      err = decoder.DecodeUint8(&currArg)
 11589      if err != nil {
 11590        return types.CopyFileRangeArgs{}, err
 11591      }
 11592  
 11593      switch currArg {
 11594      case 0:
 11595        err = decoder.DecodeInt32(&result.FdIn)
 11596        if err != nil {
 11597          return types.CopyFileRangeArgs{}, err
 11598        }
 11599      case 1:
 11600        var dataOffIn uint64
 11601        err = decoder.DecodeUint64(&dataOffIn)
 11602        if err != nil {
 11603          return types.CopyFileRangeArgs{}, err
 11604        }
 11605        result.OffIn = uintptr(dataOffIn)
 11606      case 2:
 11607        err = decoder.DecodeInt32(&result.FdOut)
 11608        if err != nil {
 11609          return types.CopyFileRangeArgs{}, err
 11610        }
 11611      case 3:
 11612        var dataOffOut uint64
 11613        err = decoder.DecodeUint64(&dataOffOut)
 11614        if err != nil {
 11615          return types.CopyFileRangeArgs{}, err
 11616        }
 11617        result.OffOut = uintptr(dataOffOut)
 11618      case 4:
 11619        err = decoder.DecodeUint64(&result.Len)
 11620        if err != nil {
 11621          return types.CopyFileRangeArgs{}, err
 11622        }
 11623      case 5:
 11624        err = decoder.DecodeUint32(&result.Flags)
 11625        if err != nil {
 11626          return types.CopyFileRangeArgs{}, err
 11627        }
 11628      }
 11629    }
 11630    return result, nil
 11631  }
 11632  
 11633  func ParsePreadv2Args(decoder *Decoder) (types.Preadv2Args, error) {
 11634    var result types.Preadv2Args
 11635    var err error
 11636  
 11637    var numArgs uint8
 11638    err = decoder.DecodeUint8(&numArgs)
 11639    if err != nil {
 11640      return types.Preadv2Args{}, err
 11641    }
 11642  
 11643    for arg := 0; arg < int(numArgs); arg++ {
 11644      var currArg uint8
 11645      err = decoder.DecodeUint8(&currArg)
 11646      if err != nil {
 11647        return types.Preadv2Args{}, err
 11648      }
 11649  
 11650      switch currArg {
 11651      case 0:
 11652        err = decoder.DecodeInt32(&result.Fd)
 11653        if err != nil {
 11654          return types.Preadv2Args{}, err
 11655        }
 11656      case 1:
 11657        var dataIov uint64
 11658        err = decoder.DecodeUint64(&dataIov)
 11659        if err != nil {
 11660          return types.Preadv2Args{}, err
 11661        }
 11662        result.Iov = uintptr(dataIov)
 11663      case 2:
 11664        err = decoder.DecodeUint64(&result.Iovcnt)
 11665        if err != nil {
 11666          return types.Preadv2Args{}, err
 11667        }
 11668      case 3:
 11669        err = decoder.DecodeUint64(&result.PosL)
 11670        if err != nil {
 11671          return types.Preadv2Args{}, err
 11672        }
 11673      case 4:
 11674        err = decoder.DecodeUint64(&result.PosH)
 11675        if err != nil {
 11676          return types.Preadv2Args{}, err
 11677        }
 11678      case 5:
 11679        err = decoder.DecodeInt32(&result.Flags)
 11680        if err != nil {
 11681          return types.Preadv2Args{}, err
 11682        }
 11683      }
 11684    }
 11685    return result, nil
 11686  }
 11687  
 11688  func ParsePwritev2Args(decoder *Decoder) (types.Pwritev2Args, error) {
 11689    var result types.Pwritev2Args
 11690    var err error
 11691  
 11692    var numArgs uint8
 11693    err = decoder.DecodeUint8(&numArgs)
 11694    if err != nil {
 11695      return types.Pwritev2Args{}, err
 11696    }
 11697  
 11698    for arg := 0; arg < int(numArgs); arg++ {
 11699      var currArg uint8
 11700      err = decoder.DecodeUint8(&currArg)
 11701      if err != nil {
 11702        return types.Pwritev2Args{}, err
 11703      }
 11704  
 11705      switch currArg {
 11706      case 0:
 11707        err = decoder.DecodeInt32(&result.Fd)
 11708        if err != nil {
 11709          return types.Pwritev2Args{}, err
 11710        }
 11711      case 1:
 11712        var dataIov uint64
 11713        err = decoder.DecodeUint64(&dataIov)
 11714        if err != nil {
 11715          return types.Pwritev2Args{}, err
 11716        }
 11717        result.Iov = uintptr(dataIov)
 11718      case 2:
 11719        err = decoder.DecodeUint64(&result.Iovcnt)
 11720        if err != nil {
 11721          return types.Pwritev2Args{}, err
 11722        }
 11723      case 3:
 11724        err = decoder.DecodeUint64(&result.PosL)
 11725        if err != nil {
 11726          return types.Pwritev2Args{}, err
 11727        }
 11728      case 4:
 11729        err = decoder.DecodeUint64(&result.PosH)
 11730        if err != nil {
 11731          return types.Pwritev2Args{}, err
 11732        }
 11733      case 5:
 11734        err = decoder.DecodeInt32(&result.Flags)
 11735        if err != nil {
 11736          return types.Pwritev2Args{}, err
 11737        }
 11738      }
 11739    }
 11740    return result, nil
 11741  }
 11742  
 11743  func ParsePkeyMprotectArgs(decoder *Decoder) (types.PkeyMprotectArgs, error) {
 11744    var result types.PkeyMprotectArgs
 11745    var err error
 11746  
 11747    var numArgs uint8
 11748    err = decoder.DecodeUint8(&numArgs)
 11749    if err != nil {
 11750      return types.PkeyMprotectArgs{}, err
 11751    }
 11752  
 11753    for arg := 0; arg < int(numArgs); arg++ {
 11754      var currArg uint8
 11755      err = decoder.DecodeUint8(&currArg)
 11756      if err != nil {
 11757        return types.PkeyMprotectArgs{}, err
 11758      }
 11759  
 11760      switch currArg {
 11761      case 0:
 11762        var dataAddr uint64
 11763        err = decoder.DecodeUint64(&dataAddr)
 11764        if err != nil {
 11765          return types.PkeyMprotectArgs{}, err
 11766        }
 11767        result.Addr = uintptr(dataAddr)
 11768      case 1:
 11769        err = decoder.DecodeUint64(&result.Len)
 11770        if err != nil {
 11771          return types.PkeyMprotectArgs{}, err
 11772        }
 11773      case 2:
 11774        err = decoder.DecodeInt32(&result.Prot)
 11775        if err != nil {
 11776          return types.PkeyMprotectArgs{}, err
 11777        }
 11778      case 3:
 11779        err = decoder.DecodeInt32(&result.Pkey)
 11780        if err != nil {
 11781          return types.PkeyMprotectArgs{}, err
 11782        }
 11783      }
 11784    }
 11785    return result, nil
 11786  }
 11787  
 11788  func ParsePkeyAllocArgs(decoder *Decoder) (types.PkeyAllocArgs, error) {
 11789    var result types.PkeyAllocArgs
 11790    var err error
 11791  
 11792    var numArgs uint8
 11793    err = decoder.DecodeUint8(&numArgs)
 11794    if err != nil {
 11795      return types.PkeyAllocArgs{}, err
 11796    }
 11797  
 11798    for arg := 0; arg < int(numArgs); arg++ {
 11799      var currArg uint8
 11800      err = decoder.DecodeUint8(&currArg)
 11801      if err != nil {
 11802        return types.PkeyAllocArgs{}, err
 11803      }
 11804  
 11805      switch currArg {
 11806      case 0:
 11807        err = decoder.DecodeUint32(&result.Flags)
 11808        if err != nil {
 11809          return types.PkeyAllocArgs{}, err
 11810        }
 11811      case 1:
 11812        err = decoder.DecodeUint64(&result.AccessRights)
 11813        if err != nil {
 11814          return types.PkeyAllocArgs{}, err
 11815        }
 11816      }
 11817    }
 11818    return result, nil
 11819  }
 11820  
 11821  func ParsePkeyFreeArgs(decoder *Decoder) (types.PkeyFreeArgs, error) {
 11822    var result types.PkeyFreeArgs
 11823    var err error
 11824  
 11825    var numArgs uint8
 11826    err = decoder.DecodeUint8(&numArgs)
 11827    if err != nil {
 11828      return types.PkeyFreeArgs{}, err
 11829    }
 11830  
 11831    for arg := 0; arg < int(numArgs); arg++ {
 11832      var currArg uint8
 11833      err = decoder.DecodeUint8(&currArg)
 11834      if err != nil {
 11835        return types.PkeyFreeArgs{}, err
 11836      }
 11837  
 11838      switch currArg {
 11839      case 0:
 11840        err = decoder.DecodeInt32(&result.Pkey)
 11841        if err != nil {
 11842          return types.PkeyFreeArgs{}, err
 11843        }
 11844      }
 11845    }
 11846    return result, nil
 11847  }
 11848  
 11849  func ParseStatxArgs(decoder *Decoder) (types.StatxArgs, error) {
 11850    var result types.StatxArgs
 11851    var err error
 11852  
 11853    var numArgs uint8
 11854    err = decoder.DecodeUint8(&numArgs)
 11855    if err != nil {
 11856      return types.StatxArgs{}, err
 11857    }
 11858  
 11859    for arg := 0; arg < int(numArgs); arg++ {
 11860      var currArg uint8
 11861      err = decoder.DecodeUint8(&currArg)
 11862      if err != nil {
 11863        return types.StatxArgs{}, err
 11864      }
 11865  
 11866      switch currArg {
 11867      case 0:
 11868        err = decoder.DecodeInt32(&result.Dirfd)
 11869        if err != nil {
 11870          return types.StatxArgs{}, err
 11871        }
 11872      case 1:
 11873        result.Pathname, err = decoder.ReadStringFromBuff()
 11874        if err != nil {
 11875          return types.StatxArgs{}, err
 11876        }
 11877      case 2:
 11878        err = decoder.DecodeInt32(&result.Flags)
 11879        if err != nil {
 11880          return types.StatxArgs{}, err
 11881        }
 11882      case 3:
 11883        err = decoder.DecodeUint32(&result.Mask)
 11884        if err != nil {
 11885          return types.StatxArgs{}, err
 11886        }
 11887      case 4:
 11888        var dataStatxbuf uint64
 11889        err = decoder.DecodeUint64(&dataStatxbuf)
 11890        if err != nil {
 11891          return types.StatxArgs{}, err
 11892        }
 11893        result.Statxbuf = uintptr(dataStatxbuf)
 11894      }
 11895    }
 11896    return result, nil
 11897  }
 11898  
 11899  func ParseIoPgeteventsArgs(decoder *Decoder) (types.IoPgeteventsArgs, error) {
 11900    var result types.IoPgeteventsArgs
 11901    var err error
 11902  
 11903    var numArgs uint8
 11904    err = decoder.DecodeUint8(&numArgs)
 11905    if err != nil {
 11906      return types.IoPgeteventsArgs{}, err
 11907    }
 11908  
 11909    for arg := 0; arg < int(numArgs); arg++ {
 11910      var currArg uint8
 11911      err = decoder.DecodeUint8(&currArg)
 11912      if err != nil {
 11913        return types.IoPgeteventsArgs{}, err
 11914      }
 11915  
 11916      switch currArg {
 11917      case 0:
 11918        var dataCtxId uint64
 11919        err = decoder.DecodeUint64(&dataCtxId)
 11920        if err != nil {
 11921          return types.IoPgeteventsArgs{}, err
 11922        }
 11923        result.CtxId = uintptr(dataCtxId)
 11924      case 1:
 11925        err = decoder.DecodeInt64(&result.MinNr)
 11926        if err != nil {
 11927          return types.IoPgeteventsArgs{}, err
 11928        }
 11929      case 2:
 11930        err = decoder.DecodeInt64(&result.Nr)
 11931        if err != nil {
 11932          return types.IoPgeteventsArgs{}, err
 11933        }
 11934      case 3:
 11935        var dataEvents uint64
 11936        err = decoder.DecodeUint64(&dataEvents)
 11937        if err != nil {
 11938          return types.IoPgeteventsArgs{}, err
 11939        }
 11940        result.Events = uintptr(dataEvents)
 11941      case 4:
 11942        result.Timeout, err = decoder.ReadTimespec()
 11943        if err != nil {
 11944          return types.IoPgeteventsArgs{}, err
 11945        }
 11946      case 5:
 11947        var dataUsig uint64
 11948        err = decoder.DecodeUint64(&dataUsig)
 11949        if err != nil {
 11950          return types.IoPgeteventsArgs{}, err
 11951        }
 11952        result.Usig = uintptr(dataUsig)
 11953      }
 11954    }
 11955    return result, nil
 11956  }
 11957  
 11958  func ParseRseqArgs(decoder *Decoder) (types.RseqArgs, error) {
 11959    var result types.RseqArgs
 11960    var err error
 11961  
 11962    var numArgs uint8
 11963    err = decoder.DecodeUint8(&numArgs)
 11964    if err != nil {
 11965      return types.RseqArgs{}, err
 11966    }
 11967  
 11968    for arg := 0; arg < int(numArgs); arg++ {
 11969      var currArg uint8
 11970      err = decoder.DecodeUint8(&currArg)
 11971      if err != nil {
 11972        return types.RseqArgs{}, err
 11973      }
 11974  
 11975      switch currArg {
 11976      case 0:
 11977        var dataRseq uint64
 11978        err = decoder.DecodeUint64(&dataRseq)
 11979        if err != nil {
 11980          return types.RseqArgs{}, err
 11981        }
 11982        result.Rseq = uintptr(dataRseq)
 11983      case 1:
 11984        err = decoder.DecodeUint32(&result.RseqLen)
 11985        if err != nil {
 11986          return types.RseqArgs{}, err
 11987        }
 11988      case 2:
 11989        err = decoder.DecodeInt32(&result.Flags)
 11990        if err != nil {
 11991          return types.RseqArgs{}, err
 11992        }
 11993      case 3:
 11994        err = decoder.DecodeUint32(&result.Sig)
 11995        if err != nil {
 11996          return types.RseqArgs{}, err
 11997        }
 11998      }
 11999    }
 12000    return result, nil
 12001  }
 12002  
 12003  func ParsePidfdSendSignalArgs(decoder *Decoder) (types.PidfdSendSignalArgs, error) {
 12004    var result types.PidfdSendSignalArgs
 12005    var err error
 12006  
 12007    var numArgs uint8
 12008    err = decoder.DecodeUint8(&numArgs)
 12009    if err != nil {
 12010      return types.PidfdSendSignalArgs{}, err
 12011    }
 12012  
 12013    for arg := 0; arg < int(numArgs); arg++ {
 12014      var currArg uint8
 12015      err = decoder.DecodeUint8(&currArg)
 12016      if err != nil {
 12017        return types.PidfdSendSignalArgs{}, err
 12018      }
 12019  
 12020      switch currArg {
 12021      case 0:
 12022        err = decoder.DecodeInt32(&result.Pidfd)
 12023        if err != nil {
 12024          return types.PidfdSendSignalArgs{}, err
 12025        }
 12026      case 1:
 12027        err = decoder.DecodeInt32(&result.Sig)
 12028        if err != nil {
 12029          return types.PidfdSendSignalArgs{}, err
 12030        }
 12031      case 2:
 12032        var dataInfo uint64
 12033        err = decoder.DecodeUint64(&dataInfo)
 12034        if err != nil {
 12035          return types.PidfdSendSignalArgs{}, err
 12036        }
 12037        result.Info = uintptr(dataInfo)
 12038      case 3:
 12039        err = decoder.DecodeUint32(&result.Flags)
 12040        if err != nil {
 12041          return types.PidfdSendSignalArgs{}, err
 12042        }
 12043      }
 12044    }
 12045    return result, nil
 12046  }
 12047  
 12048  func ParseIoUringSetupArgs(decoder *Decoder) (types.IoUringSetupArgs, error) {
 12049    var result types.IoUringSetupArgs
 12050    var err error
 12051  
 12052    var numArgs uint8
 12053    err = decoder.DecodeUint8(&numArgs)
 12054    if err != nil {
 12055      return types.IoUringSetupArgs{}, err
 12056    }
 12057  
 12058    for arg := 0; arg < int(numArgs); arg++ {
 12059      var currArg uint8
 12060      err = decoder.DecodeUint8(&currArg)
 12061      if err != nil {
 12062        return types.IoUringSetupArgs{}, err
 12063      }
 12064  
 12065      switch currArg {
 12066      case 0:
 12067        err = decoder.DecodeUint32(&result.Entries)
 12068        if err != nil {
 12069          return types.IoUringSetupArgs{}, err
 12070        }
 12071      case 1:
 12072        var dataP uint64
 12073        err = decoder.DecodeUint64(&dataP)
 12074        if err != nil {
 12075          return types.IoUringSetupArgs{}, err
 12076        }
 12077        result.P = uintptr(dataP)
 12078      }
 12079    }
 12080    return result, nil
 12081  }
 12082  
 12083  func ParseIoUringEnterArgs(decoder *Decoder) (types.IoUringEnterArgs, error) {
 12084    var result types.IoUringEnterArgs
 12085    var err error
 12086  
 12087    var numArgs uint8
 12088    err = decoder.DecodeUint8(&numArgs)
 12089    if err != nil {
 12090      return types.IoUringEnterArgs{}, err
 12091    }
 12092  
 12093    for arg := 0; arg < int(numArgs); arg++ {
 12094      var currArg uint8
 12095      err = decoder.DecodeUint8(&currArg)
 12096      if err != nil {
 12097        return types.IoUringEnterArgs{}, err
 12098      }
 12099  
 12100      switch currArg {
 12101      case 0:
 12102        err = decoder.DecodeUint32(&result.Fd)
 12103        if err != nil {
 12104          return types.IoUringEnterArgs{}, err
 12105        }
 12106      case 1:
 12107        err = decoder.DecodeUint32(&result.ToSubmit)
 12108        if err != nil {
 12109          return types.IoUringEnterArgs{}, err
 12110        }
 12111      case 2:
 12112        err = decoder.DecodeUint32(&result.MinComplete)
 12113        if err != nil {
 12114          return types.IoUringEnterArgs{}, err
 12115        }
 12116      case 3:
 12117        err = decoder.DecodeUint32(&result.Flags)
 12118        if err != nil {
 12119          return types.IoUringEnterArgs{}, err
 12120        }
 12121      case 4:
 12122        var dataSig uint64
 12123        err = decoder.DecodeUint64(&dataSig)
 12124        if err != nil {
 12125          return types.IoUringEnterArgs{}, err
 12126        }
 12127        result.Sig = uintptr(dataSig)
 12128      }
 12129    }
 12130    return result, nil
 12131  }
 12132  
 12133  func ParseIoUringRegisterArgs(decoder *Decoder) (types.IoUringRegisterArgs, error) {
 12134    var result types.IoUringRegisterArgs
 12135    var err error
 12136  
 12137    var numArgs uint8
 12138    err = decoder.DecodeUint8(&numArgs)
 12139    if err != nil {
 12140      return types.IoUringRegisterArgs{}, err
 12141    }
 12142  
 12143    for arg := 0; arg < int(numArgs); arg++ {
 12144      var currArg uint8
 12145      err = decoder.DecodeUint8(&currArg)
 12146      if err != nil {
 12147        return types.IoUringRegisterArgs{}, err
 12148      }
 12149  
 12150      switch currArg {
 12151      case 0:
 12152        err = decoder.DecodeUint32(&result.Fd)
 12153        if err != nil {
 12154          return types.IoUringRegisterArgs{}, err
 12155        }
 12156      case 1:
 12157        err = decoder.DecodeUint32(&result.Opcode)
 12158        if err != nil {
 12159          return types.IoUringRegisterArgs{}, err
 12160        }
 12161      case 2:
 12162        var dataArg uint64
 12163        err = decoder.DecodeUint64(&dataArg)
 12164        if err != nil {
 12165          return types.IoUringRegisterArgs{}, err
 12166        }
 12167        result.Arg = uintptr(dataArg)
 12168      case 3:
 12169        err = decoder.DecodeUint32(&result.NrArgs)
 12170        if err != nil {
 12171          return types.IoUringRegisterArgs{}, err
 12172        }
 12173      }
 12174    }
 12175    return result, nil
 12176  }
 12177  
 12178  func ParseOpenTreeArgs(decoder *Decoder) (types.OpenTreeArgs, error) {
 12179    var result types.OpenTreeArgs
 12180    var err error
 12181  
 12182    var numArgs uint8
 12183    err = decoder.DecodeUint8(&numArgs)
 12184    if err != nil {
 12185      return types.OpenTreeArgs{}, err
 12186    }
 12187  
 12188    for arg := 0; arg < int(numArgs); arg++ {
 12189      var currArg uint8
 12190      err = decoder.DecodeUint8(&currArg)
 12191      if err != nil {
 12192        return types.OpenTreeArgs{}, err
 12193      }
 12194  
 12195      switch currArg {
 12196      case 0:
 12197        err = decoder.DecodeInt32(&result.Dfd)
 12198        if err != nil {
 12199          return types.OpenTreeArgs{}, err
 12200        }
 12201      case 1:
 12202        result.Filename, err = decoder.ReadStringFromBuff()
 12203        if err != nil {
 12204          return types.OpenTreeArgs{}, err
 12205        }
 12206      case 2:
 12207        err = decoder.DecodeUint32(&result.Flags)
 12208        if err != nil {
 12209          return types.OpenTreeArgs{}, err
 12210        }
 12211      }
 12212    }
 12213    return result, nil
 12214  }
 12215  
 12216  func ParseMoveMountArgs(decoder *Decoder) (types.MoveMountArgs, error) {
 12217    var result types.MoveMountArgs
 12218    var err error
 12219  
 12220    var numArgs uint8
 12221    err = decoder.DecodeUint8(&numArgs)
 12222    if err != nil {
 12223      return types.MoveMountArgs{}, err
 12224    }
 12225  
 12226    for arg := 0; arg < int(numArgs); arg++ {
 12227      var currArg uint8
 12228      err = decoder.DecodeUint8(&currArg)
 12229      if err != nil {
 12230        return types.MoveMountArgs{}, err
 12231      }
 12232  
 12233      switch currArg {
 12234      case 0:
 12235        err = decoder.DecodeInt32(&result.FromDfd)
 12236        if err != nil {
 12237          return types.MoveMountArgs{}, err
 12238        }
 12239      case 1:
 12240        result.FromPath, err = decoder.ReadStringFromBuff()
 12241        if err != nil {
 12242          return types.MoveMountArgs{}, err
 12243        }
 12244      case 2:
 12245        err = decoder.DecodeInt32(&result.ToDfd)
 12246        if err != nil {
 12247          return types.MoveMountArgs{}, err
 12248        }
 12249      case 3:
 12250        result.ToPath, err = decoder.ReadStringFromBuff()
 12251        if err != nil {
 12252          return types.MoveMountArgs{}, err
 12253        }
 12254      case 4:
 12255        err = decoder.DecodeUint32(&result.Flags)
 12256        if err != nil {
 12257          return types.MoveMountArgs{}, err
 12258        }
 12259      }
 12260    }
 12261    return result, nil
 12262  }
 12263  
 12264  func ParseFsopenArgs(decoder *Decoder) (types.FsopenArgs, error) {
 12265    var result types.FsopenArgs
 12266    var err error
 12267  
 12268    var numArgs uint8
 12269    err = decoder.DecodeUint8(&numArgs)
 12270    if err != nil {
 12271      return types.FsopenArgs{}, err
 12272    }
 12273  
 12274    for arg := 0; arg < int(numArgs); arg++ {
 12275      var currArg uint8
 12276      err = decoder.DecodeUint8(&currArg)
 12277      if err != nil {
 12278        return types.FsopenArgs{}, err
 12279      }
 12280  
 12281      switch currArg {
 12282      case 0:
 12283        result.Fsname, err = decoder.ReadStringFromBuff()
 12284        if err != nil {
 12285          return types.FsopenArgs{}, err
 12286        }
 12287      case 1:
 12288        err = decoder.DecodeUint32(&result.Flags)
 12289        if err != nil {
 12290          return types.FsopenArgs{}, err
 12291        }
 12292      }
 12293    }
 12294    return result, nil
 12295  }
 12296  
 12297  func ParseFsconfigArgs(decoder *Decoder) (types.FsconfigArgs, error) {
 12298    var result types.FsconfigArgs
 12299    var err error
 12300  
 12301    var numArgs uint8
 12302    err = decoder.DecodeUint8(&numArgs)
 12303    if err != nil {
 12304      return types.FsconfigArgs{}, err
 12305    }
 12306  
 12307    for arg := 0; arg < int(numArgs); arg++ {
 12308      var currArg uint8
 12309      err = decoder.DecodeUint8(&currArg)
 12310      if err != nil {
 12311        return types.FsconfigArgs{}, err
 12312      }
 12313  
 12314      switch currArg {
 12315      case 0:
 12316        var dataFsFd uint64
 12317        err = decoder.DecodeUint64(&dataFsFd)
 12318        if err != nil {
 12319          return types.FsconfigArgs{}, err
 12320        }
 12321        result.FsFd = uintptr(dataFsFd)
 12322      case 1:
 12323        err = decoder.DecodeUint32(&result.Cmd)
 12324        if err != nil {
 12325          return types.FsconfigArgs{}, err
 12326        }
 12327      case 2:
 12328        result.Key, err = decoder.ReadStringFromBuff()
 12329        if err != nil {
 12330          return types.FsconfigArgs{}, err
 12331        }
 12332      case 3:
 12333        var dataValue uint64
 12334        err = decoder.DecodeUint64(&dataValue)
 12335        if err != nil {
 12336          return types.FsconfigArgs{}, err
 12337        }
 12338        result.Value = uintptr(dataValue)
 12339      case 4:
 12340        err = decoder.DecodeInt32(&result.Aux)
 12341        if err != nil {
 12342          return types.FsconfigArgs{}, err
 12343        }
 12344      }
 12345    }
 12346    return result, nil
 12347  }
 12348  
 12349  func ParseFsmountArgs(decoder *Decoder) (types.FsmountArgs, error) {
 12350    var result types.FsmountArgs
 12351    var err error
 12352  
 12353    var numArgs uint8
 12354    err = decoder.DecodeUint8(&numArgs)
 12355    if err != nil {
 12356      return types.FsmountArgs{}, err
 12357    }
 12358  
 12359    for arg := 0; arg < int(numArgs); arg++ {
 12360      var currArg uint8
 12361      err = decoder.DecodeUint8(&currArg)
 12362      if err != nil {
 12363        return types.FsmountArgs{}, err
 12364      }
 12365  
 12366      switch currArg {
 12367      case 0:
 12368        err = decoder.DecodeInt32(&result.Fsfd)
 12369        if err != nil {
 12370          return types.FsmountArgs{}, err
 12371        }
 12372      case 1:
 12373        err = decoder.DecodeUint32(&result.Flags)
 12374        if err != nil {
 12375          return types.FsmountArgs{}, err
 12376        }
 12377      case 2:
 12378        err = decoder.DecodeUint32(&result.MsFlags)
 12379        if err != nil {
 12380          return types.FsmountArgs{}, err
 12381        }
 12382      }
 12383    }
 12384    return result, nil
 12385  }
 12386  
 12387  func ParseFspickArgs(decoder *Decoder) (types.FspickArgs, error) {
 12388    var result types.FspickArgs
 12389    var err error
 12390  
 12391    var numArgs uint8
 12392    err = decoder.DecodeUint8(&numArgs)
 12393    if err != nil {
 12394      return types.FspickArgs{}, err
 12395    }
 12396  
 12397    for arg := 0; arg < int(numArgs); arg++ {
 12398      var currArg uint8
 12399      err = decoder.DecodeUint8(&currArg)
 12400      if err != nil {
 12401        return types.FspickArgs{}, err
 12402      }
 12403  
 12404      switch currArg {
 12405      case 0:
 12406        err = decoder.DecodeInt32(&result.Dirfd)
 12407        if err != nil {
 12408          return types.FspickArgs{}, err
 12409        }
 12410      case 1:
 12411        result.Pathname, err = decoder.ReadStringFromBuff()
 12412        if err != nil {
 12413          return types.FspickArgs{}, err
 12414        }
 12415      case 2:
 12416        err = decoder.DecodeUint32(&result.Flags)
 12417        if err != nil {
 12418          return types.FspickArgs{}, err
 12419        }
 12420      }
 12421    }
 12422    return result, nil
 12423  }
 12424  
 12425  func ParsePidfdOpenArgs(decoder *Decoder) (types.PidfdOpenArgs, error) {
 12426    var result types.PidfdOpenArgs
 12427    var err error
 12428  
 12429    var numArgs uint8
 12430    err = decoder.DecodeUint8(&numArgs)
 12431    if err != nil {
 12432      return types.PidfdOpenArgs{}, err
 12433    }
 12434  
 12435    for arg := 0; arg < int(numArgs); arg++ {
 12436      var currArg uint8
 12437      err = decoder.DecodeUint8(&currArg)
 12438      if err != nil {
 12439        return types.PidfdOpenArgs{}, err
 12440      }
 12441  
 12442      switch currArg {
 12443      case 0:
 12444        err = decoder.DecodeInt32(&result.Pid)
 12445        if err != nil {
 12446          return types.PidfdOpenArgs{}, err
 12447        }
 12448      case 1:
 12449        err = decoder.DecodeUint32(&result.Flags)
 12450        if err != nil {
 12451          return types.PidfdOpenArgs{}, err
 12452        }
 12453      }
 12454    }
 12455    return result, nil
 12456  }
 12457  
 12458  func ParseClone3Args(decoder *Decoder) (types.Clone3Args, error) {
 12459    var result types.Clone3Args
 12460    var err error
 12461  
 12462    var numArgs uint8
 12463    err = decoder.DecodeUint8(&numArgs)
 12464    if err != nil {
 12465      return types.Clone3Args{}, err
 12466    }
 12467  
 12468    for arg := 0; arg < int(numArgs); arg++ {
 12469      var currArg uint8
 12470      err = decoder.DecodeUint8(&currArg)
 12471      if err != nil {
 12472        return types.Clone3Args{}, err
 12473      }
 12474  
 12475      switch currArg {
 12476      case 0:
 12477        var dataClArgs uint64
 12478        err = decoder.DecodeUint64(&dataClArgs)
 12479        if err != nil {
 12480          return types.Clone3Args{}, err
 12481        }
 12482        result.ClArgs = uintptr(dataClArgs)
 12483      case 1:
 12484        err = decoder.DecodeUint64(&result.Size)
 12485        if err != nil {
 12486          return types.Clone3Args{}, err
 12487        }
 12488      }
 12489    }
 12490    return result, nil
 12491  }
 12492  
 12493  func ParseCloseRangeArgs(decoder *Decoder) (types.CloseRangeArgs, error) {
 12494    var result types.CloseRangeArgs
 12495    var err error
 12496  
 12497    var numArgs uint8
 12498    err = decoder.DecodeUint8(&numArgs)
 12499    if err != nil {
 12500      return types.CloseRangeArgs{}, err
 12501    }
 12502  
 12503    for arg := 0; arg < int(numArgs); arg++ {
 12504      var currArg uint8
 12505      err = decoder.DecodeUint8(&currArg)
 12506      if err != nil {
 12507        return types.CloseRangeArgs{}, err
 12508      }
 12509  
 12510      switch currArg {
 12511      case 0:
 12512        err = decoder.DecodeUint32(&result.First)
 12513        if err != nil {
 12514          return types.CloseRangeArgs{}, err
 12515        }
 12516      case 1:
 12517        err = decoder.DecodeUint32(&result.Last)
 12518        if err != nil {
 12519          return types.CloseRangeArgs{}, err
 12520        }
 12521      }
 12522    }
 12523    return result, nil
 12524  }
 12525  
 12526  func ParseOpenat2Args(decoder *Decoder) (types.Openat2Args, error) {
 12527    var result types.Openat2Args
 12528    var err error
 12529  
 12530    var numArgs uint8
 12531    err = decoder.DecodeUint8(&numArgs)
 12532    if err != nil {
 12533      return types.Openat2Args{}, err
 12534    }
 12535  
 12536    for arg := 0; arg < int(numArgs); arg++ {
 12537      var currArg uint8
 12538      err = decoder.DecodeUint8(&currArg)
 12539      if err != nil {
 12540        return types.Openat2Args{}, err
 12541      }
 12542  
 12543      switch currArg {
 12544      case 0:
 12545        err = decoder.DecodeInt32(&result.Dirfd)
 12546        if err != nil {
 12547          return types.Openat2Args{}, err
 12548        }
 12549      case 1:
 12550        result.Pathname, err = decoder.ReadStringFromBuff()
 12551        if err != nil {
 12552          return types.Openat2Args{}, err
 12553        }
 12554      case 2:
 12555        var dataHow uint64
 12556        err = decoder.DecodeUint64(&dataHow)
 12557        if err != nil {
 12558          return types.Openat2Args{}, err
 12559        }
 12560        result.How = uintptr(dataHow)
 12561      case 3:
 12562        err = decoder.DecodeUint64(&result.Size)
 12563        if err != nil {
 12564          return types.Openat2Args{}, err
 12565        }
 12566      }
 12567    }
 12568    return result, nil
 12569  }
 12570  
 12571  func ParsePidfdGetfdArgs(decoder *Decoder) (types.PidfdGetfdArgs, error) {
 12572    var result types.PidfdGetfdArgs
 12573    var err error
 12574  
 12575    var numArgs uint8
 12576    err = decoder.DecodeUint8(&numArgs)
 12577    if err != nil {
 12578      return types.PidfdGetfdArgs{}, err
 12579    }
 12580  
 12581    for arg := 0; arg < int(numArgs); arg++ {
 12582      var currArg uint8
 12583      err = decoder.DecodeUint8(&currArg)
 12584      if err != nil {
 12585        return types.PidfdGetfdArgs{}, err
 12586      }
 12587  
 12588      switch currArg {
 12589      case 0:
 12590        err = decoder.DecodeInt32(&result.Pidfd)
 12591        if err != nil {
 12592          return types.PidfdGetfdArgs{}, err
 12593        }
 12594      case 1:
 12595        err = decoder.DecodeInt32(&result.Targetfd)
 12596        if err != nil {
 12597          return types.PidfdGetfdArgs{}, err
 12598        }
 12599      case 2:
 12600        err = decoder.DecodeUint32(&result.Flags)
 12601        if err != nil {
 12602          return types.PidfdGetfdArgs{}, err
 12603        }
 12604      }
 12605    }
 12606    return result, nil
 12607  }
 12608  
 12609  func ParseFaccessat2Args(decoder *Decoder) (types.Faccessat2Args, error) {
 12610    var result types.Faccessat2Args
 12611    var err error
 12612  
 12613    var numArgs uint8
 12614    err = decoder.DecodeUint8(&numArgs)
 12615    if err != nil {
 12616      return types.Faccessat2Args{}, err
 12617    }
 12618  
 12619    for arg := 0; arg < int(numArgs); arg++ {
 12620      var currArg uint8
 12621      err = decoder.DecodeUint8(&currArg)
 12622      if err != nil {
 12623        return types.Faccessat2Args{}, err
 12624      }
 12625  
 12626      switch currArg {
 12627      case 0:
 12628        err = decoder.DecodeInt32(&result.Fd)
 12629        if err != nil {
 12630          return types.Faccessat2Args{}, err
 12631        }
 12632      case 1:
 12633        result.Path, err = decoder.ReadStringFromBuff()
 12634        if err != nil {
 12635          return types.Faccessat2Args{}, err
 12636        }
 12637      case 2:
 12638        err = decoder.DecodeInt32(&result.Mode)
 12639        if err != nil {
 12640          return types.Faccessat2Args{}, err
 12641        }
 12642      case 3:
 12643        err = decoder.DecodeInt32(&result.Flag)
 12644        if err != nil {
 12645          return types.Faccessat2Args{}, err
 12646        }
 12647      }
 12648    }
 12649    return result, nil
 12650  }
 12651  
 12652  func ParseProcessMadviseArgs(decoder *Decoder) (types.ProcessMadviseArgs, error) {
 12653    var result types.ProcessMadviseArgs
 12654    var err error
 12655  
 12656    var numArgs uint8
 12657    err = decoder.DecodeUint8(&numArgs)
 12658    if err != nil {
 12659      return types.ProcessMadviseArgs{}, err
 12660    }
 12661  
 12662    for arg := 0; arg < int(numArgs); arg++ {
 12663      var currArg uint8
 12664      err = decoder.DecodeUint8(&currArg)
 12665      if err != nil {
 12666        return types.ProcessMadviseArgs{}, err
 12667      }
 12668  
 12669      switch currArg {
 12670      case 0:
 12671        err = decoder.DecodeInt32(&result.Pidfd)
 12672        if err != nil {
 12673          return types.ProcessMadviseArgs{}, err
 12674        }
 12675      case 1:
 12676        var dataAddr uint64
 12677        err = decoder.DecodeUint64(&dataAddr)
 12678        if err != nil {
 12679          return types.ProcessMadviseArgs{}, err
 12680        }
 12681        result.Addr = uintptr(dataAddr)
 12682      case 2:
 12683        err = decoder.DecodeUint64(&result.Length)
 12684        if err != nil {
 12685          return types.ProcessMadviseArgs{}, err
 12686        }
 12687      case 3:
 12688        err = decoder.DecodeInt32(&result.Advice)
 12689        if err != nil {
 12690          return types.ProcessMadviseArgs{}, err
 12691        }
 12692      case 4:
 12693        err = decoder.DecodeUint64(&result.Flags)
 12694        if err != nil {
 12695          return types.ProcessMadviseArgs{}, err
 12696        }
 12697      }
 12698    }
 12699    return result, nil
 12700  }
 12701  
 12702  func ParseEpollPwait2Args(decoder *Decoder) (types.EpollPwait2Args, error) {
 12703    var result types.EpollPwait2Args
 12704    var err error
 12705  
 12706    var numArgs uint8
 12707    err = decoder.DecodeUint8(&numArgs)
 12708    if err != nil {
 12709      return types.EpollPwait2Args{}, err
 12710    }
 12711  
 12712    for arg := 0; arg < int(numArgs); arg++ {
 12713      var currArg uint8
 12714      err = decoder.DecodeUint8(&currArg)
 12715      if err != nil {
 12716        return types.EpollPwait2Args{}, err
 12717      }
 12718  
 12719      switch currArg {
 12720      case 0:
 12721        err = decoder.DecodeInt32(&result.Fd)
 12722        if err != nil {
 12723          return types.EpollPwait2Args{}, err
 12724        }
 12725      case 1:
 12726        var dataEvents uint64
 12727        err = decoder.DecodeUint64(&dataEvents)
 12728        if err != nil {
 12729          return types.EpollPwait2Args{}, err
 12730        }
 12731        result.Events = uintptr(dataEvents)
 12732      case 2:
 12733        err = decoder.DecodeInt32(&result.Maxevents)
 12734        if err != nil {
 12735          return types.EpollPwait2Args{}, err
 12736        }
 12737      case 3:
 12738        result.Timeout, err = decoder.ReadTimespec()
 12739        if err != nil {
 12740          return types.EpollPwait2Args{}, err
 12741        }
 12742      case 4:
 12743        var dataSigset uint64
 12744        err = decoder.DecodeUint64(&dataSigset)
 12745        if err != nil {
 12746          return types.EpollPwait2Args{}, err
 12747        }
 12748        result.Sigset = uintptr(dataSigset)
 12749      }
 12750    }
 12751    return result, nil
 12752  }
 12753  
 12754  func ParseMountSetattArgs(decoder *Decoder) (types.MountSetattArgs, error) {
 12755    var result types.MountSetattArgs
 12756    var err error
 12757  
 12758    var numArgs uint8
 12759    err = decoder.DecodeUint8(&numArgs)
 12760    if err != nil {
 12761      return types.MountSetattArgs{}, err
 12762    }
 12763  
 12764    for arg := 0; arg < int(numArgs); arg++ {
 12765      var currArg uint8
 12766      err = decoder.DecodeUint8(&currArg)
 12767      if err != nil {
 12768        return types.MountSetattArgs{}, err
 12769      }
 12770  
 12771      switch currArg {
 12772      case 0:
 12773        err = decoder.DecodeInt32(&result.Dfd)
 12774        if err != nil {
 12775          return types.MountSetattArgs{}, err
 12776        }
 12777      case 1:
 12778        result.Path, err = decoder.ReadStringFromBuff()
 12779        if err != nil {
 12780          return types.MountSetattArgs{}, err
 12781        }
 12782      case 2:
 12783        err = decoder.DecodeUint32(&result.Flags)
 12784        if err != nil {
 12785          return types.MountSetattArgs{}, err
 12786        }
 12787      case 3:
 12788        var dataUattr uint64
 12789        err = decoder.DecodeUint64(&dataUattr)
 12790        if err != nil {
 12791          return types.MountSetattArgs{}, err
 12792        }
 12793        result.Uattr = uintptr(dataUattr)
 12794      case 4:
 12795        err = decoder.DecodeUint64(&result.Usize)
 12796        if err != nil {
 12797          return types.MountSetattArgs{}, err
 12798        }
 12799      }
 12800    }
 12801    return result, nil
 12802  }
 12803  
 12804  func ParseQuotactlFdArgs(decoder *Decoder) (types.QuotactlFdArgs, error) {
 12805    var result types.QuotactlFdArgs
 12806    var err error
 12807  
 12808    var numArgs uint8
 12809    err = decoder.DecodeUint8(&numArgs)
 12810    if err != nil {
 12811      return types.QuotactlFdArgs{}, err
 12812    }
 12813  
 12814    for arg := 0; arg < int(numArgs); arg++ {
 12815      var currArg uint8
 12816      err = decoder.DecodeUint8(&currArg)
 12817      if err != nil {
 12818        return types.QuotactlFdArgs{}, err
 12819      }
 12820  
 12821      switch currArg {
 12822      case 0:
 12823        err = decoder.DecodeUint32(&result.Fd)
 12824        if err != nil {
 12825          return types.QuotactlFdArgs{}, err
 12826        }
 12827      case 1:
 12828        err = decoder.DecodeUint32(&result.Cmd)
 12829        if err != nil {
 12830          return types.QuotactlFdArgs{}, err
 12831        }
 12832      case 2:
 12833        var dataId uint64
 12834        err = decoder.DecodeUint64(&dataId)
 12835        if err != nil {
 12836          return types.QuotactlFdArgs{}, err
 12837        }
 12838        result.Id = uintptr(dataId)
 12839      case 3:
 12840        var dataAddr uint64
 12841        err = decoder.DecodeUint64(&dataAddr)
 12842        if err != nil {
 12843          return types.QuotactlFdArgs{}, err
 12844        }
 12845        result.Addr = uintptr(dataAddr)
 12846      }
 12847    }
 12848    return result, nil
 12849  }
 12850  
 12851  func ParseLandlockCreateRulesetArgs(decoder *Decoder) (types.LandlockCreateRulesetArgs, error) {
 12852    var result types.LandlockCreateRulesetArgs
 12853    var err error
 12854  
 12855    var numArgs uint8
 12856    err = decoder.DecodeUint8(&numArgs)
 12857    if err != nil {
 12858      return types.LandlockCreateRulesetArgs{}, err
 12859    }
 12860  
 12861    for arg := 0; arg < int(numArgs); arg++ {
 12862      var currArg uint8
 12863      err = decoder.DecodeUint8(&currArg)
 12864      if err != nil {
 12865        return types.LandlockCreateRulesetArgs{}, err
 12866      }
 12867  
 12868      switch currArg {
 12869      case 0:
 12870        var dataAttr uint64
 12871        err = decoder.DecodeUint64(&dataAttr)
 12872        if err != nil {
 12873          return types.LandlockCreateRulesetArgs{}, err
 12874        }
 12875        result.Attr = uintptr(dataAttr)
 12876      case 1:
 12877        err = decoder.DecodeUint64(&result.Size)
 12878        if err != nil {
 12879          return types.LandlockCreateRulesetArgs{}, err
 12880        }
 12881      case 2:
 12882        err = decoder.DecodeUint32(&result.Flags)
 12883        if err != nil {
 12884          return types.LandlockCreateRulesetArgs{}, err
 12885        }
 12886      }
 12887    }
 12888    return result, nil
 12889  }
 12890  
 12891  func ParseLandlockAddRuleArgs(decoder *Decoder) (types.LandlockAddRuleArgs, error) {
 12892    var result types.LandlockAddRuleArgs
 12893    var err error
 12894  
 12895    var numArgs uint8
 12896    err = decoder.DecodeUint8(&numArgs)
 12897    if err != nil {
 12898      return types.LandlockAddRuleArgs{}, err
 12899    }
 12900  
 12901    for arg := 0; arg < int(numArgs); arg++ {
 12902      var currArg uint8
 12903      err = decoder.DecodeUint8(&currArg)
 12904      if err != nil {
 12905        return types.LandlockAddRuleArgs{}, err
 12906      }
 12907  
 12908      switch currArg {
 12909      case 0:
 12910        err = decoder.DecodeInt32(&result.RulesetFd)
 12911        if err != nil {
 12912          return types.LandlockAddRuleArgs{}, err
 12913        }
 12914      case 1:
 12915        var dataRuleType uint64
 12916        err = decoder.DecodeUint64(&dataRuleType)
 12917        if err != nil {
 12918          return types.LandlockAddRuleArgs{}, err
 12919        }
 12920        result.RuleType = uintptr(dataRuleType)
 12921      case 2:
 12922        var dataRuleAttr uint64
 12923        err = decoder.DecodeUint64(&dataRuleAttr)
 12924        if err != nil {
 12925          return types.LandlockAddRuleArgs{}, err
 12926        }
 12927        result.RuleAttr = uintptr(dataRuleAttr)
 12928      case 3:
 12929        err = decoder.DecodeUint32(&result.Flags)
 12930        if err != nil {
 12931          return types.LandlockAddRuleArgs{}, err
 12932        }
 12933      }
 12934    }
 12935    return result, nil
 12936  }
 12937  
 12938  func ParseLandloclRestrictSetArgs(decoder *Decoder) (types.LandloclRestrictSetArgs, error) {
 12939    var result types.LandloclRestrictSetArgs
 12940    var err error
 12941  
 12942    var numArgs uint8
 12943    err = decoder.DecodeUint8(&numArgs)
 12944    if err != nil {
 12945      return types.LandloclRestrictSetArgs{}, err
 12946    }
 12947  
 12948    for arg := 0; arg < int(numArgs); arg++ {
 12949      var currArg uint8
 12950      err = decoder.DecodeUint8(&currArg)
 12951      if err != nil {
 12952        return types.LandloclRestrictSetArgs{}, err
 12953      }
 12954  
 12955      switch currArg {
 12956      case 0:
 12957        err = decoder.DecodeInt32(&result.RulesetFd)
 12958        if err != nil {
 12959          return types.LandloclRestrictSetArgs{}, err
 12960        }
 12961      case 1:
 12962        err = decoder.DecodeUint32(&result.Flags)
 12963        if err != nil {
 12964          return types.LandloclRestrictSetArgs{}, err
 12965        }
 12966      }
 12967    }
 12968    return result, nil
 12969  }
 12970  
 12971  func ParseMemfdSecretArgs(decoder *Decoder) (types.MemfdSecretArgs, error) {
 12972    var result types.MemfdSecretArgs
 12973    var err error
 12974  
 12975    var numArgs uint8
 12976    err = decoder.DecodeUint8(&numArgs)
 12977    if err != nil {
 12978      return types.MemfdSecretArgs{}, err
 12979    }
 12980  
 12981    for arg := 0; arg < int(numArgs); arg++ {
 12982      var currArg uint8
 12983      err = decoder.DecodeUint8(&currArg)
 12984      if err != nil {
 12985        return types.MemfdSecretArgs{}, err
 12986      }
 12987  
 12988      switch currArg {
 12989      case 0:
 12990        err = decoder.DecodeUint32(&result.Flags)
 12991        if err != nil {
 12992          return types.MemfdSecretArgs{}, err
 12993        }
 12994      }
 12995    }
 12996    return result, nil
 12997  }
 12998  
 12999  func ParseProcessMreleaseArgs(decoder *Decoder) (types.ProcessMreleaseArgs, error) {
 13000    var result types.ProcessMreleaseArgs
 13001    var err error
 13002  
 13003    var numArgs uint8
 13004    err = decoder.DecodeUint8(&numArgs)
 13005    if err != nil {
 13006      return types.ProcessMreleaseArgs{}, err
 13007    }
 13008  
 13009    for arg := 0; arg < int(numArgs); arg++ {
 13010      var currArg uint8
 13011      err = decoder.DecodeUint8(&currArg)
 13012      if err != nil {
 13013        return types.ProcessMreleaseArgs{}, err
 13014      }
 13015  
 13016      switch currArg {
 13017      case 0:
 13018        err = decoder.DecodeInt32(&result.Pidfd)
 13019        if err != nil {
 13020          return types.ProcessMreleaseArgs{}, err
 13021        }
 13022      case 1:
 13023        err = decoder.DecodeUint32(&result.Flags)
 13024        if err != nil {
 13025          return types.ProcessMreleaseArgs{}, err
 13026        }
 13027      }
 13028    }
 13029    return result, nil
 13030  }
 13031  
 13032  func ParseWaitpidArgs(decoder *Decoder) (types.WaitpidArgs, error) {
 13033    var result types.WaitpidArgs
 13034    var err error
 13035  
 13036    var numArgs uint8
 13037    err = decoder.DecodeUint8(&numArgs)
 13038    if err != nil {
 13039      return types.WaitpidArgs{}, err
 13040    }
 13041  
 13042    for arg := 0; arg < int(numArgs); arg++ {
 13043      var currArg uint8
 13044      err = decoder.DecodeUint8(&currArg)
 13045      if err != nil {
 13046        return types.WaitpidArgs{}, err
 13047      }
 13048  
 13049      switch currArg {
 13050      case 0:
 13051        err = decoder.DecodeInt32(&result.Pid)
 13052        if err != nil {
 13053          return types.WaitpidArgs{}, err
 13054        }
 13055      case 1:
 13056        var dataStatus uint64
 13057        err = decoder.DecodeUint64(&dataStatus)
 13058        if err != nil {
 13059          return types.WaitpidArgs{}, err
 13060        }
 13061        result.Status = uintptr(dataStatus)
 13062      case 2:
 13063        err = decoder.DecodeInt32(&result.Options)
 13064        if err != nil {
 13065          return types.WaitpidArgs{}, err
 13066        }
 13067      }
 13068    }
 13069    return result, nil
 13070  }
 13071  
 13072  func ParseOldfstatArgs(decoder *Decoder) (types.OldfstatArgs, error) {
 13073    return types.OldfstatArgs{}, nil
 13074  }
 13075  
 13076  func ParseBreakArgs(decoder *Decoder) (types.BreakArgs, error) {
 13077    return types.BreakArgs{}, nil
 13078  }
 13079  
 13080  func ParseOldstatArgs(decoder *Decoder) (types.OldstatArgs, error) {
 13081    var result types.OldstatArgs
 13082    var err error
 13083  
 13084    var numArgs uint8
 13085    err = decoder.DecodeUint8(&numArgs)
 13086    if err != nil {
 13087      return types.OldstatArgs{}, err
 13088    }
 13089  
 13090    for arg := 0; arg < int(numArgs); arg++ {
 13091      var currArg uint8
 13092      err = decoder.DecodeUint8(&currArg)
 13093      if err != nil {
 13094        return types.OldstatArgs{}, err
 13095      }
 13096  
 13097      switch currArg {
 13098      case 0:
 13099        result.Filename, err = decoder.ReadStringFromBuff()
 13100        if err != nil {
 13101          return types.OldstatArgs{}, err
 13102        }
 13103      case 1:
 13104        var dataStatbuf uint64
 13105        err = decoder.DecodeUint64(&dataStatbuf)
 13106        if err != nil {
 13107          return types.OldstatArgs{}, err
 13108        }
 13109        result.Statbuf = uintptr(dataStatbuf)
 13110      }
 13111    }
 13112    return result, nil
 13113  }
 13114  
 13115  func ParseUmountArgs(decoder *Decoder) (types.UmountArgs, error) {
 13116    var result types.UmountArgs
 13117    var err error
 13118  
 13119    var numArgs uint8
 13120    err = decoder.DecodeUint8(&numArgs)
 13121    if err != nil {
 13122      return types.UmountArgs{}, err
 13123    }
 13124  
 13125    for arg := 0; arg < int(numArgs); arg++ {
 13126      var currArg uint8
 13127      err = decoder.DecodeUint8(&currArg)
 13128      if err != nil {
 13129        return types.UmountArgs{}, err
 13130      }
 13131  
 13132      switch currArg {
 13133      case 0:
 13134        result.Target, err = decoder.ReadStringFromBuff()
 13135        if err != nil {
 13136          return types.UmountArgs{}, err
 13137        }
 13138      }
 13139    }
 13140    return result, nil
 13141  }
 13142  
 13143  func ParseStimeArgs(decoder *Decoder) (types.StimeArgs, error) {
 13144    var result types.StimeArgs
 13145    var err error
 13146  
 13147    var numArgs uint8
 13148    err = decoder.DecodeUint8(&numArgs)
 13149    if err != nil {
 13150      return types.StimeArgs{}, err
 13151    }
 13152  
 13153    for arg := 0; arg < int(numArgs); arg++ {
 13154      var currArg uint8
 13155      err = decoder.DecodeUint8(&currArg)
 13156      if err != nil {
 13157        return types.StimeArgs{}, err
 13158      }
 13159  
 13160      switch currArg {
 13161      case 0:
 13162        var dataT uint64
 13163        err = decoder.DecodeUint64(&dataT)
 13164        if err != nil {
 13165          return types.StimeArgs{}, err
 13166        }
 13167        result.T = uintptr(dataT)
 13168      }
 13169    }
 13170    return result, nil
 13171  }
 13172  
 13173  func ParseSttyArgs(decoder *Decoder) (types.SttyArgs, error) {
 13174    return types.SttyArgs{}, nil
 13175  }
 13176  
 13177  func ParseGttyArgs(decoder *Decoder) (types.GttyArgs, error) {
 13178    return types.GttyArgs{}, nil
 13179  }
 13180  
 13181  func ParseNiceArgs(decoder *Decoder) (types.NiceArgs, error) {
 13182    var result types.NiceArgs
 13183    var err error
 13184  
 13185    var numArgs uint8
 13186    err = decoder.DecodeUint8(&numArgs)
 13187    if err != nil {
 13188      return types.NiceArgs{}, err
 13189    }
 13190  
 13191    for arg := 0; arg < int(numArgs); arg++ {
 13192      var currArg uint8
 13193      err = decoder.DecodeUint8(&currArg)
 13194      if err != nil {
 13195        return types.NiceArgs{}, err
 13196      }
 13197  
 13198      switch currArg {
 13199      case 0:
 13200        err = decoder.DecodeInt32(&result.Inc)
 13201        if err != nil {
 13202          return types.NiceArgs{}, err
 13203        }
 13204      }
 13205    }
 13206    return result, nil
 13207  }
 13208  
 13209  func ParseFtimeArgs(decoder *Decoder) (types.FtimeArgs, error) {
 13210    return types.FtimeArgs{}, nil
 13211  }
 13212  
 13213  func ParseProfArgs(decoder *Decoder) (types.ProfArgs, error) {
 13214    return types.ProfArgs{}, nil
 13215  }
 13216  
 13217  func ParseSignalArgs(decoder *Decoder) (types.SignalArgs, error) {
 13218    var result types.SignalArgs
 13219    var err error
 13220  
 13221    var numArgs uint8
 13222    err = decoder.DecodeUint8(&numArgs)
 13223    if err != nil {
 13224      return types.SignalArgs{}, err
 13225    }
 13226  
 13227    for arg := 0; arg < int(numArgs); arg++ {
 13228      var currArg uint8
 13229      err = decoder.DecodeUint8(&currArg)
 13230      if err != nil {
 13231        return types.SignalArgs{}, err
 13232      }
 13233  
 13234      switch currArg {
 13235      case 0:
 13236        err = decoder.DecodeInt32(&result.Signum)
 13237        if err != nil {
 13238          return types.SignalArgs{}, err
 13239        }
 13240      case 1:
 13241        var dataHandler uint64
 13242        err = decoder.DecodeUint64(&dataHandler)
 13243        if err != nil {
 13244          return types.SignalArgs{}, err
 13245        }
 13246        result.Handler = uintptr(dataHandler)
 13247      }
 13248    }
 13249    return result, nil
 13250  }
 13251  
 13252  func ParseLockArgs(decoder *Decoder) (types.LockArgs, error) {
 13253    return types.LockArgs{}, nil
 13254  }
 13255  
 13256  func ParseMpxArgs(decoder *Decoder) (types.MpxArgs, error) {
 13257    return types.MpxArgs{}, nil
 13258  }
 13259  
 13260  func ParseUlimitArgs(decoder *Decoder) (types.UlimitArgs, error) {
 13261    return types.UlimitArgs{}, nil
 13262  }
 13263  
 13264  func ParseOldoldunameArgs(decoder *Decoder) (types.OldoldunameArgs, error) {
 13265    var result types.OldoldunameArgs
 13266    var err error
 13267  
 13268    var numArgs uint8
 13269    err = decoder.DecodeUint8(&numArgs)
 13270    if err != nil {
 13271      return types.OldoldunameArgs{}, err
 13272    }
 13273  
 13274    for arg := 0; arg < int(numArgs); arg++ {
 13275      var currArg uint8
 13276      err = decoder.DecodeUint8(&currArg)
 13277      if err != nil {
 13278        return types.OldoldunameArgs{}, err
 13279      }
 13280  
 13281      switch currArg {
 13282      case 0:
 13283        var dataName uint64
 13284        err = decoder.DecodeUint64(&dataName)
 13285        if err != nil {
 13286          return types.OldoldunameArgs{}, err
 13287        }
 13288        result.Name = uintptr(dataName)
 13289      }
 13290    }
 13291    return result, nil
 13292  }
 13293  
 13294  func ParseSigactionArgs(decoder *Decoder) (types.SigactionArgs, error) {
 13295    var result types.SigactionArgs
 13296    var err error
 13297  
 13298    var numArgs uint8
 13299    err = decoder.DecodeUint8(&numArgs)
 13300    if err != nil {
 13301      return types.SigactionArgs{}, err
 13302    }
 13303  
 13304    for arg := 0; arg < int(numArgs); arg++ {
 13305      var currArg uint8
 13306      err = decoder.DecodeUint8(&currArg)
 13307      if err != nil {
 13308        return types.SigactionArgs{}, err
 13309      }
 13310  
 13311      switch currArg {
 13312      case 0:
 13313        err = decoder.DecodeInt32(&result.Sig)
 13314        if err != nil {
 13315          return types.SigactionArgs{}, err
 13316        }
 13317      case 1:
 13318        var dataAct uint64
 13319        err = decoder.DecodeUint64(&dataAct)
 13320        if err != nil {
 13321          return types.SigactionArgs{}, err
 13322        }
 13323        result.Act = uintptr(dataAct)
 13324      case 2:
 13325        var dataOact uint64
 13326        err = decoder.DecodeUint64(&dataOact)
 13327        if err != nil {
 13328          return types.SigactionArgs{}, err
 13329        }
 13330        result.Oact = uintptr(dataOact)
 13331      }
 13332    }
 13333    return result, nil
 13334  }
 13335  
 13336  func ParseSgetmaskArgs(decoder *Decoder) (types.SgetmaskArgs, error) {
 13337    return types.SgetmaskArgs{}, nil
 13338  }
 13339  
 13340  func ParseSsetmaskArgs(decoder *Decoder) (types.SsetmaskArgs, error) {
 13341    var result types.SsetmaskArgs
 13342    var err error
 13343  
 13344    var numArgs uint8
 13345    err = decoder.DecodeUint8(&numArgs)
 13346    if err != nil {
 13347      return types.SsetmaskArgs{}, err
 13348    }
 13349  
 13350    for arg := 0; arg < int(numArgs); arg++ {
 13351      var currArg uint8
 13352      err = decoder.DecodeUint8(&currArg)
 13353      if err != nil {
 13354        return types.SsetmaskArgs{}, err
 13355      }
 13356  
 13357      switch currArg {
 13358      case 0:
 13359        err = decoder.DecodeInt64(&result.Newmask)
 13360        if err != nil {
 13361          return types.SsetmaskArgs{}, err
 13362        }
 13363      }
 13364    }
 13365    return result, nil
 13366  }
 13367  
 13368  func ParseSigsuspendArgs(decoder *Decoder) (types.SigsuspendArgs, error) {
 13369    var result types.SigsuspendArgs
 13370    var err error
 13371  
 13372    var numArgs uint8
 13373    err = decoder.DecodeUint8(&numArgs)
 13374    if err != nil {
 13375      return types.SigsuspendArgs{}, err
 13376    }
 13377  
 13378    for arg := 0; arg < int(numArgs); arg++ {
 13379      var currArg uint8
 13380      err = decoder.DecodeUint8(&currArg)
 13381      if err != nil {
 13382        return types.SigsuspendArgs{}, err
 13383      }
 13384  
 13385      switch currArg {
 13386      case 0:
 13387        var dataMask uint64
 13388        err = decoder.DecodeUint64(&dataMask)
 13389        if err != nil {
 13390          return types.SigsuspendArgs{}, err
 13391        }
 13392        result.Mask = uintptr(dataMask)
 13393      }
 13394    }
 13395    return result, nil
 13396  }
 13397  
 13398  func ParseSigpendingArgs(decoder *Decoder) (types.SigpendingArgs, error) {
 13399    var result types.SigpendingArgs
 13400    var err error
 13401  
 13402    var numArgs uint8
 13403    err = decoder.DecodeUint8(&numArgs)
 13404    if err != nil {
 13405      return types.SigpendingArgs{}, err
 13406    }
 13407  
 13408    for arg := 0; arg < int(numArgs); arg++ {
 13409      var currArg uint8
 13410      err = decoder.DecodeUint8(&currArg)
 13411      if err != nil {
 13412        return types.SigpendingArgs{}, err
 13413      }
 13414  
 13415      switch currArg {
 13416      case 0:
 13417        var dataSet uint64
 13418        err = decoder.DecodeUint64(&dataSet)
 13419        if err != nil {
 13420          return types.SigpendingArgs{}, err
 13421        }
 13422        result.Set = uintptr(dataSet)
 13423      }
 13424    }
 13425    return result, nil
 13426  }
 13427  
 13428  func ParseOldlstatArgs(decoder *Decoder) (types.OldlstatArgs, error) {
 13429    var result types.OldlstatArgs
 13430    var err error
 13431  
 13432    var numArgs uint8
 13433    err = decoder.DecodeUint8(&numArgs)
 13434    if err != nil {
 13435      return types.OldlstatArgs{}, err
 13436    }
 13437  
 13438    for arg := 0; arg < int(numArgs); arg++ {
 13439      var currArg uint8
 13440      err = decoder.DecodeUint8(&currArg)
 13441      if err != nil {
 13442        return types.OldlstatArgs{}, err
 13443      }
 13444  
 13445      switch currArg {
 13446      case 0:
 13447        result.Pathname, err = decoder.ReadStringFromBuff()
 13448        if err != nil {
 13449          return types.OldlstatArgs{}, err
 13450        }
 13451      case 1:
 13452        var dataStatbuf uint64
 13453        err = decoder.DecodeUint64(&dataStatbuf)
 13454        if err != nil {
 13455          return types.OldlstatArgs{}, err
 13456        }
 13457        result.Statbuf = uintptr(dataStatbuf)
 13458      }
 13459    }
 13460    return result, nil
 13461  }
 13462  
 13463  func ParseReaddirArgs(decoder *Decoder) (types.ReaddirArgs, error) {
 13464    var result types.ReaddirArgs
 13465    var err error
 13466  
 13467    var numArgs uint8
 13468    err = decoder.DecodeUint8(&numArgs)
 13469    if err != nil {
 13470      return types.ReaddirArgs{}, err
 13471    }
 13472  
 13473    for arg := 0; arg < int(numArgs); arg++ {
 13474      var currArg uint8
 13475      err = decoder.DecodeUint8(&currArg)
 13476      if err != nil {
 13477        return types.ReaddirArgs{}, err
 13478      }
 13479  
 13480      switch currArg {
 13481      case 0:
 13482        err = decoder.DecodeUint32(&result.Fd)
 13483        if err != nil {
 13484          return types.ReaddirArgs{}, err
 13485        }
 13486      case 1:
 13487        var dataDirp uint64
 13488        err = decoder.DecodeUint64(&dataDirp)
 13489        if err != nil {
 13490          return types.ReaddirArgs{}, err
 13491        }
 13492        result.Dirp = uintptr(dataDirp)
 13493      case 2:
 13494        err = decoder.DecodeUint32(&result.Count)
 13495        if err != nil {
 13496          return types.ReaddirArgs{}, err
 13497        }
 13498      }
 13499    }
 13500    return result, nil
 13501  }
 13502  
 13503  func ParseProfilArgs(decoder *Decoder) (types.ProfilArgs, error) {
 13504    return types.ProfilArgs{}, nil
 13505  }
 13506  
 13507  func ParseSocketcallArgs(decoder *Decoder) (types.SocketcallArgs, error) {
 13508    var result types.SocketcallArgs
 13509    var err error
 13510  
 13511    var numArgs uint8
 13512    err = decoder.DecodeUint8(&numArgs)
 13513    if err != nil {
 13514      return types.SocketcallArgs{}, err
 13515    }
 13516  
 13517    for arg := 0; arg < int(numArgs); arg++ {
 13518      var currArg uint8
 13519      err = decoder.DecodeUint8(&currArg)
 13520      if err != nil {
 13521        return types.SocketcallArgs{}, err
 13522      }
 13523  
 13524      switch currArg {
 13525      case 0:
 13526        err = decoder.DecodeInt32(&result.Call)
 13527        if err != nil {
 13528          return types.SocketcallArgs{}, err
 13529        }
 13530      case 1:
 13531        var dataArgs uint64
 13532        err = decoder.DecodeUint64(&dataArgs)
 13533        if err != nil {
 13534          return types.SocketcallArgs{}, err
 13535        }
 13536        result.Args = uintptr(dataArgs)
 13537      }
 13538    }
 13539    return result, nil
 13540  }
 13541  
 13542  func ParseOldunameArgs(decoder *Decoder) (types.OldunameArgs, error) {
 13543    var result types.OldunameArgs
 13544    var err error
 13545  
 13546    var numArgs uint8
 13547    err = decoder.DecodeUint8(&numArgs)
 13548    if err != nil {
 13549      return types.OldunameArgs{}, err
 13550    }
 13551  
 13552    for arg := 0; arg < int(numArgs); arg++ {
 13553      var currArg uint8
 13554      err = decoder.DecodeUint8(&currArg)
 13555      if err != nil {
 13556        return types.OldunameArgs{}, err
 13557      }
 13558  
 13559      switch currArg {
 13560      case 0:
 13561        var dataBuf uint64
 13562        err = decoder.DecodeUint64(&dataBuf)
 13563        if err != nil {
 13564          return types.OldunameArgs{}, err
 13565        }
 13566        result.Buf = uintptr(dataBuf)
 13567      }
 13568    }
 13569    return result, nil
 13570  }
 13571  
 13572  func ParseIdleArgs(decoder *Decoder) (types.IdleArgs, error) {
 13573    return types.IdleArgs{}, nil
 13574  }
 13575  
 13576  func ParseVm86oldArgs(decoder *Decoder) (types.Vm86oldArgs, error) {
 13577    var result types.Vm86oldArgs
 13578    var err error
 13579  
 13580    var numArgs uint8
 13581    err = decoder.DecodeUint8(&numArgs)
 13582    if err != nil {
 13583      return types.Vm86oldArgs{}, err
 13584    }
 13585  
 13586    for arg := 0; arg < int(numArgs); arg++ {
 13587      var currArg uint8
 13588      err = decoder.DecodeUint8(&currArg)
 13589      if err != nil {
 13590        return types.Vm86oldArgs{}, err
 13591      }
 13592  
 13593      switch currArg {
 13594      case 0:
 13595        var dataInfo uint64
 13596        err = decoder.DecodeUint64(&dataInfo)
 13597        if err != nil {
 13598          return types.Vm86oldArgs{}, err
 13599        }
 13600        result.Info = uintptr(dataInfo)
 13601      }
 13602    }
 13603    return result, nil
 13604  }
 13605  
 13606  func ParseIpcArgs(decoder *Decoder) (types.IpcArgs, error) {
 13607    var result types.IpcArgs
 13608    var err error
 13609  
 13610    var numArgs uint8
 13611    err = decoder.DecodeUint8(&numArgs)
 13612    if err != nil {
 13613      return types.IpcArgs{}, err
 13614    }
 13615  
 13616    for arg := 0; arg < int(numArgs); arg++ {
 13617      var currArg uint8
 13618      err = decoder.DecodeUint8(&currArg)
 13619      if err != nil {
 13620        return types.IpcArgs{}, err
 13621      }
 13622  
 13623      switch currArg {
 13624      case 0:
 13625        err = decoder.DecodeUint32(&result.Call)
 13626        if err != nil {
 13627          return types.IpcArgs{}, err
 13628        }
 13629      case 1:
 13630        err = decoder.DecodeInt32(&result.First)
 13631        if err != nil {
 13632          return types.IpcArgs{}, err
 13633        }
 13634      case 2:
 13635        err = decoder.DecodeUint64(&result.Second)
 13636        if err != nil {
 13637          return types.IpcArgs{}, err
 13638        }
 13639      case 3:
 13640        err = decoder.DecodeUint64(&result.Third)
 13641        if err != nil {
 13642          return types.IpcArgs{}, err
 13643        }
 13644      case 4:
 13645        var dataPtr uint64
 13646        err = decoder.DecodeUint64(&dataPtr)
 13647        if err != nil {
 13648          return types.IpcArgs{}, err
 13649        }
 13650        result.Ptr = uintptr(dataPtr)
 13651      case 5:
 13652        err = decoder.DecodeInt64(&result.Fifth)
 13653        if err != nil {
 13654          return types.IpcArgs{}, err
 13655        }
 13656      }
 13657    }
 13658    return result, nil
 13659  }
 13660  
 13661  func ParseSigreturnArgs(decoder *Decoder) (types.SigreturnArgs, error) {
 13662    return types.SigreturnArgs{}, nil
 13663  }
 13664  
 13665  func ParseSigprocmaskArgs(decoder *Decoder) (types.SigprocmaskArgs, error) {
 13666    var result types.SigprocmaskArgs
 13667    var err error
 13668  
 13669    var numArgs uint8
 13670    err = decoder.DecodeUint8(&numArgs)
 13671    if err != nil {
 13672      return types.SigprocmaskArgs{}, err
 13673    }
 13674  
 13675    for arg := 0; arg < int(numArgs); arg++ {
 13676      var currArg uint8
 13677      err = decoder.DecodeUint8(&currArg)
 13678      if err != nil {
 13679        return types.SigprocmaskArgs{}, err
 13680      }
 13681  
 13682      switch currArg {
 13683      case 0:
 13684        err = decoder.DecodeInt32(&result.How)
 13685        if err != nil {
 13686          return types.SigprocmaskArgs{}, err
 13687        }
 13688      case 1:
 13689        var dataSet uint64
 13690        err = decoder.DecodeUint64(&dataSet)
 13691        if err != nil {
 13692          return types.SigprocmaskArgs{}, err
 13693        }
 13694        result.Set = uintptr(dataSet)
 13695      case 2:
 13696        var dataOldset uint64
 13697        err = decoder.DecodeUint64(&dataOldset)
 13698        if err != nil {
 13699          return types.SigprocmaskArgs{}, err
 13700        }
 13701        result.Oldset = uintptr(dataOldset)
 13702      }
 13703    }
 13704    return result, nil
 13705  }
 13706  
 13707  func ParseBdflushArgs(decoder *Decoder) (types.BdflushArgs, error) {
 13708    return types.BdflushArgs{}, nil
 13709  }
 13710  
 13711  func ParseAfs_syscallArgs(decoder *Decoder) (types.Afs_syscallArgs, error) {
 13712    return types.Afs_syscallArgs{}, nil
 13713  }
 13714  
 13715  func ParseLlseekArgs(decoder *Decoder) (types.LlseekArgs, error) {
 13716    var result types.LlseekArgs
 13717    var err error
 13718  
 13719    var numArgs uint8
 13720    err = decoder.DecodeUint8(&numArgs)
 13721    if err != nil {
 13722      return types.LlseekArgs{}, err
 13723    }
 13724  
 13725    for arg := 0; arg < int(numArgs); arg++ {
 13726      var currArg uint8
 13727      err = decoder.DecodeUint8(&currArg)
 13728      if err != nil {
 13729        return types.LlseekArgs{}, err
 13730      }
 13731  
 13732      switch currArg {
 13733      case 0:
 13734        err = decoder.DecodeUint32(&result.Fd)
 13735        if err != nil {
 13736          return types.LlseekArgs{}, err
 13737        }
 13738      case 1:
 13739        err = decoder.DecodeUint64(&result.OffsetHigh)
 13740        if err != nil {
 13741          return types.LlseekArgs{}, err
 13742        }
 13743      case 2:
 13744        err = decoder.DecodeUint64(&result.OffsetLow)
 13745        if err != nil {
 13746          return types.LlseekArgs{}, err
 13747        }
 13748      case 3:
 13749        var dataResult uint64
 13750        err = decoder.DecodeUint64(&dataResult)
 13751        if err != nil {
 13752          return types.LlseekArgs{}, err
 13753        }
 13754        result.Result = uintptr(dataResult)
 13755      case 4:
 13756        err = decoder.DecodeUint32(&result.Whence)
 13757        if err != nil {
 13758          return types.LlseekArgs{}, err
 13759        }
 13760      }
 13761    }
 13762    return result, nil
 13763  }
 13764  
 13765  func ParseOldSelectArgs(decoder *Decoder) (types.OldSelectArgs, error) {
 13766    var result types.OldSelectArgs
 13767    var err error
 13768  
 13769    var numArgs uint8
 13770    err = decoder.DecodeUint8(&numArgs)
 13771    if err != nil {
 13772      return types.OldSelectArgs{}, err
 13773    }
 13774  
 13775    for arg := 0; arg < int(numArgs); arg++ {
 13776      var currArg uint8
 13777      err = decoder.DecodeUint8(&currArg)
 13778      if err != nil {
 13779        return types.OldSelectArgs{}, err
 13780      }
 13781  
 13782      switch currArg {
 13783      case 0:
 13784        err = decoder.DecodeInt32(&result.Nfds)
 13785        if err != nil {
 13786          return types.OldSelectArgs{}, err
 13787        }
 13788      case 1:
 13789        var dataReadfds uint64
 13790        err = decoder.DecodeUint64(&dataReadfds)
 13791        if err != nil {
 13792          return types.OldSelectArgs{}, err
 13793        }
 13794        result.Readfds = uintptr(dataReadfds)
 13795      case 2:
 13796        var dataWritefds uint64
 13797        err = decoder.DecodeUint64(&dataWritefds)
 13798        if err != nil {
 13799          return types.OldSelectArgs{}, err
 13800        }
 13801        result.Writefds = uintptr(dataWritefds)
 13802      case 3:
 13803        var dataExceptfds uint64
 13804        err = decoder.DecodeUint64(&dataExceptfds)
 13805        if err != nil {
 13806          return types.OldSelectArgs{}, err
 13807        }
 13808        result.Exceptfds = uintptr(dataExceptfds)
 13809      case 4:
 13810        var dataTimeout uint64
 13811        err = decoder.DecodeUint64(&dataTimeout)
 13812        if err != nil {
 13813          return types.OldSelectArgs{}, err
 13814        }
 13815        result.Timeout = uintptr(dataTimeout)
 13816      }
 13817    }
 13818    return result, nil
 13819  }
 13820  
 13821  func ParseVm86Args(decoder *Decoder) (types.Vm86Args, error) {
 13822    var result types.Vm86Args
 13823    var err error
 13824  
 13825    var numArgs uint8
 13826    err = decoder.DecodeUint8(&numArgs)
 13827    if err != nil {
 13828      return types.Vm86Args{}, err
 13829    }
 13830  
 13831    for arg := 0; arg < int(numArgs); arg++ {
 13832      var currArg uint8
 13833      err = decoder.DecodeUint8(&currArg)
 13834      if err != nil {
 13835        return types.Vm86Args{}, err
 13836      }
 13837  
 13838      switch currArg {
 13839      case 0:
 13840        err = decoder.DecodeUint64(&result.Fn)
 13841        if err != nil {
 13842          return types.Vm86Args{}, err
 13843        }
 13844      case 1:
 13845        var dataV86 uint64
 13846        err = decoder.DecodeUint64(&dataV86)
 13847        if err != nil {
 13848          return types.Vm86Args{}, err
 13849        }
 13850        result.V86 = uintptr(dataV86)
 13851      }
 13852    }
 13853    return result, nil
 13854  }
 13855  
 13856  func ParseOldGetrlimitArgs(decoder *Decoder) (types.OldGetrlimitArgs, error) {
 13857    var result types.OldGetrlimitArgs
 13858    var err error
 13859  
 13860    var numArgs uint8
 13861    err = decoder.DecodeUint8(&numArgs)
 13862    if err != nil {
 13863      return types.OldGetrlimitArgs{}, err
 13864    }
 13865  
 13866    for arg := 0; arg < int(numArgs); arg++ {
 13867      var currArg uint8
 13868      err = decoder.DecodeUint8(&currArg)
 13869      if err != nil {
 13870        return types.OldGetrlimitArgs{}, err
 13871      }
 13872  
 13873      switch currArg {
 13874      case 0:
 13875        err = decoder.DecodeInt32(&result.Resource)
 13876        if err != nil {
 13877          return types.OldGetrlimitArgs{}, err
 13878        }
 13879      case 1:
 13880        var dataRlim uint64
 13881        err = decoder.DecodeUint64(&dataRlim)
 13882        if err != nil {
 13883          return types.OldGetrlimitArgs{}, err
 13884        }
 13885        result.Rlim = uintptr(dataRlim)
 13886      }
 13887    }
 13888    return result, nil
 13889  }
 13890  
 13891  func ParseMmap2Args(decoder *Decoder) (types.Mmap2Args, error) {
 13892    var result types.Mmap2Args
 13893    var err error
 13894  
 13895    var numArgs uint8
 13896    err = decoder.DecodeUint8(&numArgs)
 13897    if err != nil {
 13898      return types.Mmap2Args{}, err
 13899    }
 13900  
 13901    for arg := 0; arg < int(numArgs); arg++ {
 13902      var currArg uint8
 13903      err = decoder.DecodeUint8(&currArg)
 13904      if err != nil {
 13905        return types.Mmap2Args{}, err
 13906      }
 13907  
 13908      switch currArg {
 13909      case 0:
 13910        err = decoder.DecodeUint64(&result.Addr)
 13911        if err != nil {
 13912          return types.Mmap2Args{}, err
 13913        }
 13914      case 1:
 13915        err = decoder.DecodeUint64(&result.Length)
 13916        if err != nil {
 13917          return types.Mmap2Args{}, err
 13918        }
 13919      case 2:
 13920        err = decoder.DecodeUint64(&result.Prot)
 13921        if err != nil {
 13922          return types.Mmap2Args{}, err
 13923        }
 13924      case 3:
 13925        err = decoder.DecodeUint64(&result.Flags)
 13926        if err != nil {
 13927          return types.Mmap2Args{}, err
 13928        }
 13929      case 4:
 13930        err = decoder.DecodeUint64(&result.Fd)
 13931        if err != nil {
 13932          return types.Mmap2Args{}, err
 13933        }
 13934      case 5:
 13935        err = decoder.DecodeUint64(&result.Pgoffset)
 13936        if err != nil {
 13937          return types.Mmap2Args{}, err
 13938        }
 13939      }
 13940    }
 13941    return result, nil
 13942  }
 13943  
 13944  func ParseTruncate64Args(decoder *Decoder) (types.Truncate64Args, error) {
 13945    var result types.Truncate64Args
 13946    var err error
 13947  
 13948    var numArgs uint8
 13949    err = decoder.DecodeUint8(&numArgs)
 13950    if err != nil {
 13951      return types.Truncate64Args{}, err
 13952    }
 13953  
 13954    for arg := 0; arg < int(numArgs); arg++ {
 13955      var currArg uint8
 13956      err = decoder.DecodeUint8(&currArg)
 13957      if err != nil {
 13958        return types.Truncate64Args{}, err
 13959      }
 13960  
 13961      switch currArg {
 13962      case 0:
 13963        result.Path, err = decoder.ReadStringFromBuff()
 13964        if err != nil {
 13965          return types.Truncate64Args{}, err
 13966        }
 13967      case 1:
 13968        err = decoder.DecodeUint64(&result.Length)
 13969        if err != nil {
 13970          return types.Truncate64Args{}, err
 13971        }
 13972      }
 13973    }
 13974    return result, nil
 13975  }
 13976  
 13977  func ParseFtruncate64Args(decoder *Decoder) (types.Ftruncate64Args, error) {
 13978    var result types.Ftruncate64Args
 13979    var err error
 13980  
 13981    var numArgs uint8
 13982    err = decoder.DecodeUint8(&numArgs)
 13983    if err != nil {
 13984      return types.Ftruncate64Args{}, err
 13985    }
 13986  
 13987    for arg := 0; arg < int(numArgs); arg++ {
 13988      var currArg uint8
 13989      err = decoder.DecodeUint8(&currArg)
 13990      if err != nil {
 13991        return types.Ftruncate64Args{}, err
 13992      }
 13993  
 13994      switch currArg {
 13995      case 0:
 13996        err = decoder.DecodeInt32(&result.Fd)
 13997        if err != nil {
 13998          return types.Ftruncate64Args{}, err
 13999        }
 14000      case 1:
 14001        err = decoder.DecodeUint64(&result.Length)
 14002        if err != nil {
 14003          return types.Ftruncate64Args{}, err
 14004        }
 14005      }
 14006    }
 14007    return result, nil
 14008  }
 14009  
 14010  func ParseStat64Args(decoder *Decoder) (types.Stat64Args, error) {
 14011    var result types.Stat64Args
 14012    var err error
 14013  
 14014    var numArgs uint8
 14015    err = decoder.DecodeUint8(&numArgs)
 14016    if err != nil {
 14017      return types.Stat64Args{}, err
 14018    }
 14019  
 14020    for arg := 0; arg < int(numArgs); arg++ {
 14021      var currArg uint8
 14022      err = decoder.DecodeUint8(&currArg)
 14023      if err != nil {
 14024        return types.Stat64Args{}, err
 14025      }
 14026  
 14027      switch currArg {
 14028      case 0:
 14029        result.Pathname, err = decoder.ReadStringFromBuff()
 14030        if err != nil {
 14031          return types.Stat64Args{}, err
 14032        }
 14033      case 1:
 14034        var dataStatbuf uint64
 14035        err = decoder.DecodeUint64(&dataStatbuf)
 14036        if err != nil {
 14037          return types.Stat64Args{}, err
 14038        }
 14039        result.Statbuf = uintptr(dataStatbuf)
 14040      }
 14041    }
 14042    return result, nil
 14043  }
 14044  
 14045  func ParseLstat64Args(decoder *Decoder) (types.Lstat64Args, error) {
 14046    var result types.Lstat64Args
 14047    var err error
 14048  
 14049    var numArgs uint8
 14050    err = decoder.DecodeUint8(&numArgs)
 14051    if err != nil {
 14052      return types.Lstat64Args{}, err
 14053    }
 14054  
 14055    for arg := 0; arg < int(numArgs); arg++ {
 14056      var currArg uint8
 14057      err = decoder.DecodeUint8(&currArg)
 14058      if err != nil {
 14059        return types.Lstat64Args{}, err
 14060      }
 14061  
 14062      switch currArg {
 14063      case 0:
 14064        result.Pathname, err = decoder.ReadStringFromBuff()
 14065        if err != nil {
 14066          return types.Lstat64Args{}, err
 14067        }
 14068      case 1:
 14069        var dataStatbuf uint64
 14070        err = decoder.DecodeUint64(&dataStatbuf)
 14071        if err != nil {
 14072          return types.Lstat64Args{}, err
 14073        }
 14074        result.Statbuf = uintptr(dataStatbuf)
 14075      }
 14076    }
 14077    return result, nil
 14078  }
 14079  
 14080  func ParseFstat64Args(decoder *Decoder) (types.Fstat64Args, error) {
 14081    var result types.Fstat64Args
 14082    var err error
 14083  
 14084    var numArgs uint8
 14085    err = decoder.DecodeUint8(&numArgs)
 14086    if err != nil {
 14087      return types.Fstat64Args{}, err
 14088    }
 14089  
 14090    for arg := 0; arg < int(numArgs); arg++ {
 14091      var currArg uint8
 14092      err = decoder.DecodeUint8(&currArg)
 14093      if err != nil {
 14094        return types.Fstat64Args{}, err
 14095      }
 14096  
 14097      switch currArg {
 14098      case 0:
 14099        err = decoder.DecodeInt32(&result.Fd)
 14100        if err != nil {
 14101          return types.Fstat64Args{}, err
 14102        }
 14103      case 1:
 14104        var dataStatbuf uint64
 14105        err = decoder.DecodeUint64(&dataStatbuf)
 14106        if err != nil {
 14107          return types.Fstat64Args{}, err
 14108        }
 14109        result.Statbuf = uintptr(dataStatbuf)
 14110      }
 14111    }
 14112    return result, nil
 14113  }
 14114  
 14115  func ParseLchown16Args(decoder *Decoder) (types.Lchown16Args, error) {
 14116    var result types.Lchown16Args
 14117    var err error
 14118  
 14119    var numArgs uint8
 14120    err = decoder.DecodeUint8(&numArgs)
 14121    if err != nil {
 14122      return types.Lchown16Args{}, err
 14123    }
 14124  
 14125    for arg := 0; arg < int(numArgs); arg++ {
 14126      var currArg uint8
 14127      err = decoder.DecodeUint8(&currArg)
 14128      if err != nil {
 14129        return types.Lchown16Args{}, err
 14130      }
 14131  
 14132      switch currArg {
 14133      case 0:
 14134        result.Pathname, err = decoder.ReadStringFromBuff()
 14135        if err != nil {
 14136          return types.Lchown16Args{}, err
 14137        }
 14138      case 1:
 14139        var dataOwner uint64
 14140        err = decoder.DecodeUint64(&dataOwner)
 14141        if err != nil {
 14142          return types.Lchown16Args{}, err
 14143        }
 14144        result.Owner = uintptr(dataOwner)
 14145      case 2:
 14146        var dataGroup uint64
 14147        err = decoder.DecodeUint64(&dataGroup)
 14148        if err != nil {
 14149          return types.Lchown16Args{}, err
 14150        }
 14151        result.Group = uintptr(dataGroup)
 14152      }
 14153    }
 14154    return result, nil
 14155  }
 14156  
 14157  func ParseGetuid16Args(decoder *Decoder) (types.Getuid16Args, error) {
 14158    return types.Getuid16Args{}, nil
 14159  }
 14160  
 14161  func ParseGetgid16Args(decoder *Decoder) (types.Getgid16Args, error) {
 14162    return types.Getgid16Args{}, nil
 14163  }
 14164  
 14165  func ParseGeteuid16Args(decoder *Decoder) (types.Geteuid16Args, error) {
 14166    return types.Geteuid16Args{}, nil
 14167  }
 14168  
 14169  func ParseGetegid16Args(decoder *Decoder) (types.Getegid16Args, error) {
 14170    return types.Getegid16Args{}, nil
 14171  }
 14172  
 14173  func ParseSetreuid16Args(decoder *Decoder) (types.Setreuid16Args, error) {
 14174    var result types.Setreuid16Args
 14175    var err error
 14176  
 14177    var numArgs uint8
 14178    err = decoder.DecodeUint8(&numArgs)
 14179    if err != nil {
 14180      return types.Setreuid16Args{}, err
 14181    }
 14182  
 14183    for arg := 0; arg < int(numArgs); arg++ {
 14184      var currArg uint8
 14185      err = decoder.DecodeUint8(&currArg)
 14186      if err != nil {
 14187        return types.Setreuid16Args{}, err
 14188      }
 14189  
 14190      switch currArg {
 14191      case 0:
 14192        var dataRuid uint64
 14193        err = decoder.DecodeUint64(&dataRuid)
 14194        if err != nil {
 14195          return types.Setreuid16Args{}, err
 14196        }
 14197        result.Ruid = uintptr(dataRuid)
 14198      case 1:
 14199        var dataEuid uint64
 14200        err = decoder.DecodeUint64(&dataEuid)
 14201        if err != nil {
 14202          return types.Setreuid16Args{}, err
 14203        }
 14204        result.Euid = uintptr(dataEuid)
 14205      }
 14206    }
 14207    return result, nil
 14208  }
 14209  
 14210  func ParseSetregid16Args(decoder *Decoder) (types.Setregid16Args, error) {
 14211    var result types.Setregid16Args
 14212    var err error
 14213  
 14214    var numArgs uint8
 14215    err = decoder.DecodeUint8(&numArgs)
 14216    if err != nil {
 14217      return types.Setregid16Args{}, err
 14218    }
 14219  
 14220    for arg := 0; arg < int(numArgs); arg++ {
 14221      var currArg uint8
 14222      err = decoder.DecodeUint8(&currArg)
 14223      if err != nil {
 14224        return types.Setregid16Args{}, err
 14225      }
 14226  
 14227      switch currArg {
 14228      case 0:
 14229        var dataRgid uint64
 14230        err = decoder.DecodeUint64(&dataRgid)
 14231        if err != nil {
 14232          return types.Setregid16Args{}, err
 14233        }
 14234        result.Rgid = uintptr(dataRgid)
 14235      case 1:
 14236        var dataEgid uint64
 14237        err = decoder.DecodeUint64(&dataEgid)
 14238        if err != nil {
 14239          return types.Setregid16Args{}, err
 14240        }
 14241        result.Egid = uintptr(dataEgid)
 14242      }
 14243    }
 14244    return result, nil
 14245  }
 14246  
 14247  func ParseGetgroups16Args(decoder *Decoder) (types.Getgroups16Args, error) {
 14248    var result types.Getgroups16Args
 14249    var err error
 14250  
 14251    var numArgs uint8
 14252    err = decoder.DecodeUint8(&numArgs)
 14253    if err != nil {
 14254      return types.Getgroups16Args{}, err
 14255    }
 14256  
 14257    for arg := 0; arg < int(numArgs); arg++ {
 14258      var currArg uint8
 14259      err = decoder.DecodeUint8(&currArg)
 14260      if err != nil {
 14261        return types.Getgroups16Args{}, err
 14262      }
 14263  
 14264      switch currArg {
 14265      case 0:
 14266        err = decoder.DecodeInt32(&result.Size)
 14267        if err != nil {
 14268          return types.Getgroups16Args{}, err
 14269        }
 14270      case 1:
 14271        var dataList uint64
 14272        err = decoder.DecodeUint64(&dataList)
 14273        if err != nil {
 14274          return types.Getgroups16Args{}, err
 14275        }
 14276        result.List = uintptr(dataList)
 14277      }
 14278    }
 14279    return result, nil
 14280  }
 14281  
 14282  func ParseSetgroups16Args(decoder *Decoder) (types.Setgroups16Args, error) {
 14283    var result types.Setgroups16Args
 14284    var err error
 14285  
 14286    var numArgs uint8
 14287    err = decoder.DecodeUint8(&numArgs)
 14288    if err != nil {
 14289      return types.Setgroups16Args{}, err
 14290    }
 14291  
 14292    for arg := 0; arg < int(numArgs); arg++ {
 14293      var currArg uint8
 14294      err = decoder.DecodeUint8(&currArg)
 14295      if err != nil {
 14296        return types.Setgroups16Args{}, err
 14297      }
 14298  
 14299      switch currArg {
 14300      case 0:
 14301        err = decoder.DecodeUint64(&result.Size)
 14302        if err != nil {
 14303          return types.Setgroups16Args{}, err
 14304        }
 14305      case 1:
 14306        var dataList uint64
 14307        err = decoder.DecodeUint64(&dataList)
 14308        if err != nil {
 14309          return types.Setgroups16Args{}, err
 14310        }
 14311        result.List = uintptr(dataList)
 14312      }
 14313    }
 14314    return result, nil
 14315  }
 14316  
 14317  func ParseFchown16Args(decoder *Decoder) (types.Fchown16Args, error) {
 14318    var result types.Fchown16Args
 14319    var err error
 14320  
 14321    var numArgs uint8
 14322    err = decoder.DecodeUint8(&numArgs)
 14323    if err != nil {
 14324      return types.Fchown16Args{}, err
 14325    }
 14326  
 14327    for arg := 0; arg < int(numArgs); arg++ {
 14328      var currArg uint8
 14329      err = decoder.DecodeUint8(&currArg)
 14330      if err != nil {
 14331        return types.Fchown16Args{}, err
 14332      }
 14333  
 14334      switch currArg {
 14335      case 0:
 14336        err = decoder.DecodeUint32(&result.Fd)
 14337        if err != nil {
 14338          return types.Fchown16Args{}, err
 14339        }
 14340      case 1:
 14341        var dataUser uint64
 14342        err = decoder.DecodeUint64(&dataUser)
 14343        if err != nil {
 14344          return types.Fchown16Args{}, err
 14345        }
 14346        result.User = uintptr(dataUser)
 14347      case 2:
 14348        var dataGroup uint64
 14349        err = decoder.DecodeUint64(&dataGroup)
 14350        if err != nil {
 14351          return types.Fchown16Args{}, err
 14352        }
 14353        result.Group = uintptr(dataGroup)
 14354      }
 14355    }
 14356    return result, nil
 14357  }
 14358  
 14359  func ParseSetresuid16Args(decoder *Decoder) (types.Setresuid16Args, error) {
 14360    var result types.Setresuid16Args
 14361    var err error
 14362  
 14363    var numArgs uint8
 14364    err = decoder.DecodeUint8(&numArgs)
 14365    if err != nil {
 14366      return types.Setresuid16Args{}, err
 14367    }
 14368  
 14369    for arg := 0; arg < int(numArgs); arg++ {
 14370      var currArg uint8
 14371      err = decoder.DecodeUint8(&currArg)
 14372      if err != nil {
 14373        return types.Setresuid16Args{}, err
 14374      }
 14375  
 14376      switch currArg {
 14377      case 0:
 14378        var dataRuid uint64
 14379        err = decoder.DecodeUint64(&dataRuid)
 14380        if err != nil {
 14381          return types.Setresuid16Args{}, err
 14382        }
 14383        result.Ruid = uintptr(dataRuid)
 14384      case 1:
 14385        var dataEuid uint64
 14386        err = decoder.DecodeUint64(&dataEuid)
 14387        if err != nil {
 14388          return types.Setresuid16Args{}, err
 14389        }
 14390        result.Euid = uintptr(dataEuid)
 14391      case 2:
 14392        var dataSuid uint64
 14393        err = decoder.DecodeUint64(&dataSuid)
 14394        if err != nil {
 14395          return types.Setresuid16Args{}, err
 14396        }
 14397        result.Suid = uintptr(dataSuid)
 14398      }
 14399    }
 14400    return result, nil
 14401  }
 14402  
 14403  func ParseGetresuid16Args(decoder *Decoder) (types.Getresuid16Args, error) {
 14404    var result types.Getresuid16Args
 14405    var err error
 14406  
 14407    var numArgs uint8
 14408    err = decoder.DecodeUint8(&numArgs)
 14409    if err != nil {
 14410      return types.Getresuid16Args{}, err
 14411    }
 14412  
 14413    for arg := 0; arg < int(numArgs); arg++ {
 14414      var currArg uint8
 14415      err = decoder.DecodeUint8(&currArg)
 14416      if err != nil {
 14417        return types.Getresuid16Args{}, err
 14418      }
 14419  
 14420      switch currArg {
 14421      case 0:
 14422        var dataRuid uint64
 14423        err = decoder.DecodeUint64(&dataRuid)
 14424        if err != nil {
 14425          return types.Getresuid16Args{}, err
 14426        }
 14427        result.Ruid = uintptr(dataRuid)
 14428      case 1:
 14429        var dataEuid uint64
 14430        err = decoder.DecodeUint64(&dataEuid)
 14431        if err != nil {
 14432          return types.Getresuid16Args{}, err
 14433        }
 14434        result.Euid = uintptr(dataEuid)
 14435      case 2:
 14436        var dataSuid uint64
 14437        err = decoder.DecodeUint64(&dataSuid)
 14438        if err != nil {
 14439          return types.Getresuid16Args{}, err
 14440        }
 14441        result.Suid = uintptr(dataSuid)
 14442      }
 14443    }
 14444    return result, nil
 14445  }
 14446  
 14447  func ParseSetresgid16Args(decoder *Decoder) (types.Setresgid16Args, error) {
 14448    var result types.Setresgid16Args
 14449    var err error
 14450  
 14451    var numArgs uint8
 14452    err = decoder.DecodeUint8(&numArgs)
 14453    if err != nil {
 14454      return types.Setresgid16Args{}, err
 14455    }
 14456  
 14457    for arg := 0; arg < int(numArgs); arg++ {
 14458      var currArg uint8
 14459      err = decoder.DecodeUint8(&currArg)
 14460      if err != nil {
 14461        return types.Setresgid16Args{}, err
 14462      }
 14463  
 14464      switch currArg {
 14465      case 0:
 14466        var dataRgid uint64
 14467        err = decoder.DecodeUint64(&dataRgid)
 14468        if err != nil {
 14469          return types.Setresgid16Args{}, err
 14470        }
 14471        result.Rgid = uintptr(dataRgid)
 14472      case 1:
 14473        var dataEuid uint64
 14474        err = decoder.DecodeUint64(&dataEuid)
 14475        if err != nil {
 14476          return types.Setresgid16Args{}, err
 14477        }
 14478        result.Euid = uintptr(dataEuid)
 14479      case 2:
 14480        var dataSuid uint64
 14481        err = decoder.DecodeUint64(&dataSuid)
 14482        if err != nil {
 14483          return types.Setresgid16Args{}, err
 14484        }
 14485        result.Suid = uintptr(dataSuid)
 14486      }
 14487    }
 14488    return result, nil
 14489  }
 14490  
 14491  func ParseGetresgid16Args(decoder *Decoder) (types.Getresgid16Args, error) {
 14492    var result types.Getresgid16Args
 14493    var err error
 14494  
 14495    var numArgs uint8
 14496    err = decoder.DecodeUint8(&numArgs)
 14497    if err != nil {
 14498      return types.Getresgid16Args{}, err
 14499    }
 14500  
 14501    for arg := 0; arg < int(numArgs); arg++ {
 14502      var currArg uint8
 14503      err = decoder.DecodeUint8(&currArg)
 14504      if err != nil {
 14505        return types.Getresgid16Args{}, err
 14506      }
 14507  
 14508      switch currArg {
 14509      case 0:
 14510        var dataRgid uint64
 14511        err = decoder.DecodeUint64(&dataRgid)
 14512        if err != nil {
 14513          return types.Getresgid16Args{}, err
 14514        }
 14515        result.Rgid = uintptr(dataRgid)
 14516      case 1:
 14517        var dataEgid uint64
 14518        err = decoder.DecodeUint64(&dataEgid)
 14519        if err != nil {
 14520          return types.Getresgid16Args{}, err
 14521        }
 14522        result.Egid = uintptr(dataEgid)
 14523      case 2:
 14524        var dataSgid uint64
 14525        err = decoder.DecodeUint64(&dataSgid)
 14526        if err != nil {
 14527          return types.Getresgid16Args{}, err
 14528        }
 14529        result.Sgid = uintptr(dataSgid)
 14530      }
 14531    }
 14532    return result, nil
 14533  }
 14534  
 14535  func ParseChown16Args(decoder *Decoder) (types.Chown16Args, error) {
 14536    var result types.Chown16Args
 14537    var err error
 14538  
 14539    var numArgs uint8
 14540    err = decoder.DecodeUint8(&numArgs)
 14541    if err != nil {
 14542      return types.Chown16Args{}, err
 14543    }
 14544  
 14545    for arg := 0; arg < int(numArgs); arg++ {
 14546      var currArg uint8
 14547      err = decoder.DecodeUint8(&currArg)
 14548      if err != nil {
 14549        return types.Chown16Args{}, err
 14550      }
 14551  
 14552      switch currArg {
 14553      case 0:
 14554        result.Pathname, err = decoder.ReadStringFromBuff()
 14555        if err != nil {
 14556          return types.Chown16Args{}, err
 14557        }
 14558      case 1:
 14559        var dataOwner uint64
 14560        err = decoder.DecodeUint64(&dataOwner)
 14561        if err != nil {
 14562          return types.Chown16Args{}, err
 14563        }
 14564        result.Owner = uintptr(dataOwner)
 14565      case 2:
 14566        var dataGroup uint64
 14567        err = decoder.DecodeUint64(&dataGroup)
 14568        if err != nil {
 14569          return types.Chown16Args{}, err
 14570        }
 14571        result.Group = uintptr(dataGroup)
 14572      }
 14573    }
 14574    return result, nil
 14575  }
 14576  
 14577  func ParseSetuid16Args(decoder *Decoder) (types.Setuid16Args, error) {
 14578    var result types.Setuid16Args
 14579    var err error
 14580  
 14581    var numArgs uint8
 14582    err = decoder.DecodeUint8(&numArgs)
 14583    if err != nil {
 14584      return types.Setuid16Args{}, err
 14585    }
 14586  
 14587    for arg := 0; arg < int(numArgs); arg++ {
 14588      var currArg uint8
 14589      err = decoder.DecodeUint8(&currArg)
 14590      if err != nil {
 14591        return types.Setuid16Args{}, err
 14592      }
 14593  
 14594      switch currArg {
 14595      case 0:
 14596        var dataUid uint64
 14597        err = decoder.DecodeUint64(&dataUid)
 14598        if err != nil {
 14599          return types.Setuid16Args{}, err
 14600        }
 14601        result.Uid = uintptr(dataUid)
 14602      }
 14603    }
 14604    return result, nil
 14605  }
 14606  
 14607  func ParseSetgid16Args(decoder *Decoder) (types.Setgid16Args, error) {
 14608    var result types.Setgid16Args
 14609    var err error
 14610  
 14611    var numArgs uint8
 14612    err = decoder.DecodeUint8(&numArgs)
 14613    if err != nil {
 14614      return types.Setgid16Args{}, err
 14615    }
 14616  
 14617    for arg := 0; arg < int(numArgs); arg++ {
 14618      var currArg uint8
 14619      err = decoder.DecodeUint8(&currArg)
 14620      if err != nil {
 14621        return types.Setgid16Args{}, err
 14622      }
 14623  
 14624      switch currArg {
 14625      case 0:
 14626        var dataGid uint64
 14627        err = decoder.DecodeUint64(&dataGid)
 14628        if err != nil {
 14629          return types.Setgid16Args{}, err
 14630        }
 14631        result.Gid = uintptr(dataGid)
 14632      }
 14633    }
 14634    return result, nil
 14635  }
 14636  
 14637  func ParseSetfsuid16Args(decoder *Decoder) (types.Setfsuid16Args, error) {
 14638    var result types.Setfsuid16Args
 14639    var err error
 14640  
 14641    var numArgs uint8
 14642    err = decoder.DecodeUint8(&numArgs)
 14643    if err != nil {
 14644      return types.Setfsuid16Args{}, err
 14645    }
 14646  
 14647    for arg := 0; arg < int(numArgs); arg++ {
 14648      var currArg uint8
 14649      err = decoder.DecodeUint8(&currArg)
 14650      if err != nil {
 14651        return types.Setfsuid16Args{}, err
 14652      }
 14653  
 14654      switch currArg {
 14655      case 0:
 14656        var dataFsuid uint64
 14657        err = decoder.DecodeUint64(&dataFsuid)
 14658        if err != nil {
 14659          return types.Setfsuid16Args{}, err
 14660        }
 14661        result.Fsuid = uintptr(dataFsuid)
 14662      }
 14663    }
 14664    return result, nil
 14665  }
 14666  
 14667  func ParseSetfsgid16Args(decoder *Decoder) (types.Setfsgid16Args, error) {
 14668    var result types.Setfsgid16Args
 14669    var err error
 14670  
 14671    var numArgs uint8
 14672    err = decoder.DecodeUint8(&numArgs)
 14673    if err != nil {
 14674      return types.Setfsgid16Args{}, err
 14675    }
 14676  
 14677    for arg := 0; arg < int(numArgs); arg++ {
 14678      var currArg uint8
 14679      err = decoder.DecodeUint8(&currArg)
 14680      if err != nil {
 14681        return types.Setfsgid16Args{}, err
 14682      }
 14683  
 14684      switch currArg {
 14685      case 0:
 14686        var dataFsgid uint64
 14687        err = decoder.DecodeUint64(&dataFsgid)
 14688        if err != nil {
 14689          return types.Setfsgid16Args{}, err
 14690        }
 14691        result.Fsgid = uintptr(dataFsgid)
 14692      }
 14693    }
 14694    return result, nil
 14695  }
 14696  
 14697  func ParseFcntl64Args(decoder *Decoder) (types.Fcntl64Args, error) {
 14698    var result types.Fcntl64Args
 14699    var err error
 14700  
 14701    var numArgs uint8
 14702    err = decoder.DecodeUint8(&numArgs)
 14703    if err != nil {
 14704      return types.Fcntl64Args{}, err
 14705    }
 14706  
 14707    for arg := 0; arg < int(numArgs); arg++ {
 14708      var currArg uint8
 14709      err = decoder.DecodeUint8(&currArg)
 14710      if err != nil {
 14711        return types.Fcntl64Args{}, err
 14712      }
 14713  
 14714      switch currArg {
 14715      case 0:
 14716        err = decoder.DecodeInt32(&result.Fd)
 14717        if err != nil {
 14718          return types.Fcntl64Args{}, err
 14719        }
 14720      case 1:
 14721        err = decoder.DecodeInt32(&result.Cmd)
 14722        if err != nil {
 14723          return types.Fcntl64Args{}, err
 14724        }
 14725      case 2:
 14726        err = decoder.DecodeUint64(&result.Arg)
 14727        if err != nil {
 14728          return types.Fcntl64Args{}, err
 14729        }
 14730      }
 14731    }
 14732    return result, nil
 14733  }
 14734  
 14735  func ParseSendfile32Args(decoder *Decoder) (types.Sendfile32Args, error) {
 14736    var result types.Sendfile32Args
 14737    var err error
 14738  
 14739    var numArgs uint8
 14740    err = decoder.DecodeUint8(&numArgs)
 14741    if err != nil {
 14742      return types.Sendfile32Args{}, err
 14743    }
 14744  
 14745    for arg := 0; arg < int(numArgs); arg++ {
 14746      var currArg uint8
 14747      err = decoder.DecodeUint8(&currArg)
 14748      if err != nil {
 14749        return types.Sendfile32Args{}, err
 14750      }
 14751  
 14752      switch currArg {
 14753      case 0:
 14754        err = decoder.DecodeInt32(&result.OutFd)
 14755        if err != nil {
 14756          return types.Sendfile32Args{}, err
 14757        }
 14758      case 1:
 14759        err = decoder.DecodeInt32(&result.InFd)
 14760        if err != nil {
 14761          return types.Sendfile32Args{}, err
 14762        }
 14763      case 2:
 14764        var dataOffset uint64
 14765        err = decoder.DecodeUint64(&dataOffset)
 14766        if err != nil {
 14767          return types.Sendfile32Args{}, err
 14768        }
 14769        result.Offset = uintptr(dataOffset)
 14770      case 3:
 14771        err = decoder.DecodeUint64(&result.Count)
 14772        if err != nil {
 14773          return types.Sendfile32Args{}, err
 14774        }
 14775      }
 14776    }
 14777    return result, nil
 14778  }
 14779  
 14780  func ParseStatfs64Args(decoder *Decoder) (types.Statfs64Args, error) {
 14781    var result types.Statfs64Args
 14782    var err error
 14783  
 14784    var numArgs uint8
 14785    err = decoder.DecodeUint8(&numArgs)
 14786    if err != nil {
 14787      return types.Statfs64Args{}, err
 14788    }
 14789  
 14790    for arg := 0; arg < int(numArgs); arg++ {
 14791      var currArg uint8
 14792      err = decoder.DecodeUint8(&currArg)
 14793      if err != nil {
 14794        return types.Statfs64Args{}, err
 14795      }
 14796  
 14797      switch currArg {
 14798      case 0:
 14799        result.Path, err = decoder.ReadStringFromBuff()
 14800        if err != nil {
 14801          return types.Statfs64Args{}, err
 14802        }
 14803      case 1:
 14804        err = decoder.DecodeUint64(&result.Sz)
 14805        if err != nil {
 14806          return types.Statfs64Args{}, err
 14807        }
 14808      case 2:
 14809        var dataBuf uint64
 14810        err = decoder.DecodeUint64(&dataBuf)
 14811        if err != nil {
 14812          return types.Statfs64Args{}, err
 14813        }
 14814        result.Buf = uintptr(dataBuf)
 14815      }
 14816    }
 14817    return result, nil
 14818  }
 14819  
 14820  func ParseFstatfs64Args(decoder *Decoder) (types.Fstatfs64Args, error) {
 14821    var result types.Fstatfs64Args
 14822    var err error
 14823  
 14824    var numArgs uint8
 14825    err = decoder.DecodeUint8(&numArgs)
 14826    if err != nil {
 14827      return types.Fstatfs64Args{}, err
 14828    }
 14829  
 14830    for arg := 0; arg < int(numArgs); arg++ {
 14831      var currArg uint8
 14832      err = decoder.DecodeUint8(&currArg)
 14833      if err != nil {
 14834        return types.Fstatfs64Args{}, err
 14835      }
 14836  
 14837      switch currArg {
 14838      case 0:
 14839        err = decoder.DecodeInt32(&result.Fd)
 14840        if err != nil {
 14841          return types.Fstatfs64Args{}, err
 14842        }
 14843      case 1:
 14844        err = decoder.DecodeUint64(&result.Sz)
 14845        if err != nil {
 14846          return types.Fstatfs64Args{}, err
 14847        }
 14848      case 2:
 14849        var dataBuf uint64
 14850        err = decoder.DecodeUint64(&dataBuf)
 14851        if err != nil {
 14852          return types.Fstatfs64Args{}, err
 14853        }
 14854        result.Buf = uintptr(dataBuf)
 14855      }
 14856    }
 14857    return result, nil
 14858  }
 14859  
 14860  func ParseFadvise64_64Args(decoder *Decoder) (types.Fadvise64_64Args, error) {
 14861    var result types.Fadvise64_64Args
 14862    var err error
 14863  
 14864    var numArgs uint8
 14865    err = decoder.DecodeUint8(&numArgs)
 14866    if err != nil {
 14867      return types.Fadvise64_64Args{}, err
 14868    }
 14869  
 14870    for arg := 0; arg < int(numArgs); arg++ {
 14871      var currArg uint8
 14872      err = decoder.DecodeUint8(&currArg)
 14873      if err != nil {
 14874        return types.Fadvise64_64Args{}, err
 14875      }
 14876  
 14877      switch currArg {
 14878      case 0:
 14879        err = decoder.DecodeInt32(&result.Fd)
 14880        if err != nil {
 14881          return types.Fadvise64_64Args{}, err
 14882        }
 14883      case 1:
 14884        err = decoder.DecodeUint64(&result.Offset)
 14885        if err != nil {
 14886          return types.Fadvise64_64Args{}, err
 14887        }
 14888      case 2:
 14889        err = decoder.DecodeUint64(&result.Len)
 14890        if err != nil {
 14891          return types.Fadvise64_64Args{}, err
 14892        }
 14893      case 3:
 14894        err = decoder.DecodeInt32(&result.Advice)
 14895        if err != nil {
 14896          return types.Fadvise64_64Args{}, err
 14897        }
 14898      }
 14899    }
 14900    return result, nil
 14901  }
 14902  
 14903  func ParseClockGettime32Args(decoder *Decoder) (types.ClockGettime32Args, error) {
 14904    var result types.ClockGettime32Args
 14905    var err error
 14906  
 14907    var numArgs uint8
 14908    err = decoder.DecodeUint8(&numArgs)
 14909    if err != nil {
 14910      return types.ClockGettime32Args{}, err
 14911    }
 14912  
 14913    for arg := 0; arg < int(numArgs); arg++ {
 14914      var currArg uint8
 14915      err = decoder.DecodeUint8(&currArg)
 14916      if err != nil {
 14917        return types.ClockGettime32Args{}, err
 14918      }
 14919  
 14920      switch currArg {
 14921      case 0:
 14922        err = decoder.DecodeInt32(&result.WhichClock)
 14923        if err != nil {
 14924          return types.ClockGettime32Args{}, err
 14925        }
 14926      case 1:
 14927        var dataTp uint64
 14928        err = decoder.DecodeUint64(&dataTp)
 14929        if err != nil {
 14930          return types.ClockGettime32Args{}, err
 14931        }
 14932        result.Tp = uintptr(dataTp)
 14933      }
 14934    }
 14935    return result, nil
 14936  }
 14937  
 14938  func ParseClockSettime32Args(decoder *Decoder) (types.ClockSettime32Args, error) {
 14939    var result types.ClockSettime32Args
 14940    var err error
 14941  
 14942    var numArgs uint8
 14943    err = decoder.DecodeUint8(&numArgs)
 14944    if err != nil {
 14945      return types.ClockSettime32Args{}, err
 14946    }
 14947  
 14948    for arg := 0; arg < int(numArgs); arg++ {
 14949      var currArg uint8
 14950      err = decoder.DecodeUint8(&currArg)
 14951      if err != nil {
 14952        return types.ClockSettime32Args{}, err
 14953      }
 14954  
 14955      switch currArg {
 14956      case 0:
 14957        err = decoder.DecodeInt32(&result.WhichClock)
 14958        if err != nil {
 14959          return types.ClockSettime32Args{}, err
 14960        }
 14961      case 1:
 14962        var dataTp uint64
 14963        err = decoder.DecodeUint64(&dataTp)
 14964        if err != nil {
 14965          return types.ClockSettime32Args{}, err
 14966        }
 14967        result.Tp = uintptr(dataTp)
 14968      }
 14969    }
 14970    return result, nil
 14971  }
 14972  
 14973  func ParseClockAdjtime64Args(decoder *Decoder) (types.ClockAdjtime64Args, error) {
 14974    return types.ClockAdjtime64Args{}, nil
 14975  }
 14976  
 14977  func ParseClockGetresTime32Args(decoder *Decoder) (types.ClockGetresTime32Args, error) {
 14978    var result types.ClockGetresTime32Args
 14979    var err error
 14980  
 14981    var numArgs uint8
 14982    err = decoder.DecodeUint8(&numArgs)
 14983    if err != nil {
 14984      return types.ClockGetresTime32Args{}, err
 14985    }
 14986  
 14987    for arg := 0; arg < int(numArgs); arg++ {
 14988      var currArg uint8
 14989      err = decoder.DecodeUint8(&currArg)
 14990      if err != nil {
 14991        return types.ClockGetresTime32Args{}, err
 14992      }
 14993  
 14994      switch currArg {
 14995      case 0:
 14996        err = decoder.DecodeInt32(&result.WhichClock)
 14997        if err != nil {
 14998          return types.ClockGetresTime32Args{}, err
 14999        }
 15000      case 1:
 15001        var dataTp uint64
 15002        err = decoder.DecodeUint64(&dataTp)
 15003        if err != nil {
 15004          return types.ClockGetresTime32Args{}, err
 15005        }
 15006        result.Tp = uintptr(dataTp)
 15007      }
 15008    }
 15009    return result, nil
 15010  }
 15011  
 15012  func ParseClockNanosleepTime32Args(decoder *Decoder) (types.ClockNanosleepTime32Args, error) {
 15013    var result types.ClockNanosleepTime32Args
 15014    var err error
 15015  
 15016    var numArgs uint8
 15017    err = decoder.DecodeUint8(&numArgs)
 15018    if err != nil {
 15019      return types.ClockNanosleepTime32Args{}, err
 15020    }
 15021  
 15022    for arg := 0; arg < int(numArgs); arg++ {
 15023      var currArg uint8
 15024      err = decoder.DecodeUint8(&currArg)
 15025      if err != nil {
 15026        return types.ClockNanosleepTime32Args{}, err
 15027      }
 15028  
 15029      switch currArg {
 15030      case 0:
 15031        err = decoder.DecodeInt32(&result.WhichClock)
 15032        if err != nil {
 15033          return types.ClockNanosleepTime32Args{}, err
 15034        }
 15035      case 1:
 15036        err = decoder.DecodeInt32(&result.Flags)
 15037        if err != nil {
 15038          return types.ClockNanosleepTime32Args{}, err
 15039        }
 15040      case 2:
 15041        var dataRqtp uint64
 15042        err = decoder.DecodeUint64(&dataRqtp)
 15043        if err != nil {
 15044          return types.ClockNanosleepTime32Args{}, err
 15045        }
 15046        result.Rqtp = uintptr(dataRqtp)
 15047      case 3:
 15048        var dataRmtp uint64
 15049        err = decoder.DecodeUint64(&dataRmtp)
 15050        if err != nil {
 15051          return types.ClockNanosleepTime32Args{}, err
 15052        }
 15053        result.Rmtp = uintptr(dataRmtp)
 15054      }
 15055    }
 15056    return result, nil
 15057  }
 15058  
 15059  func ParseTimerGettime32Args(decoder *Decoder) (types.TimerGettime32Args, error) {
 15060    var result types.TimerGettime32Args
 15061    var err error
 15062  
 15063    var numArgs uint8
 15064    err = decoder.DecodeUint8(&numArgs)
 15065    if err != nil {
 15066      return types.TimerGettime32Args{}, err
 15067    }
 15068  
 15069    for arg := 0; arg < int(numArgs); arg++ {
 15070      var currArg uint8
 15071      err = decoder.DecodeUint8(&currArg)
 15072      if err != nil {
 15073        return types.TimerGettime32Args{}, err
 15074      }
 15075  
 15076      switch currArg {
 15077      case 0:
 15078        err = decoder.DecodeInt32(&result.TimerId)
 15079        if err != nil {
 15080          return types.TimerGettime32Args{}, err
 15081        }
 15082      case 1:
 15083        var dataSetting uint64
 15084        err = decoder.DecodeUint64(&dataSetting)
 15085        if err != nil {
 15086          return types.TimerGettime32Args{}, err
 15087        }
 15088        result.Setting = uintptr(dataSetting)
 15089      }
 15090    }
 15091    return result, nil
 15092  }
 15093  
 15094  func ParseTimerSettime32Args(decoder *Decoder) (types.TimerSettime32Args, error) {
 15095    var result types.TimerSettime32Args
 15096    var err error
 15097  
 15098    var numArgs uint8
 15099    err = decoder.DecodeUint8(&numArgs)
 15100    if err != nil {
 15101      return types.TimerSettime32Args{}, err
 15102    }
 15103  
 15104    for arg := 0; arg < int(numArgs); arg++ {
 15105      var currArg uint8
 15106      err = decoder.DecodeUint8(&currArg)
 15107      if err != nil {
 15108        return types.TimerSettime32Args{}, err
 15109      }
 15110  
 15111      switch currArg {
 15112      case 0:
 15113        err = decoder.DecodeInt32(&result.TimerId)
 15114        if err != nil {
 15115          return types.TimerSettime32Args{}, err
 15116        }
 15117      case 1:
 15118        err = decoder.DecodeInt32(&result.Flags)
 15119        if err != nil {
 15120          return types.TimerSettime32Args{}, err
 15121        }
 15122      case 2:
 15123        var dataNew uint64
 15124        err = decoder.DecodeUint64(&dataNew)
 15125        if err != nil {
 15126          return types.TimerSettime32Args{}, err
 15127        }
 15128        result.New = uintptr(dataNew)
 15129      case 3:
 15130        var dataOld uint64
 15131        err = decoder.DecodeUint64(&dataOld)
 15132        if err != nil {
 15133          return types.TimerSettime32Args{}, err
 15134        }
 15135        result.Old = uintptr(dataOld)
 15136      }
 15137    }
 15138    return result, nil
 15139  }
 15140  
 15141  func ParseTimerfdGettime32Args(decoder *Decoder) (types.TimerfdGettime32Args, error) {
 15142    var result types.TimerfdGettime32Args
 15143    var err error
 15144  
 15145    var numArgs uint8
 15146    err = decoder.DecodeUint8(&numArgs)
 15147    if err != nil {
 15148      return types.TimerfdGettime32Args{}, err
 15149    }
 15150  
 15151    for arg := 0; arg < int(numArgs); arg++ {
 15152      var currArg uint8
 15153      err = decoder.DecodeUint8(&currArg)
 15154      if err != nil {
 15155        return types.TimerfdGettime32Args{}, err
 15156      }
 15157  
 15158      switch currArg {
 15159      case 0:
 15160        err = decoder.DecodeInt32(&result.Ufd)
 15161        if err != nil {
 15162          return types.TimerfdGettime32Args{}, err
 15163        }
 15164      case 1:
 15165        var dataOtmr uint64
 15166        err = decoder.DecodeUint64(&dataOtmr)
 15167        if err != nil {
 15168          return types.TimerfdGettime32Args{}, err
 15169        }
 15170        result.Otmr = uintptr(dataOtmr)
 15171      }
 15172    }
 15173    return result, nil
 15174  }
 15175  
 15176  func ParseTimerfdSettime32Args(decoder *Decoder) (types.TimerfdSettime32Args, error) {
 15177    var result types.TimerfdSettime32Args
 15178    var err error
 15179  
 15180    var numArgs uint8
 15181    err = decoder.DecodeUint8(&numArgs)
 15182    if err != nil {
 15183      return types.TimerfdSettime32Args{}, err
 15184    }
 15185  
 15186    for arg := 0; arg < int(numArgs); arg++ {
 15187      var currArg uint8
 15188      err = decoder.DecodeUint8(&currArg)
 15189      if err != nil {
 15190        return types.TimerfdSettime32Args{}, err
 15191      }
 15192  
 15193      switch currArg {
 15194      case 0:
 15195        err = decoder.DecodeInt32(&result.Ufd)
 15196        if err != nil {
 15197          return types.TimerfdSettime32Args{}, err
 15198        }
 15199      case 1:
 15200        err = decoder.DecodeInt32(&result.Flags)
 15201        if err != nil {
 15202          return types.TimerfdSettime32Args{}, err
 15203        }
 15204      case 2:
 15205        var dataUtmr uint64
 15206        err = decoder.DecodeUint64(&dataUtmr)
 15207        if err != nil {
 15208          return types.TimerfdSettime32Args{}, err
 15209        }
 15210        result.Utmr = uintptr(dataUtmr)
 15211      case 3:
 15212        var dataOtmr uint64
 15213        err = decoder.DecodeUint64(&dataOtmr)
 15214        if err != nil {
 15215          return types.TimerfdSettime32Args{}, err
 15216        }
 15217        result.Otmr = uintptr(dataOtmr)
 15218      }
 15219    }
 15220    return result, nil
 15221  }
 15222  
 15223  func ParseUtimensatTime32Args(decoder *Decoder) (types.UtimensatTime32Args, error) {
 15224    var result types.UtimensatTime32Args
 15225    var err error
 15226  
 15227    var numArgs uint8
 15228    err = decoder.DecodeUint8(&numArgs)
 15229    if err != nil {
 15230      return types.UtimensatTime32Args{}, err
 15231    }
 15232  
 15233    for arg := 0; arg < int(numArgs); arg++ {
 15234      var currArg uint8
 15235      err = decoder.DecodeUint8(&currArg)
 15236      if err != nil {
 15237        return types.UtimensatTime32Args{}, err
 15238      }
 15239  
 15240      switch currArg {
 15241      case 0:
 15242        err = decoder.DecodeUint32(&result.Dfd)
 15243        if err != nil {
 15244          return types.UtimensatTime32Args{}, err
 15245        }
 15246      case 1:
 15247        result.Filename, err = decoder.ReadStringFromBuff()
 15248        if err != nil {
 15249          return types.UtimensatTime32Args{}, err
 15250        }
 15251      case 2:
 15252        var dataT uint64
 15253        err = decoder.DecodeUint64(&dataT)
 15254        if err != nil {
 15255          return types.UtimensatTime32Args{}, err
 15256        }
 15257        result.T = uintptr(dataT)
 15258      case 3:
 15259        err = decoder.DecodeInt32(&result.Flags)
 15260        if err != nil {
 15261          return types.UtimensatTime32Args{}, err
 15262        }
 15263      }
 15264    }
 15265    return result, nil
 15266  }
 15267  
 15268  func ParsePselect6Time32Args(decoder *Decoder) (types.Pselect6Time32Args, error) {
 15269    var result types.Pselect6Time32Args
 15270    var err error
 15271  
 15272    var numArgs uint8
 15273    err = decoder.DecodeUint8(&numArgs)
 15274    if err != nil {
 15275      return types.Pselect6Time32Args{}, err
 15276    }
 15277  
 15278    for arg := 0; arg < int(numArgs); arg++ {
 15279      var currArg uint8
 15280      err = decoder.DecodeUint8(&currArg)
 15281      if err != nil {
 15282        return types.Pselect6Time32Args{}, err
 15283      }
 15284  
 15285      switch currArg {
 15286      case 0:
 15287        err = decoder.DecodeInt32(&result.N)
 15288        if err != nil {
 15289          return types.Pselect6Time32Args{}, err
 15290        }
 15291      case 1:
 15292        var dataInp uint64
 15293        err = decoder.DecodeUint64(&dataInp)
 15294        if err != nil {
 15295          return types.Pselect6Time32Args{}, err
 15296        }
 15297        result.Inp = uintptr(dataInp)
 15298      case 2:
 15299        var dataOutp uint64
 15300        err = decoder.DecodeUint64(&dataOutp)
 15301        if err != nil {
 15302          return types.Pselect6Time32Args{}, err
 15303        }
 15304        result.Outp = uintptr(dataOutp)
 15305      case 3:
 15306        var dataExp uint64
 15307        err = decoder.DecodeUint64(&dataExp)
 15308        if err != nil {
 15309          return types.Pselect6Time32Args{}, err
 15310        }
 15311        result.Exp = uintptr(dataExp)
 15312      case 4:
 15313        var dataTsp uint64
 15314        err = decoder.DecodeUint64(&dataTsp)
 15315        if err != nil {
 15316          return types.Pselect6Time32Args{}, err
 15317        }
 15318        result.Tsp = uintptr(dataTsp)
 15319      case 5:
 15320        var dataSig uint64
 15321        err = decoder.DecodeUint64(&dataSig)
 15322        if err != nil {
 15323          return types.Pselect6Time32Args{}, err
 15324        }
 15325        result.Sig = uintptr(dataSig)
 15326      }
 15327    }
 15328    return result, nil
 15329  }
 15330  
 15331  func ParsePpollTime32Args(decoder *Decoder) (types.PpollTime32Args, error) {
 15332    var result types.PpollTime32Args
 15333    var err error
 15334  
 15335    var numArgs uint8
 15336    err = decoder.DecodeUint8(&numArgs)
 15337    if err != nil {
 15338      return types.PpollTime32Args{}, err
 15339    }
 15340  
 15341    for arg := 0; arg < int(numArgs); arg++ {
 15342      var currArg uint8
 15343      err = decoder.DecodeUint8(&currArg)
 15344      if err != nil {
 15345        return types.PpollTime32Args{}, err
 15346      }
 15347  
 15348      switch currArg {
 15349      case 0:
 15350        var dataUfds uint64
 15351        err = decoder.DecodeUint64(&dataUfds)
 15352        if err != nil {
 15353          return types.PpollTime32Args{}, err
 15354        }
 15355        result.Ufds = uintptr(dataUfds)
 15356      case 1:
 15357        err = decoder.DecodeUint32(&result.Nfds)
 15358        if err != nil {
 15359          return types.PpollTime32Args{}, err
 15360        }
 15361      case 2:
 15362        var dataTsp uint64
 15363        err = decoder.DecodeUint64(&dataTsp)
 15364        if err != nil {
 15365          return types.PpollTime32Args{}, err
 15366        }
 15367        result.Tsp = uintptr(dataTsp)
 15368      case 3:
 15369        var dataSigmask uint64
 15370        err = decoder.DecodeUint64(&dataSigmask)
 15371        if err != nil {
 15372          return types.PpollTime32Args{}, err
 15373        }
 15374        result.Sigmask = uintptr(dataSigmask)
 15375      case 4:
 15376        err = decoder.DecodeUint64(&result.Sigsetsize)
 15377        if err != nil {
 15378          return types.PpollTime32Args{}, err
 15379        }
 15380      }
 15381    }
 15382    return result, nil
 15383  }
 15384  
 15385  func ParseIoPgeteventsTime32Args(decoder *Decoder) (types.IoPgeteventsTime32Args, error) {
 15386    return types.IoPgeteventsTime32Args{}, nil
 15387  }
 15388  
 15389  func ParseRecvmmsgTime32Args(decoder *Decoder) (types.RecvmmsgTime32Args, error) {
 15390    var result types.RecvmmsgTime32Args
 15391    var err error
 15392  
 15393    var numArgs uint8
 15394    err = decoder.DecodeUint8(&numArgs)
 15395    if err != nil {
 15396      return types.RecvmmsgTime32Args{}, err
 15397    }
 15398  
 15399    for arg := 0; arg < int(numArgs); arg++ {
 15400      var currArg uint8
 15401      err = decoder.DecodeUint8(&currArg)
 15402      if err != nil {
 15403        return types.RecvmmsgTime32Args{}, err
 15404      }
 15405  
 15406      switch currArg {
 15407      case 0:
 15408        err = decoder.DecodeInt32(&result.Fd)
 15409        if err != nil {
 15410          return types.RecvmmsgTime32Args{}, err
 15411        }
 15412      case 1:
 15413        var dataMmsg uint64
 15414        err = decoder.DecodeUint64(&dataMmsg)
 15415        if err != nil {
 15416          return types.RecvmmsgTime32Args{}, err
 15417        }
 15418        result.Mmsg = uintptr(dataMmsg)
 15419      case 2:
 15420        err = decoder.DecodeUint32(&result.Vlen)
 15421        if err != nil {
 15422          return types.RecvmmsgTime32Args{}, err
 15423        }
 15424      case 3:
 15425        err = decoder.DecodeUint32(&result.Flags)
 15426        if err != nil {
 15427          return types.RecvmmsgTime32Args{}, err
 15428        }
 15429      case 4:
 15430        var dataTimeout uint64
 15431        err = decoder.DecodeUint64(&dataTimeout)
 15432        if err != nil {
 15433          return types.RecvmmsgTime32Args{}, err
 15434        }
 15435        result.Timeout = uintptr(dataTimeout)
 15436      }
 15437    }
 15438    return result, nil
 15439  }
 15440  
 15441  func ParseMqTimedsendTime32Args(decoder *Decoder) (types.MqTimedsendTime32Args, error) {
 15442    var result types.MqTimedsendTime32Args
 15443    var err error
 15444  
 15445    var numArgs uint8
 15446    err = decoder.DecodeUint8(&numArgs)
 15447    if err != nil {
 15448      return types.MqTimedsendTime32Args{}, err
 15449    }
 15450  
 15451    for arg := 0; arg < int(numArgs); arg++ {
 15452      var currArg uint8
 15453      err = decoder.DecodeUint8(&currArg)
 15454      if err != nil {
 15455        return types.MqTimedsendTime32Args{}, err
 15456      }
 15457  
 15458      switch currArg {
 15459      case 0:
 15460        err = decoder.DecodeInt32(&result.Mqdes)
 15461        if err != nil {
 15462          return types.MqTimedsendTime32Args{}, err
 15463        }
 15464      case 1:
 15465        result.UMsgPtr, err = decoder.ReadStringFromBuff()
 15466        if err != nil {
 15467          return types.MqTimedsendTime32Args{}, err
 15468        }
 15469      case 2:
 15470        err = decoder.DecodeUint32(&result.MsgLen)
 15471        if err != nil {
 15472          return types.MqTimedsendTime32Args{}, err
 15473        }
 15474      case 3:
 15475        err = decoder.DecodeUint32(&result.MsgPrio)
 15476        if err != nil {
 15477          return types.MqTimedsendTime32Args{}, err
 15478        }
 15479      case 4:
 15480        var dataUAbsTimeout uint64
 15481        err = decoder.DecodeUint64(&dataUAbsTimeout)
 15482        if err != nil {
 15483          return types.MqTimedsendTime32Args{}, err
 15484        }
 15485        result.UAbsTimeout = uintptr(dataUAbsTimeout)
 15486      }
 15487    }
 15488    return result, nil
 15489  }
 15490  
 15491  func ParseMqTimedreceiveTime32Args(decoder *Decoder) (types.MqTimedreceiveTime32Args, error) {
 15492    var result types.MqTimedreceiveTime32Args
 15493    var err error
 15494  
 15495    var numArgs uint8
 15496    err = decoder.DecodeUint8(&numArgs)
 15497    if err != nil {
 15498      return types.MqTimedreceiveTime32Args{}, err
 15499    }
 15500  
 15501    for arg := 0; arg < int(numArgs); arg++ {
 15502      var currArg uint8
 15503      err = decoder.DecodeUint8(&currArg)
 15504      if err != nil {
 15505        return types.MqTimedreceiveTime32Args{}, err
 15506      }
 15507  
 15508      switch currArg {
 15509      case 0:
 15510        err = decoder.DecodeInt32(&result.Mqdes)
 15511        if err != nil {
 15512          return types.MqTimedreceiveTime32Args{}, err
 15513        }
 15514      case 1:
 15515        result.UMsgPtr, err = decoder.ReadStringFromBuff()
 15516        if err != nil {
 15517          return types.MqTimedreceiveTime32Args{}, err
 15518        }
 15519      case 2:
 15520        err = decoder.DecodeUint32(&result.MsgLen)
 15521        if err != nil {
 15522          return types.MqTimedreceiveTime32Args{}, err
 15523        }
 15524      case 3:
 15525        var dataUMsgPrio uint64
 15526        err = decoder.DecodeUint64(&dataUMsgPrio)
 15527        if err != nil {
 15528          return types.MqTimedreceiveTime32Args{}, err
 15529        }
 15530        result.UMsgPrio = uintptr(dataUMsgPrio)
 15531      case 4:
 15532        var dataUAbsTimeout uint64
 15533        err = decoder.DecodeUint64(&dataUAbsTimeout)
 15534        if err != nil {
 15535          return types.MqTimedreceiveTime32Args{}, err
 15536        }
 15537        result.UAbsTimeout = uintptr(dataUAbsTimeout)
 15538      }
 15539    }
 15540    return result, nil
 15541  }
 15542  
 15543  func ParseRtSigtimedwaitTime32Args(decoder *Decoder) (types.RtSigtimedwaitTime32Args, error) {
 15544    var result types.RtSigtimedwaitTime32Args
 15545    var err error
 15546  
 15547    var numArgs uint8
 15548    err = decoder.DecodeUint8(&numArgs)
 15549    if err != nil {
 15550      return types.RtSigtimedwaitTime32Args{}, err
 15551    }
 15552  
 15553    for arg := 0; arg < int(numArgs); arg++ {
 15554      var currArg uint8
 15555      err = decoder.DecodeUint8(&currArg)
 15556      if err != nil {
 15557        return types.RtSigtimedwaitTime32Args{}, err
 15558      }
 15559  
 15560      switch currArg {
 15561      case 0:
 15562        var dataUthese uint64
 15563        err = decoder.DecodeUint64(&dataUthese)
 15564        if err != nil {
 15565          return types.RtSigtimedwaitTime32Args{}, err
 15566        }
 15567        result.Uthese = uintptr(dataUthese)
 15568      case 1:
 15569        var dataUinfo uint64
 15570        err = decoder.DecodeUint64(&dataUinfo)
 15571        if err != nil {
 15572          return types.RtSigtimedwaitTime32Args{}, err
 15573        }
 15574        result.Uinfo = uintptr(dataUinfo)
 15575      case 2:
 15576        var dataUts uint64
 15577        err = decoder.DecodeUint64(&dataUts)
 15578        if err != nil {
 15579          return types.RtSigtimedwaitTime32Args{}, err
 15580        }
 15581        result.Uts = uintptr(dataUts)
 15582      case 3:
 15583        err = decoder.DecodeUint64(&result.Sigsetsize)
 15584        if err != nil {
 15585          return types.RtSigtimedwaitTime32Args{}, err
 15586        }
 15587      }
 15588    }
 15589    return result, nil
 15590  }
 15591  
 15592  func ParseFutexTime32Args(decoder *Decoder) (types.FutexTime32Args, error) {
 15593    var result types.FutexTime32Args
 15594    var err error
 15595  
 15596    var numArgs uint8
 15597    err = decoder.DecodeUint8(&numArgs)
 15598    if err != nil {
 15599      return types.FutexTime32Args{}, err
 15600    }
 15601  
 15602    for arg := 0; arg < int(numArgs); arg++ {
 15603      var currArg uint8
 15604      err = decoder.DecodeUint8(&currArg)
 15605      if err != nil {
 15606        return types.FutexTime32Args{}, err
 15607      }
 15608  
 15609      switch currArg {
 15610      case 0:
 15611        var dataUaddr uint64
 15612        err = decoder.DecodeUint64(&dataUaddr)
 15613        if err != nil {
 15614          return types.FutexTime32Args{}, err
 15615        }
 15616        result.Uaddr = uintptr(dataUaddr)
 15617      case 1:
 15618        err = decoder.DecodeInt32(&result.Op)
 15619        if err != nil {
 15620          return types.FutexTime32Args{}, err
 15621        }
 15622      case 2:
 15623        err = decoder.DecodeUint32(&result.Val)
 15624        if err != nil {
 15625          return types.FutexTime32Args{}, err
 15626        }
 15627      case 3:
 15628        var dataUtime uint64
 15629        err = decoder.DecodeUint64(&dataUtime)
 15630        if err != nil {
 15631          return types.FutexTime32Args{}, err
 15632        }
 15633        result.Utime = uintptr(dataUtime)
 15634      case 4:
 15635        var dataUaddr2 uint64
 15636        err = decoder.DecodeUint64(&dataUaddr2)
 15637        if err != nil {
 15638          return types.FutexTime32Args{}, err
 15639        }
 15640        result.Uaddr2 = uintptr(dataUaddr2)
 15641      case 5:
 15642        err = decoder.DecodeUint32(&result.Val3)
 15643        if err != nil {
 15644          return types.FutexTime32Args{}, err
 15645        }
 15646      }
 15647    }
 15648    return result, nil
 15649  }
 15650  
 15651  func ParseSchedRrGetInterval32Args(decoder *Decoder) (types.SchedRrGetInterval32Args, error) {
 15652    var result types.SchedRrGetInterval32Args
 15653    var err error
 15654  
 15655    var numArgs uint8
 15656    err = decoder.DecodeUint8(&numArgs)
 15657    if err != nil {
 15658      return types.SchedRrGetInterval32Args{}, err
 15659    }
 15660  
 15661    for arg := 0; arg < int(numArgs); arg++ {
 15662      var currArg uint8
 15663      err = decoder.DecodeUint8(&currArg)
 15664      if err != nil {
 15665        return types.SchedRrGetInterval32Args{}, err
 15666      }
 15667  
 15668      switch currArg {
 15669      case 0:
 15670        err = decoder.DecodeInt32(&result.Pid)
 15671        if err != nil {
 15672          return types.SchedRrGetInterval32Args{}, err
 15673        }
 15674      case 1:
 15675        var dataInterval uint64
 15676        err = decoder.DecodeUint64(&dataInterval)
 15677        if err != nil {
 15678          return types.SchedRrGetInterval32Args{}, err
 15679        }
 15680        result.Interval = uintptr(dataInterval)
 15681      }
 15682    }
 15683    return result, nil
 15684  }
 15685  
 15686  func ParseSysEnterArgs(decoder *Decoder) (types.SysEnterArgs, error) {
 15687    var result types.SysEnterArgs
 15688    var err error
 15689  
 15690    var numArgs uint8
 15691    err = decoder.DecodeUint8(&numArgs)
 15692    if err != nil {
 15693      return types.SysEnterArgs{}, err
 15694    }
 15695  
 15696    for arg := 0; arg < int(numArgs); arg++ {
 15697      var currArg uint8
 15698      err = decoder.DecodeUint8(&currArg)
 15699      if err != nil {
 15700        return types.SysEnterArgs{}, err
 15701      }
 15702  
 15703      switch currArg {
 15704      case 0:
 15705        err = decoder.DecodeInt32(&result.Syscall)
 15706        if err != nil {
 15707          return types.SysEnterArgs{}, err
 15708        }
 15709      }
 15710    }
 15711    return result, nil
 15712  }
 15713  
 15714  func ParseSysExitArgs(decoder *Decoder) (types.SysExitArgs, error) {
 15715    var result types.SysExitArgs
 15716    var err error
 15717  
 15718    var numArgs uint8
 15719    err = decoder.DecodeUint8(&numArgs)
 15720    if err != nil {
 15721      return types.SysExitArgs{}, err
 15722    }
 15723  
 15724    for arg := 0; arg < int(numArgs); arg++ {
 15725      var currArg uint8
 15726      err = decoder.DecodeUint8(&currArg)
 15727      if err != nil {
 15728        return types.SysExitArgs{}, err
 15729      }
 15730  
 15731      switch currArg {
 15732      case 0:
 15733        err = decoder.DecodeInt32(&result.Syscall)
 15734        if err != nil {
 15735          return types.SysExitArgs{}, err
 15736        }
 15737      }
 15738    }
 15739    return result, nil
 15740  }
 15741  
 15742  func ParseSchedProcessForkArgs(decoder *Decoder) (types.SchedProcessForkArgs, error) {
 15743    var result types.SchedProcessForkArgs
 15744    var err error
 15745  
 15746    var numArgs uint8
 15747    err = decoder.DecodeUint8(&numArgs)
 15748    if err != nil {
 15749      return types.SchedProcessForkArgs{}, err
 15750    }
 15751  
 15752    for arg := 0; arg < int(numArgs); arg++ {
 15753      var currArg uint8
 15754      err = decoder.DecodeUint8(&currArg)
 15755      if err != nil {
 15756        return types.SchedProcessForkArgs{}, err
 15757      }
 15758  
 15759      switch currArg {
 15760      case 0:
 15761        err = decoder.DecodeInt32(&result.ParentTid)
 15762        if err != nil {
 15763          return types.SchedProcessForkArgs{}, err
 15764        }
 15765      case 1:
 15766        err = decoder.DecodeInt32(&result.ParentNsTid)
 15767        if err != nil {
 15768          return types.SchedProcessForkArgs{}, err
 15769        }
 15770      case 2:
 15771        err = decoder.DecodeInt32(&result.ParentPid)
 15772        if err != nil {
 15773          return types.SchedProcessForkArgs{}, err
 15774        }
 15775      case 3:
 15776        err = decoder.DecodeInt32(&result.ParentNsPid)
 15777        if err != nil {
 15778          return types.SchedProcessForkArgs{}, err
 15779        }
 15780      case 4:
 15781        err = decoder.DecodeInt32(&result.ChildTid)
 15782        if err != nil {
 15783          return types.SchedProcessForkArgs{}, err
 15784        }
 15785      case 5:
 15786        err = decoder.DecodeInt32(&result.ChildNsTid)
 15787        if err != nil {
 15788          return types.SchedProcessForkArgs{}, err
 15789        }
 15790      case 6:
 15791        err = decoder.DecodeInt32(&result.ChildPid)
 15792        if err != nil {
 15793          return types.SchedProcessForkArgs{}, err
 15794        }
 15795      case 7:
 15796        err = decoder.DecodeInt32(&result.ChildNsPid)
 15797        if err != nil {
 15798          return types.SchedProcessForkArgs{}, err
 15799        }
 15800      case 8:
 15801        err = decoder.DecodeUint64(&result.StartTime)
 15802        if err != nil {
 15803          return types.SchedProcessForkArgs{}, err
 15804        }
 15805      }
 15806    }
 15807    return result, nil
 15808  }
 15809  
 15810  func ParseSchedProcessExecArgs(decoder *Decoder) (types.SchedProcessExecArgs, error) {
 15811    var result types.SchedProcessExecArgs
 15812    var err error
 15813  
 15814    var numArgs uint8
 15815    err = decoder.DecodeUint8(&numArgs)
 15816    if err != nil {
 15817      return types.SchedProcessExecArgs{}, err
 15818    }
 15819  
 15820    for arg := 0; arg < int(numArgs); arg++ {
 15821      var currArg uint8
 15822      err = decoder.DecodeUint8(&currArg)
 15823      if err != nil {
 15824        return types.SchedProcessExecArgs{}, err
 15825      }
 15826  
 15827      switch currArg {
 15828      case 0:
 15829        result.Cmdpath, err = decoder.ReadStringFromBuff()
 15830        if err != nil {
 15831          return types.SchedProcessExecArgs{}, err
 15832        }
 15833      case 1:
 15834        result.Pathname, err = decoder.ReadStringFromBuff()
 15835        if err != nil {
 15836          return types.SchedProcessExecArgs{}, err
 15837        }
 15838      case 2:
 15839        err = decoder.DecodeUint32(&result.Dev)
 15840        if err != nil {
 15841          return types.SchedProcessExecArgs{}, err
 15842        }
 15843      case 3:
 15844        err = decoder.DecodeUint64(&result.Inode)
 15845        if err != nil {
 15846          return types.SchedProcessExecArgs{}, err
 15847        }
 15848      case 4:
 15849        err = decoder.DecodeUint64(&result.Ctime)
 15850        if err != nil {
 15851          return types.SchedProcessExecArgs{}, err
 15852        }
 15853      case 5:
 15854        err = decoder.DecodeUint16(&result.InodeMode)
 15855        if err != nil {
 15856          return types.SchedProcessExecArgs{}, err
 15857        }
 15858      case 6:
 15859        result.InterpreterPathname, err = decoder.ReadStringFromBuff()
 15860        if err != nil {
 15861          return types.SchedProcessExecArgs{}, err
 15862        }
 15863      case 7:
 15864        err = decoder.DecodeUint32(&result.InterpreterDev)
 15865        if err != nil {
 15866          return types.SchedProcessExecArgs{}, err
 15867        }
 15868      case 8:
 15869        err = decoder.DecodeUint64(&result.InterpreterInode)
 15870        if err != nil {
 15871          return types.SchedProcessExecArgs{}, err
 15872        }
 15873      case 9:
 15874        err = decoder.DecodeUint64(&result.InterpreterCtime)
 15875        if err != nil {
 15876          return types.SchedProcessExecArgs{}, err
 15877        }
 15878      case 10:
 15879        result.Argv, err = decoder.ReadArgsArrayFromBuff()
 15880        if err != nil {
 15881          return types.SchedProcessExecArgs{}, err
 15882        }
 15883      case 11:
 15884        result.Interp, err = decoder.ReadStringFromBuff()
 15885        if err != nil {
 15886          return types.SchedProcessExecArgs{}, err
 15887        }
 15888      case 12:
 15889        err = decoder.DecodeUint16(&result.StdinType)
 15890        if err != nil {
 15891          return types.SchedProcessExecArgs{}, err
 15892        }
 15893      case 13:
 15894        result.StdinPath, err = decoder.ReadStringFromBuff()
 15895        if err != nil {
 15896          return types.SchedProcessExecArgs{}, err
 15897        }
 15898      case 14:
 15899        err = decoder.DecodeInt32(&result.InvokedFromKernel)
 15900        if err != nil {
 15901          return types.SchedProcessExecArgs{}, err
 15902        }
 15903      case 15:
 15904        result.Env, err = decoder.ReadArgsArrayFromBuff()
 15905        if err != nil {
 15906          return types.SchedProcessExecArgs{}, err
 15907        }
 15908      }
 15909    }
 15910    return result, nil
 15911  }
 15912  
 15913  func ParseSchedProcessExitArgs(decoder *Decoder) (types.SchedProcessExitArgs, error) {
 15914    var result types.SchedProcessExitArgs
 15915    var err error
 15916  
 15917    var numArgs uint8
 15918    err = decoder.DecodeUint8(&numArgs)
 15919    if err != nil {
 15920      return types.SchedProcessExitArgs{}, err
 15921    }
 15922  
 15923    for arg := 0; arg < int(numArgs); arg++ {
 15924      var currArg uint8
 15925      err = decoder.DecodeUint8(&currArg)
 15926      if err != nil {
 15927        return types.SchedProcessExitArgs{}, err
 15928      }
 15929  
 15930      switch currArg {
 15931      case 0:
 15932        err = decoder.DecodeInt64(&result.ExitCode)
 15933        if err != nil {
 15934          return types.SchedProcessExitArgs{}, err
 15935        }
 15936      case 1:
 15937        err = decoder.DecodeBool(&result.ProcessGroupExit)
 15938        if err != nil {
 15939          return types.SchedProcessExitArgs{}, err
 15940        }
 15941      }
 15942    }
 15943    return result, nil
 15944  }
 15945  
 15946  func ParseSchedSwitchArgs(decoder *Decoder) (types.SchedSwitchArgs, error) {
 15947    var result types.SchedSwitchArgs
 15948    var err error
 15949  
 15950    var numArgs uint8
 15951    err = decoder.DecodeUint8(&numArgs)
 15952    if err != nil {
 15953      return types.SchedSwitchArgs{}, err
 15954    }
 15955  
 15956    for arg := 0; arg < int(numArgs); arg++ {
 15957      var currArg uint8
 15958      err = decoder.DecodeUint8(&currArg)
 15959      if err != nil {
 15960        return types.SchedSwitchArgs{}, err
 15961      }
 15962  
 15963      switch currArg {
 15964      case 0:
 15965        err = decoder.DecodeInt32(&result.Cpu)
 15966        if err != nil {
 15967          return types.SchedSwitchArgs{}, err
 15968        }
 15969      case 1:
 15970        err = decoder.DecodeInt32(&result.PrevTid)
 15971        if err != nil {
 15972          return types.SchedSwitchArgs{}, err
 15973        }
 15974      case 2:
 15975        result.PrevComm, err = decoder.ReadStringFromBuff()
 15976        if err != nil {
 15977          return types.SchedSwitchArgs{}, err
 15978        }
 15979      case 3:
 15980        err = decoder.DecodeInt32(&result.NextTid)
 15981        if err != nil {
 15982          return types.SchedSwitchArgs{}, err
 15983        }
 15984      case 4:
 15985        result.NextComm, err = decoder.ReadStringFromBuff()
 15986        if err != nil {
 15987          return types.SchedSwitchArgs{}, err
 15988        }
 15989      }
 15990    }
 15991    return result, nil
 15992  }
 15993  
 15994  func ParseProcessOomKilledArgs(decoder *Decoder) (types.ProcessOomKilledArgs, error) {
 15995    var result types.ProcessOomKilledArgs
 15996    var err error
 15997  
 15998    var numArgs uint8
 15999    err = decoder.DecodeUint8(&numArgs)
 16000    if err != nil {
 16001      return types.ProcessOomKilledArgs{}, err
 16002    }
 16003  
 16004    for arg := 0; arg < int(numArgs); arg++ {
 16005      var currArg uint8
 16006      err = decoder.DecodeUint8(&currArg)
 16007      if err != nil {
 16008        return types.ProcessOomKilledArgs{}, err
 16009      }
 16010  
 16011      switch currArg {
 16012      case 0:
 16013        err = decoder.DecodeInt64(&result.ExitCode)
 16014        if err != nil {
 16015          return types.ProcessOomKilledArgs{}, err
 16016        }
 16017      case 1:
 16018        err = decoder.DecodeBool(&result.ProcessGroupExit)
 16019        if err != nil {
 16020          return types.ProcessOomKilledArgs{}, err
 16021        }
 16022      }
 16023    }
 16024    return result, nil
 16025  }
 16026  
 16027  func ParseDoExitArgs(decoder *Decoder) (types.DoExitArgs, error) {
 16028    return types.DoExitArgs{}, nil
 16029  }
 16030  
 16031  func ParseCapCapableArgs(decoder *Decoder) (types.CapCapableArgs, error) {
 16032    var result types.CapCapableArgs
 16033    var err error
 16034  
 16035    var numArgs uint8
 16036    err = decoder.DecodeUint8(&numArgs)
 16037    if err != nil {
 16038      return types.CapCapableArgs{}, err
 16039    }
 16040  
 16041    for arg := 0; arg < int(numArgs); arg++ {
 16042      var currArg uint8
 16043      err = decoder.DecodeUint8(&currArg)
 16044      if err != nil {
 16045        return types.CapCapableArgs{}, err
 16046      }
 16047  
 16048      switch currArg {
 16049      case 0:
 16050        err = decoder.DecodeInt32(&result.Cap)
 16051        if err != nil {
 16052          return types.CapCapableArgs{}, err
 16053        }
 16054      }
 16055    }
 16056    return result, nil
 16057  }
 16058  
 16059  func ParseVfsWriteArgs(decoder *Decoder) (types.VfsWriteArgs, error) {
 16060    var result types.VfsWriteArgs
 16061    var err error
 16062  
 16063    var numArgs uint8
 16064    err = decoder.DecodeUint8(&numArgs)
 16065    if err != nil {
 16066      return types.VfsWriteArgs{}, err
 16067    }
 16068  
 16069    for arg := 0; arg < int(numArgs); arg++ {
 16070      var currArg uint8
 16071      err = decoder.DecodeUint8(&currArg)
 16072      if err != nil {
 16073        return types.VfsWriteArgs{}, err
 16074      }
 16075  
 16076      switch currArg {
 16077      case 0:
 16078        result.Pathname, err = decoder.ReadStringFromBuff()
 16079        if err != nil {
 16080          return types.VfsWriteArgs{}, err
 16081        }
 16082      case 1:
 16083        err = decoder.DecodeUint32(&result.Dev)
 16084        if err != nil {
 16085          return types.VfsWriteArgs{}, err
 16086        }
 16087      case 2:
 16088        err = decoder.DecodeUint64(&result.Inode)
 16089        if err != nil {
 16090          return types.VfsWriteArgs{}, err
 16091        }
 16092      case 3:
 16093        err = decoder.DecodeUint64(&result.Count)
 16094        if err != nil {
 16095          return types.VfsWriteArgs{}, err
 16096        }
 16097      case 4:
 16098        err = decoder.DecodeUint64(&result.Pos)
 16099        if err != nil {
 16100          return types.VfsWriteArgs{}, err
 16101        }
 16102      }
 16103    }
 16104    return result, nil
 16105  }
 16106  
 16107  func ParseVfsWritevArgs(decoder *Decoder) (types.VfsWritevArgs, error) {
 16108    var result types.VfsWritevArgs
 16109    var err error
 16110  
 16111    var numArgs uint8
 16112    err = decoder.DecodeUint8(&numArgs)
 16113    if err != nil {
 16114      return types.VfsWritevArgs{}, err
 16115    }
 16116  
 16117    for arg := 0; arg < int(numArgs); arg++ {
 16118      var currArg uint8
 16119      err = decoder.DecodeUint8(&currArg)
 16120      if err != nil {
 16121        return types.VfsWritevArgs{}, err
 16122      }
 16123  
 16124      switch currArg {
 16125      case 0:
 16126        result.Pathname, err = decoder.ReadStringFromBuff()
 16127        if err != nil {
 16128          return types.VfsWritevArgs{}, err
 16129        }
 16130      case 1:
 16131        err = decoder.DecodeUint32(&result.Dev)
 16132        if err != nil {
 16133          return types.VfsWritevArgs{}, err
 16134        }
 16135      case 2:
 16136        err = decoder.DecodeUint64(&result.Inode)
 16137        if err != nil {
 16138          return types.VfsWritevArgs{}, err
 16139        }
 16140      case 3:
 16141        err = decoder.DecodeUint64(&result.Vlen)
 16142        if err != nil {
 16143          return types.VfsWritevArgs{}, err
 16144        }
 16145      case 4:
 16146        err = decoder.DecodeUint64(&result.Pos)
 16147        if err != nil {
 16148          return types.VfsWritevArgs{}, err
 16149        }
 16150      }
 16151    }
 16152    return result, nil
 16153  }
 16154  
 16155  func ParseMemProtAlertArgs(decoder *Decoder) (types.MemProtAlertArgs, error) {
 16156    var result types.MemProtAlertArgs
 16157    var err error
 16158  
 16159    var numArgs uint8
 16160    err = decoder.DecodeUint8(&numArgs)
 16161    if err != nil {
 16162      return types.MemProtAlertArgs{}, err
 16163    }
 16164  
 16165    for arg := 0; arg < int(numArgs); arg++ {
 16166      var currArg uint8
 16167      err = decoder.DecodeUint8(&currArg)
 16168      if err != nil {
 16169        return types.MemProtAlertArgs{}, err
 16170      }
 16171  
 16172      switch currArg {
 16173      case 0:
 16174        err = decoder.DecodeUint32(&result.Alert)
 16175        if err != nil {
 16176          return types.MemProtAlertArgs{}, err
 16177        }
 16178      case 1:
 16179        var dataAddr uint64
 16180        err = decoder.DecodeUint64(&dataAddr)
 16181        if err != nil {
 16182          return types.MemProtAlertArgs{}, err
 16183        }
 16184        result.Addr = uintptr(dataAddr)
 16185      case 2:
 16186        err = decoder.DecodeUint64(&result.Len)
 16187        if err != nil {
 16188          return types.MemProtAlertArgs{}, err
 16189        }
 16190      case 3:
 16191        err = decoder.DecodeInt32(&result.Prot)
 16192        if err != nil {
 16193          return types.MemProtAlertArgs{}, err
 16194        }
 16195      case 4:
 16196        err = decoder.DecodeInt32(&result.PrevProt)
 16197        if err != nil {
 16198          return types.MemProtAlertArgs{}, err
 16199        }
 16200      case 5:
 16201        result.Pathname, err = decoder.ReadStringFromBuff()
 16202        if err != nil {
 16203          return types.MemProtAlertArgs{}, err
 16204        }
 16205      case 6:
 16206        err = decoder.DecodeUint32(&result.Dev)
 16207        if err != nil {
 16208          return types.MemProtAlertArgs{}, err
 16209        }
 16210      case 7:
 16211        err = decoder.DecodeUint64(&result.Inode)
 16212        if err != nil {
 16213          return types.MemProtAlertArgs{}, err
 16214        }
 16215      case 8:
 16216        err = decoder.DecodeUint64(&result.Ctime)
 16217        if err != nil {
 16218          return types.MemProtAlertArgs{}, err
 16219        }
 16220      }
 16221    }
 16222    return result, nil
 16223  }
 16224  
 16225  func ParseCommitCredsArgs(decoder *Decoder) (types.CommitCredsArgs, error) {
 16226    var result types.CommitCredsArgs
 16227    var err error
 16228  
 16229    var numArgs uint8
 16230    err = decoder.DecodeUint8(&numArgs)
 16231    if err != nil {
 16232      return types.CommitCredsArgs{}, err
 16233    }
 16234  
 16235    for arg := 0; arg < int(numArgs); arg++ {
 16236      var currArg uint8
 16237      err = decoder.DecodeUint8(&currArg)
 16238      if err != nil {
 16239        return types.CommitCredsArgs{}, err
 16240      }
 16241  
 16242      switch currArg {
 16243      case 0:
 16244        err = decoder.DecodeSlimCred(&result.OldCred)
 16245        if err != nil {
 16246          return types.CommitCredsArgs{}, err
 16247        }
 16248      case 1:
 16249        err = decoder.DecodeSlimCred(&result.NewCred)
 16250        if err != nil {
 16251          return types.CommitCredsArgs{}, err
 16252        }
 16253      }
 16254    }
 16255    return result, nil
 16256  }
 16257  
 16258  func ParseSwitchTaskNSArgs(decoder *Decoder) (types.SwitchTaskNSArgs, error) {
 16259    var result types.SwitchTaskNSArgs
 16260    var err error
 16261  
 16262    var numArgs uint8
 16263    err = decoder.DecodeUint8(&numArgs)
 16264    if err != nil {
 16265      return types.SwitchTaskNSArgs{}, err
 16266    }
 16267  
 16268    for arg := 0; arg < int(numArgs); arg++ {
 16269      var currArg uint8
 16270      err = decoder.DecodeUint8(&currArg)
 16271      if err != nil {
 16272        return types.SwitchTaskNSArgs{}, err
 16273      }
 16274  
 16275      switch currArg {
 16276      case 0:
 16277        err = decoder.DecodeInt32(&result.Pid)
 16278        if err != nil {
 16279          return types.SwitchTaskNSArgs{}, err
 16280        }
 16281      case 1:
 16282        err = decoder.DecodeUint32(&result.NewMnt)
 16283        if err != nil {
 16284          return types.SwitchTaskNSArgs{}, err
 16285        }
 16286      case 2:
 16287        err = decoder.DecodeUint32(&result.NewPid)
 16288        if err != nil {
 16289          return types.SwitchTaskNSArgs{}, err
 16290        }
 16291      case 3:
 16292        err = decoder.DecodeUint32(&result.NewUts)
 16293        if err != nil {
 16294          return types.SwitchTaskNSArgs{}, err
 16295        }
 16296      case 4:
 16297        err = decoder.DecodeUint32(&result.NewIpc)
 16298        if err != nil {
 16299          return types.SwitchTaskNSArgs{}, err
 16300        }
 16301      case 5:
 16302        err = decoder.DecodeUint32(&result.NewNet)
 16303        if err != nil {
 16304          return types.SwitchTaskNSArgs{}, err
 16305        }
 16306      case 6:
 16307        err = decoder.DecodeUint32(&result.NewCgroup)
 16308        if err != nil {
 16309          return types.SwitchTaskNSArgs{}, err
 16310        }
 16311      }
 16312    }
 16313    return result, nil
 16314  }
 16315  
 16316  func ParseMagicWriteArgs(decoder *Decoder) (types.MagicWriteArgs, error) {
 16317    var result types.MagicWriteArgs
 16318    var err error
 16319  
 16320    var numArgs uint8
 16321    err = decoder.DecodeUint8(&numArgs)
 16322    if err != nil {
 16323      return types.MagicWriteArgs{}, err
 16324    }
 16325  
 16326    for arg := 0; arg < int(numArgs); arg++ {
 16327      var currArg uint8
 16328      err = decoder.DecodeUint8(&currArg)
 16329      if err != nil {
 16330        return types.MagicWriteArgs{}, err
 16331      }
 16332  
 16333      switch currArg {
 16334      case 0:
 16335        result.Pathname, err = decoder.ReadStringFromBuff()
 16336        if err != nil {
 16337          return types.MagicWriteArgs{}, err
 16338        }
 16339      case 1:
 16340        result.Bytes, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.MagicWrite))
 16341        if err != nil {
 16342          return types.MagicWriteArgs{}, err
 16343        }
 16344      case 2:
 16345        err = decoder.DecodeUint32(&result.Dev)
 16346        if err != nil {
 16347          return types.MagicWriteArgs{}, err
 16348        }
 16349      case 3:
 16350        err = decoder.DecodeUint64(&result.Inode)
 16351        if err != nil {
 16352          return types.MagicWriteArgs{}, err
 16353        }
 16354      }
 16355    }
 16356    return result, nil
 16357  }
 16358  
 16359  func ParseCgroupAttachTaskArgs(decoder *Decoder) (types.CgroupAttachTaskArgs, error) {
 16360    var result types.CgroupAttachTaskArgs
 16361    var err error
 16362  
 16363    var numArgs uint8
 16364    err = decoder.DecodeUint8(&numArgs)
 16365    if err != nil {
 16366      return types.CgroupAttachTaskArgs{}, err
 16367    }
 16368  
 16369    for arg := 0; arg < int(numArgs); arg++ {
 16370      var currArg uint8
 16371      err = decoder.DecodeUint8(&currArg)
 16372      if err != nil {
 16373        return types.CgroupAttachTaskArgs{}, err
 16374      }
 16375  
 16376      switch currArg {
 16377      case 0:
 16378        result.CgroupPath, err = decoder.ReadStringFromBuff()
 16379        if err != nil {
 16380          return types.CgroupAttachTaskArgs{}, err
 16381        }
 16382      case 1:
 16383        result.Comm, err = decoder.ReadStringFromBuff()
 16384        if err != nil {
 16385          return types.CgroupAttachTaskArgs{}, err
 16386        }
 16387      case 2:
 16388        err = decoder.DecodeInt32(&result.Pid)
 16389        if err != nil {
 16390          return types.CgroupAttachTaskArgs{}, err
 16391        }
 16392      }
 16393    }
 16394    return result, nil
 16395  }
 16396  
 16397  func ParseCgroupMkdirArgs(decoder *Decoder) (types.CgroupMkdirArgs, error) {
 16398    var result types.CgroupMkdirArgs
 16399    var err error
 16400  
 16401    var numArgs uint8
 16402    err = decoder.DecodeUint8(&numArgs)
 16403    if err != nil {
 16404      return types.CgroupMkdirArgs{}, err
 16405    }
 16406  
 16407    for arg := 0; arg < int(numArgs); arg++ {
 16408      var currArg uint8
 16409      err = decoder.DecodeUint8(&currArg)
 16410      if err != nil {
 16411        return types.CgroupMkdirArgs{}, err
 16412      }
 16413  
 16414      switch currArg {
 16415      case 0:
 16416        err = decoder.DecodeUint64(&result.CgroupId)
 16417        if err != nil {
 16418          return types.CgroupMkdirArgs{}, err
 16419        }
 16420      case 1:
 16421        result.CgroupPath, err = decoder.ReadStringFromBuff()
 16422        if err != nil {
 16423          return types.CgroupMkdirArgs{}, err
 16424        }
 16425      case 2:
 16426        err = decoder.DecodeUint32(&result.HierarchyId)
 16427        if err != nil {
 16428          return types.CgroupMkdirArgs{}, err
 16429        }
 16430      }
 16431    }
 16432    return result, nil
 16433  }
 16434  
 16435  func ParseCgroupRmdirArgs(decoder *Decoder) (types.CgroupRmdirArgs, error) {
 16436    var result types.CgroupRmdirArgs
 16437    var err error
 16438  
 16439    var numArgs uint8
 16440    err = decoder.DecodeUint8(&numArgs)
 16441    if err != nil {
 16442      return types.CgroupRmdirArgs{}, err
 16443    }
 16444  
 16445    for arg := 0; arg < int(numArgs); arg++ {
 16446      var currArg uint8
 16447      err = decoder.DecodeUint8(&currArg)
 16448      if err != nil {
 16449        return types.CgroupRmdirArgs{}, err
 16450      }
 16451  
 16452      switch currArg {
 16453      case 0:
 16454        err = decoder.DecodeUint64(&result.CgroupId)
 16455        if err != nil {
 16456          return types.CgroupRmdirArgs{}, err
 16457        }
 16458      case 1:
 16459        result.CgroupPath, err = decoder.ReadStringFromBuff()
 16460        if err != nil {
 16461          return types.CgroupRmdirArgs{}, err
 16462        }
 16463      case 2:
 16464        err = decoder.DecodeUint32(&result.HierarchyId)
 16465        if err != nil {
 16466          return types.CgroupRmdirArgs{}, err
 16467        }
 16468      }
 16469    }
 16470    return result, nil
 16471  }
 16472  
 16473  func ParseSecurityFileOpenArgs(decoder *Decoder) (types.SecurityFileOpenArgs, error) {
 16474    var result types.SecurityFileOpenArgs
 16475    var err error
 16476  
 16477    var numArgs uint8
 16478    err = decoder.DecodeUint8(&numArgs)
 16479    if err != nil {
 16480      return types.SecurityFileOpenArgs{}, err
 16481    }
 16482  
 16483    for arg := 0; arg < int(numArgs); arg++ {
 16484      var currArg uint8
 16485      err = decoder.DecodeUint8(&currArg)
 16486      if err != nil {
 16487        return types.SecurityFileOpenArgs{}, err
 16488      }
 16489  
 16490      switch currArg {
 16491      case 0:
 16492        result.Pathname, err = decoder.ReadStringFromBuff()
 16493        if err != nil {
 16494          return types.SecurityFileOpenArgs{}, err
 16495        }
 16496      case 1:
 16497        err = decoder.DecodeInt32(&result.Flags)
 16498        if err != nil {
 16499          return types.SecurityFileOpenArgs{}, err
 16500        }
 16501      case 2:
 16502        err = decoder.DecodeUint32(&result.Dev)
 16503        if err != nil {
 16504          return types.SecurityFileOpenArgs{}, err
 16505        }
 16506      case 3:
 16507        err = decoder.DecodeUint64(&result.Inode)
 16508        if err != nil {
 16509          return types.SecurityFileOpenArgs{}, err
 16510        }
 16511      case 4:
 16512        err = decoder.DecodeUint64(&result.Ctime)
 16513        if err != nil {
 16514          return types.SecurityFileOpenArgs{}, err
 16515        }
 16516      case 5:
 16517        result.SyscallPathname, err = decoder.ReadStringFromBuff()
 16518        if err != nil {
 16519          return types.SecurityFileOpenArgs{}, err
 16520        }
 16521      }
 16522    }
 16523    return result, nil
 16524  }
 16525  
 16526  func ParseSecurityInodeUnlinkArgs(decoder *Decoder) (types.SecurityInodeUnlinkArgs, error) {
 16527    var result types.SecurityInodeUnlinkArgs
 16528    var err error
 16529  
 16530    var numArgs uint8
 16531    err = decoder.DecodeUint8(&numArgs)
 16532    if err != nil {
 16533      return types.SecurityInodeUnlinkArgs{}, err
 16534    }
 16535  
 16536    for arg := 0; arg < int(numArgs); arg++ {
 16537      var currArg uint8
 16538      err = decoder.DecodeUint8(&currArg)
 16539      if err != nil {
 16540        return types.SecurityInodeUnlinkArgs{}, err
 16541      }
 16542  
 16543      switch currArg {
 16544      case 0:
 16545        result.Pathname, err = decoder.ReadStringFromBuff()
 16546        if err != nil {
 16547          return types.SecurityInodeUnlinkArgs{}, err
 16548        }
 16549      case 1:
 16550        err = decoder.DecodeUint64(&result.Inode)
 16551        if err != nil {
 16552          return types.SecurityInodeUnlinkArgs{}, err
 16553        }
 16554      case 2:
 16555        err = decoder.DecodeUint32(&result.Dev)
 16556        if err != nil {
 16557          return types.SecurityInodeUnlinkArgs{}, err
 16558        }
 16559      case 3:
 16560        err = decoder.DecodeUint64(&result.Ctime)
 16561        if err != nil {
 16562          return types.SecurityInodeUnlinkArgs{}, err
 16563        }
 16564      }
 16565    }
 16566    return result, nil
 16567  }
 16568  
 16569  func ParseSecuritySocketCreateArgs(decoder *Decoder) (types.SecuritySocketCreateArgs, error) {
 16570    var result types.SecuritySocketCreateArgs
 16571    var err error
 16572  
 16573    var numArgs uint8
 16574    err = decoder.DecodeUint8(&numArgs)
 16575    if err != nil {
 16576      return types.SecuritySocketCreateArgs{}, err
 16577    }
 16578  
 16579    for arg := 0; arg < int(numArgs); arg++ {
 16580      var currArg uint8
 16581      err = decoder.DecodeUint8(&currArg)
 16582      if err != nil {
 16583        return types.SecuritySocketCreateArgs{}, err
 16584      }
 16585  
 16586      switch currArg {
 16587      case 0:
 16588        err = decoder.DecodeInt32(&result.Family)
 16589        if err != nil {
 16590          return types.SecuritySocketCreateArgs{}, err
 16591        }
 16592      case 1:
 16593        err = decoder.DecodeInt32(&result.Type)
 16594        if err != nil {
 16595          return types.SecuritySocketCreateArgs{}, err
 16596        }
 16597      case 2:
 16598        err = decoder.DecodeInt32(&result.Protocol)
 16599        if err != nil {
 16600          return types.SecuritySocketCreateArgs{}, err
 16601        }
 16602      case 3:
 16603        err = decoder.DecodeInt32(&result.Kern)
 16604        if err != nil {
 16605          return types.SecuritySocketCreateArgs{}, err
 16606        }
 16607      }
 16608    }
 16609    return result, nil
 16610  }
 16611  
 16612  func ParseSecuritySocketListenArgs(decoder *Decoder) (types.SecuritySocketListenArgs, error) {
 16613    var result types.SecuritySocketListenArgs
 16614    var err error
 16615  
 16616    var numArgs uint8
 16617    err = decoder.DecodeUint8(&numArgs)
 16618    if err != nil {
 16619      return types.SecuritySocketListenArgs{}, err
 16620    }
 16621  
 16622    for arg := 0; arg < int(numArgs); arg++ {
 16623      var currArg uint8
 16624      err = decoder.DecodeUint8(&currArg)
 16625      if err != nil {
 16626        return types.SecuritySocketListenArgs{}, err
 16627      }
 16628  
 16629      switch currArg {
 16630      case 0:
 16631        err = decoder.DecodeInt32(&result.Sockfd)
 16632        if err != nil {
 16633          return types.SecuritySocketListenArgs{}, err
 16634        }
 16635      case 1:
 16636        result.LocalAddr, err = decoder.ReadSockaddrFromBuff()
 16637        if err != nil {
 16638          return types.SecuritySocketListenArgs{}, err
 16639        }
 16640      case 2:
 16641        err = decoder.DecodeInt32(&result.Backlog)
 16642        if err != nil {
 16643          return types.SecuritySocketListenArgs{}, err
 16644        }
 16645      }
 16646    }
 16647    return result, nil
 16648  }
 16649  
 16650  func ParseSecuritySocketConnectArgs(decoder *Decoder) (types.SecuritySocketConnectArgs, error) {
 16651    var result types.SecuritySocketConnectArgs
 16652    var err error
 16653  
 16654    var numArgs uint8
 16655    err = decoder.DecodeUint8(&numArgs)
 16656    if err != nil {
 16657      return types.SecuritySocketConnectArgs{}, err
 16658    }
 16659  
 16660    for arg := 0; arg < int(numArgs); arg++ {
 16661      var currArg uint8
 16662      err = decoder.DecodeUint8(&currArg)
 16663      if err != nil {
 16664        return types.SecuritySocketConnectArgs{}, err
 16665      }
 16666  
 16667      switch currArg {
 16668      case 0:
 16669        err = decoder.DecodeInt32(&result.Sockfd)
 16670        if err != nil {
 16671          return types.SecuritySocketConnectArgs{}, err
 16672        }
 16673      case 1:
 16674        err = decoder.DecodeInt32(&result.Type)
 16675        if err != nil {
 16676          return types.SecuritySocketConnectArgs{}, err
 16677        }
 16678      case 2:
 16679        result.RemoteAddr, err = decoder.ReadSockaddrFromBuff()
 16680        if err != nil {
 16681          return types.SecuritySocketConnectArgs{}, err
 16682        }
 16683      }
 16684    }
 16685    return result, nil
 16686  }
 16687  
 16688  func ParseSecuritySocketAcceptArgs(decoder *Decoder) (types.SecuritySocketAcceptArgs, error) {
 16689    var result types.SecuritySocketAcceptArgs
 16690    var err error
 16691  
 16692    var numArgs uint8
 16693    err = decoder.DecodeUint8(&numArgs)
 16694    if err != nil {
 16695      return types.SecuritySocketAcceptArgs{}, err
 16696    }
 16697  
 16698    for arg := 0; arg < int(numArgs); arg++ {
 16699      var currArg uint8
 16700      err = decoder.DecodeUint8(&currArg)
 16701      if err != nil {
 16702        return types.SecuritySocketAcceptArgs{}, err
 16703      }
 16704  
 16705      switch currArg {
 16706      case 0:
 16707        err = decoder.DecodeInt32(&result.Sockfd)
 16708        if err != nil {
 16709          return types.SecuritySocketAcceptArgs{}, err
 16710        }
 16711      case 1:
 16712        result.LocalAddr, err = decoder.ReadSockaddrFromBuff()
 16713        if err != nil {
 16714          return types.SecuritySocketAcceptArgs{}, err
 16715        }
 16716      }
 16717    }
 16718    return result, nil
 16719  }
 16720  
 16721  func ParseSecuritySocketBindArgs(decoder *Decoder) (types.SecuritySocketBindArgs, error) {
 16722    var result types.SecuritySocketBindArgs
 16723    var err error
 16724  
 16725    var numArgs uint8
 16726    err = decoder.DecodeUint8(&numArgs)
 16727    if err != nil {
 16728      return types.SecuritySocketBindArgs{}, err
 16729    }
 16730  
 16731    for arg := 0; arg < int(numArgs); arg++ {
 16732      var currArg uint8
 16733      err = decoder.DecodeUint8(&currArg)
 16734      if err != nil {
 16735        return types.SecuritySocketBindArgs{}, err
 16736      }
 16737  
 16738      switch currArg {
 16739      case 0:
 16740        err = decoder.DecodeInt32(&result.Sockfd)
 16741        if err != nil {
 16742          return types.SecuritySocketBindArgs{}, err
 16743        }
 16744      case 1:
 16745        result.LocalAddr, err = decoder.ReadSockaddrFromBuff()
 16746        if err != nil {
 16747          return types.SecuritySocketBindArgs{}, err
 16748        }
 16749      }
 16750    }
 16751    return result, nil
 16752  }
 16753  
 16754  func ParseSecuritySocketSetsockoptArgs(decoder *Decoder) (types.SecuritySocketSetsockoptArgs, error) {
 16755    var result types.SecuritySocketSetsockoptArgs
 16756    var err error
 16757  
 16758    var numArgs uint8
 16759    err = decoder.DecodeUint8(&numArgs)
 16760    if err != nil {
 16761      return types.SecuritySocketSetsockoptArgs{}, err
 16762    }
 16763  
 16764    for arg := 0; arg < int(numArgs); arg++ {
 16765      var currArg uint8
 16766      err = decoder.DecodeUint8(&currArg)
 16767      if err != nil {
 16768        return types.SecuritySocketSetsockoptArgs{}, err
 16769      }
 16770  
 16771      switch currArg {
 16772      case 0:
 16773        err = decoder.DecodeInt32(&result.Sockfd)
 16774        if err != nil {
 16775          return types.SecuritySocketSetsockoptArgs{}, err
 16776        }
 16777      case 1:
 16778        err = decoder.DecodeInt32(&result.Level)
 16779        if err != nil {
 16780          return types.SecuritySocketSetsockoptArgs{}, err
 16781        }
 16782      case 2:
 16783        err = decoder.DecodeInt32(&result.Optname)
 16784        if err != nil {
 16785          return types.SecuritySocketSetsockoptArgs{}, err
 16786        }
 16787      case 3:
 16788        result.LocalAddr, err = decoder.ReadSockaddrFromBuff()
 16789        if err != nil {
 16790          return types.SecuritySocketSetsockoptArgs{}, err
 16791        }
 16792      }
 16793    }
 16794    return result, nil
 16795  }
 16796  
 16797  func ParseSecuritySbMountArgs(decoder *Decoder) (types.SecuritySbMountArgs, error) {
 16798    var result types.SecuritySbMountArgs
 16799    var err error
 16800  
 16801    var numArgs uint8
 16802    err = decoder.DecodeUint8(&numArgs)
 16803    if err != nil {
 16804      return types.SecuritySbMountArgs{}, err
 16805    }
 16806  
 16807    for arg := 0; arg < int(numArgs); arg++ {
 16808      var currArg uint8
 16809      err = decoder.DecodeUint8(&currArg)
 16810      if err != nil {
 16811        return types.SecuritySbMountArgs{}, err
 16812      }
 16813  
 16814      switch currArg {
 16815      case 0:
 16816        result.DevName, err = decoder.ReadStringFromBuff()
 16817        if err != nil {
 16818          return types.SecuritySbMountArgs{}, err
 16819        }
 16820      case 1:
 16821        result.Path, err = decoder.ReadStringFromBuff()
 16822        if err != nil {
 16823          return types.SecuritySbMountArgs{}, err
 16824        }
 16825      case 2:
 16826        result.Type, err = decoder.ReadStringFromBuff()
 16827        if err != nil {
 16828          return types.SecuritySbMountArgs{}, err
 16829        }
 16830      case 3:
 16831        err = decoder.DecodeUint64(&result.Flags)
 16832        if err != nil {
 16833          return types.SecuritySbMountArgs{}, err
 16834        }
 16835      }
 16836    }
 16837    return result, nil
 16838  }
 16839  
 16840  func ParseSecurityBPFArgs(decoder *Decoder) (types.SecurityBPFArgs, error) {
 16841    var result types.SecurityBPFArgs
 16842    var err error
 16843  
 16844    var numArgs uint8
 16845    err = decoder.DecodeUint8(&numArgs)
 16846    if err != nil {
 16847      return types.SecurityBPFArgs{}, err
 16848    }
 16849  
 16850    for arg := 0; arg < int(numArgs); arg++ {
 16851      var currArg uint8
 16852      err = decoder.DecodeUint8(&currArg)
 16853      if err != nil {
 16854        return types.SecurityBPFArgs{}, err
 16855      }
 16856  
 16857      switch currArg {
 16858      case 0:
 16859        err = decoder.DecodeInt32(&result.Cmd)
 16860        if err != nil {
 16861          return types.SecurityBPFArgs{}, err
 16862        }
 16863      }
 16864    }
 16865    return result, nil
 16866  }
 16867  
 16868  func ParseSecurityBPFMapArgs(decoder *Decoder) (types.SecurityBPFMapArgs, error) {
 16869    var result types.SecurityBPFMapArgs
 16870    var err error
 16871  
 16872    var numArgs uint8
 16873    err = decoder.DecodeUint8(&numArgs)
 16874    if err != nil {
 16875      return types.SecurityBPFMapArgs{}, err
 16876    }
 16877  
 16878    for arg := 0; arg < int(numArgs); arg++ {
 16879      var currArg uint8
 16880      err = decoder.DecodeUint8(&currArg)
 16881      if err != nil {
 16882        return types.SecurityBPFMapArgs{}, err
 16883      }
 16884  
 16885      switch currArg {
 16886      case 0:
 16887        err = decoder.DecodeUint32(&result.MapId)
 16888        if err != nil {
 16889          return types.SecurityBPFMapArgs{}, err
 16890        }
 16891      case 1:
 16892        result.MapName, err = decoder.ReadStringFromBuff()
 16893        if err != nil {
 16894          return types.SecurityBPFMapArgs{}, err
 16895        }
 16896      }
 16897    }
 16898    return result, nil
 16899  }
 16900  
 16901  func ParseSecurityKernelReadFileArgs(decoder *Decoder) (types.SecurityKernelReadFileArgs, error) {
 16902    var result types.SecurityKernelReadFileArgs
 16903    var err error
 16904  
 16905    var numArgs uint8
 16906    err = decoder.DecodeUint8(&numArgs)
 16907    if err != nil {
 16908      return types.SecurityKernelReadFileArgs{}, err
 16909    }
 16910  
 16911    for arg := 0; arg < int(numArgs); arg++ {
 16912      var currArg uint8
 16913      err = decoder.DecodeUint8(&currArg)
 16914      if err != nil {
 16915        return types.SecurityKernelReadFileArgs{}, err
 16916      }
 16917  
 16918      switch currArg {
 16919      case 0:
 16920        result.Pathname, err = decoder.ReadStringFromBuff()
 16921        if err != nil {
 16922          return types.SecurityKernelReadFileArgs{}, err
 16923        }
 16924      case 1:
 16925        err = decoder.DecodeUint32(&result.Dev)
 16926        if err != nil {
 16927          return types.SecurityKernelReadFileArgs{}, err
 16928        }
 16929      case 2:
 16930        err = decoder.DecodeUint64(&result.Inode)
 16931        if err != nil {
 16932          return types.SecurityKernelReadFileArgs{}, err
 16933        }
 16934      case 3:
 16935        err = decoder.DecodeInt32(&result.Type)
 16936        if err != nil {
 16937          return types.SecurityKernelReadFileArgs{}, err
 16938        }
 16939      case 4:
 16940        err = decoder.DecodeUint64(&result.Ctime)
 16941        if err != nil {
 16942          return types.SecurityKernelReadFileArgs{}, err
 16943        }
 16944      }
 16945    }
 16946    return result, nil
 16947  }
 16948  
 16949  func ParseSecurityPostReadFileArgs(decoder *Decoder) (types.SecurityPostReadFileArgs, error) {
 16950    var result types.SecurityPostReadFileArgs
 16951    var err error
 16952  
 16953    var numArgs uint8
 16954    err = decoder.DecodeUint8(&numArgs)
 16955    if err != nil {
 16956      return types.SecurityPostReadFileArgs{}, err
 16957    }
 16958  
 16959    for arg := 0; arg < int(numArgs); arg++ {
 16960      var currArg uint8
 16961      err = decoder.DecodeUint8(&currArg)
 16962      if err != nil {
 16963        return types.SecurityPostReadFileArgs{}, err
 16964      }
 16965  
 16966      switch currArg {
 16967      case 0:
 16968        result.Pathname, err = decoder.ReadStringFromBuff()
 16969        if err != nil {
 16970          return types.SecurityPostReadFileArgs{}, err
 16971        }
 16972      case 1:
 16973        err = decoder.DecodeInt64(&result.Size)
 16974        if err != nil {
 16975          return types.SecurityPostReadFileArgs{}, err
 16976        }
 16977      case 2:
 16978        err = decoder.DecodeInt32(&result.Type)
 16979        if err != nil {
 16980          return types.SecurityPostReadFileArgs{}, err
 16981        }
 16982      }
 16983    }
 16984    return result, nil
 16985  }
 16986  
 16987  func ParseSecurityInodeMknodArgs(decoder *Decoder) (types.SecurityInodeMknodArgs, error) {
 16988    var result types.SecurityInodeMknodArgs
 16989    var err error
 16990  
 16991    var numArgs uint8
 16992    err = decoder.DecodeUint8(&numArgs)
 16993    if err != nil {
 16994      return types.SecurityInodeMknodArgs{}, err
 16995    }
 16996  
 16997    for arg := 0; arg < int(numArgs); arg++ {
 16998      var currArg uint8
 16999      err = decoder.DecodeUint8(&currArg)
 17000      if err != nil {
 17001        return types.SecurityInodeMknodArgs{}, err
 17002      }
 17003  
 17004      switch currArg {
 17005      case 0:
 17006        result.FileName, err = decoder.ReadStringFromBuff()
 17007        if err != nil {
 17008          return types.SecurityInodeMknodArgs{}, err
 17009        }
 17010      case 1:
 17011        err = decoder.DecodeUint16(&result.Mode)
 17012        if err != nil {
 17013          return types.SecurityInodeMknodArgs{}, err
 17014        }
 17015      case 2:
 17016        err = decoder.DecodeUint32(&result.Dev)
 17017        if err != nil {
 17018          return types.SecurityInodeMknodArgs{}, err
 17019        }
 17020      }
 17021    }
 17022    return result, nil
 17023  }
 17024  
 17025  func ParseSecurityInodeSymlinkEventIdArgs(decoder *Decoder) (types.SecurityInodeSymlinkEventIdArgs, error) {
 17026    var result types.SecurityInodeSymlinkEventIdArgs
 17027    var err error
 17028  
 17029    var numArgs uint8
 17030    err = decoder.DecodeUint8(&numArgs)
 17031    if err != nil {
 17032      return types.SecurityInodeSymlinkEventIdArgs{}, err
 17033    }
 17034  
 17035    for arg := 0; arg < int(numArgs); arg++ {
 17036      var currArg uint8
 17037      err = decoder.DecodeUint8(&currArg)
 17038      if err != nil {
 17039        return types.SecurityInodeSymlinkEventIdArgs{}, err
 17040      }
 17041  
 17042      switch currArg {
 17043      case 0:
 17044        result.Linkpath, err = decoder.ReadStringFromBuff()
 17045        if err != nil {
 17046          return types.SecurityInodeSymlinkEventIdArgs{}, err
 17047        }
 17048      case 1:
 17049        result.Target, err = decoder.ReadStringFromBuff()
 17050        if err != nil {
 17051          return types.SecurityInodeSymlinkEventIdArgs{}, err
 17052        }
 17053      }
 17054    }
 17055    return result, nil
 17056  }
 17057  
 17058  func ParseSecurityMmapFileArgs(decoder *Decoder) (types.SecurityMmapFileArgs, error) {
 17059    var result types.SecurityMmapFileArgs
 17060    var err error
 17061  
 17062    var numArgs uint8
 17063    err = decoder.DecodeUint8(&numArgs)
 17064    if err != nil {
 17065      return types.SecurityMmapFileArgs{}, err
 17066    }
 17067  
 17068    for arg := 0; arg < int(numArgs); arg++ {
 17069      var currArg uint8
 17070      err = decoder.DecodeUint8(&currArg)
 17071      if err != nil {
 17072        return types.SecurityMmapFileArgs{}, err
 17073      }
 17074  
 17075      switch currArg {
 17076      case 0:
 17077        result.Pathname, err = decoder.ReadStringFromBuff()
 17078        if err != nil {
 17079          return types.SecurityMmapFileArgs{}, err
 17080        }
 17081      case 1:
 17082        err = decoder.DecodeInt32(&result.Flags)
 17083        if err != nil {
 17084          return types.SecurityMmapFileArgs{}, err
 17085        }
 17086      case 2:
 17087        err = decoder.DecodeUint32(&result.Dev)
 17088        if err != nil {
 17089          return types.SecurityMmapFileArgs{}, err
 17090        }
 17091      case 3:
 17092        err = decoder.DecodeUint64(&result.Inode)
 17093        if err != nil {
 17094          return types.SecurityMmapFileArgs{}, err
 17095        }
 17096      case 4:
 17097        err = decoder.DecodeUint64(&result.Ctime)
 17098        if err != nil {
 17099          return types.SecurityMmapFileArgs{}, err
 17100        }
 17101      case 5:
 17102        err = decoder.DecodeUint64(&result.Prot)
 17103        if err != nil {
 17104          return types.SecurityMmapFileArgs{}, err
 17105        }
 17106      case 6:
 17107        err = decoder.DecodeUint64(&result.MmapFlags)
 17108        if err != nil {
 17109          return types.SecurityMmapFileArgs{}, err
 17110        }
 17111      }
 17112    }
 17113    return result, nil
 17114  }
 17115  
 17116  func ParseDoMmapArgs(decoder *Decoder) (types.DoMmapArgs, error) {
 17117    var result types.DoMmapArgs
 17118    var err error
 17119  
 17120    var numArgs uint8
 17121    err = decoder.DecodeUint8(&numArgs)
 17122    if err != nil {
 17123      return types.DoMmapArgs{}, err
 17124    }
 17125  
 17126    for arg := 0; arg < int(numArgs); arg++ {
 17127      var currArg uint8
 17128      err = decoder.DecodeUint8(&currArg)
 17129      if err != nil {
 17130        return types.DoMmapArgs{}, err
 17131      }
 17132  
 17133      switch currArg {
 17134      case 0:
 17135        var dataAddr uint64
 17136        err = decoder.DecodeUint64(&dataAddr)
 17137        if err != nil {
 17138          return types.DoMmapArgs{}, err
 17139        }
 17140        result.Addr = uintptr(dataAddr)
 17141      case 1:
 17142        result.Pathname, err = decoder.ReadStringFromBuff()
 17143        if err != nil {
 17144          return types.DoMmapArgs{}, err
 17145        }
 17146      case 2:
 17147        err = decoder.DecodeUint32(&result.Flags)
 17148        if err != nil {
 17149          return types.DoMmapArgs{}, err
 17150        }
 17151      case 3:
 17152        err = decoder.DecodeUint32(&result.Dev)
 17153        if err != nil {
 17154          return types.DoMmapArgs{}, err
 17155        }
 17156      case 4:
 17157        err = decoder.DecodeUint64(&result.Inode)
 17158        if err != nil {
 17159          return types.DoMmapArgs{}, err
 17160        }
 17161      case 5:
 17162        err = decoder.DecodeUint64(&result.Ctime)
 17163        if err != nil {
 17164          return types.DoMmapArgs{}, err
 17165        }
 17166      case 6:
 17167        err = decoder.DecodeUint64(&result.Pgoff)
 17168        if err != nil {
 17169          return types.DoMmapArgs{}, err
 17170        }
 17171      case 7:
 17172        err = decoder.DecodeUint64(&result.Len)
 17173        if err != nil {
 17174          return types.DoMmapArgs{}, err
 17175        }
 17176      case 8:
 17177        err = decoder.DecodeUint64(&result.Prot)
 17178        if err != nil {
 17179          return types.DoMmapArgs{}, err
 17180        }
 17181      case 9:
 17182        err = decoder.DecodeUint64(&result.MmapFlags)
 17183        if err != nil {
 17184          return types.DoMmapArgs{}, err
 17185        }
 17186      }
 17187    }
 17188    return result, nil
 17189  }
 17190  
 17191  func ParseSecurityFileMprotectArgs(decoder *Decoder) (types.SecurityFileMprotectArgs, error) {
 17192    var result types.SecurityFileMprotectArgs
 17193    var err error
 17194  
 17195    var numArgs uint8
 17196    err = decoder.DecodeUint8(&numArgs)
 17197    if err != nil {
 17198      return types.SecurityFileMprotectArgs{}, err
 17199    }
 17200  
 17201    for arg := 0; arg < int(numArgs); arg++ {
 17202      var currArg uint8
 17203      err = decoder.DecodeUint8(&currArg)
 17204      if err != nil {
 17205        return types.SecurityFileMprotectArgs{}, err
 17206      }
 17207  
 17208      switch currArg {
 17209      case 0:
 17210        result.Pathname, err = decoder.ReadStringFromBuff()
 17211        if err != nil {
 17212          return types.SecurityFileMprotectArgs{}, err
 17213        }
 17214      case 1:
 17215        err = decoder.DecodeInt32(&result.Prot)
 17216        if err != nil {
 17217          return types.SecurityFileMprotectArgs{}, err
 17218        }
 17219      case 2:
 17220        err = decoder.DecodeUint64(&result.Ctime)
 17221        if err != nil {
 17222          return types.SecurityFileMprotectArgs{}, err
 17223        }
 17224      case 3:
 17225        err = decoder.DecodeInt32(&result.PrevProt)
 17226        if err != nil {
 17227          return types.SecurityFileMprotectArgs{}, err
 17228        }
 17229      case 4:
 17230        var dataAddr uint64
 17231        err = decoder.DecodeUint64(&dataAddr)
 17232        if err != nil {
 17233          return types.SecurityFileMprotectArgs{}, err
 17234        }
 17235        result.Addr = uintptr(dataAddr)
 17236      case 5:
 17237        err = decoder.DecodeUint64(&result.Len)
 17238        if err != nil {
 17239          return types.SecurityFileMprotectArgs{}, err
 17240        }
 17241      case 6:
 17242        err = decoder.DecodeInt32(&result.Pkey)
 17243        if err != nil {
 17244          return types.SecurityFileMprotectArgs{}, err
 17245        }
 17246      }
 17247    }
 17248    return result, nil
 17249  }
 17250  
 17251  func ParseInitNamespacesArgs(decoder *Decoder) (types.InitNamespacesArgs, error) {
 17252    var result types.InitNamespacesArgs
 17253    var err error
 17254  
 17255    var numArgs uint8
 17256    err = decoder.DecodeUint8(&numArgs)
 17257    if err != nil {
 17258      return types.InitNamespacesArgs{}, err
 17259    }
 17260  
 17261    for arg := 0; arg < int(numArgs); arg++ {
 17262      var currArg uint8
 17263      err = decoder.DecodeUint8(&currArg)
 17264      if err != nil {
 17265        return types.InitNamespacesArgs{}, err
 17266      }
 17267  
 17268      switch currArg {
 17269      case 0:
 17270        err = decoder.DecodeUint32(&result.Cgroup)
 17271        if err != nil {
 17272          return types.InitNamespacesArgs{}, err
 17273        }
 17274      case 1:
 17275        err = decoder.DecodeUint32(&result.Ipc)
 17276        if err != nil {
 17277          return types.InitNamespacesArgs{}, err
 17278        }
 17279      case 2:
 17280        err = decoder.DecodeUint32(&result.Mnt)
 17281        if err != nil {
 17282          return types.InitNamespacesArgs{}, err
 17283        }
 17284      case 3:
 17285        err = decoder.DecodeUint32(&result.Net)
 17286        if err != nil {
 17287          return types.InitNamespacesArgs{}, err
 17288        }
 17289      case 4:
 17290        err = decoder.DecodeUint32(&result.Pid)
 17291        if err != nil {
 17292          return types.InitNamespacesArgs{}, err
 17293        }
 17294      case 5:
 17295        err = decoder.DecodeUint32(&result.PidForChildren)
 17296        if err != nil {
 17297          return types.InitNamespacesArgs{}, err
 17298        }
 17299      case 6:
 17300        err = decoder.DecodeUint32(&result.Time)
 17301        if err != nil {
 17302          return types.InitNamespacesArgs{}, err
 17303        }
 17304      case 7:
 17305        err = decoder.DecodeUint32(&result.TimeForChildren)
 17306        if err != nil {
 17307          return types.InitNamespacesArgs{}, err
 17308        }
 17309      case 8:
 17310        err = decoder.DecodeUint32(&result.User)
 17311        if err != nil {
 17312          return types.InitNamespacesArgs{}, err
 17313        }
 17314      case 9:
 17315        err = decoder.DecodeUint32(&result.Uts)
 17316        if err != nil {
 17317          return types.InitNamespacesArgs{}, err
 17318        }
 17319      }
 17320    }
 17321    return result, nil
 17322  }
 17323  
 17324  func ParseSocketDupArgs(decoder *Decoder) (types.SocketDupArgs, error) {
 17325    var result types.SocketDupArgs
 17326    var err error
 17327  
 17328    var numArgs uint8
 17329    err = decoder.DecodeUint8(&numArgs)
 17330    if err != nil {
 17331      return types.SocketDupArgs{}, err
 17332    }
 17333  
 17334    for arg := 0; arg < int(numArgs); arg++ {
 17335      var currArg uint8
 17336      err = decoder.DecodeUint8(&currArg)
 17337      if err != nil {
 17338        return types.SocketDupArgs{}, err
 17339      }
 17340  
 17341      switch currArg {
 17342      case 0:
 17343        err = decoder.DecodeInt32(&result.Oldfd)
 17344        if err != nil {
 17345          return types.SocketDupArgs{}, err
 17346        }
 17347      case 1:
 17348        err = decoder.DecodeInt32(&result.Newfd)
 17349        if err != nil {
 17350          return types.SocketDupArgs{}, err
 17351        }
 17352      case 2:
 17353        result.RemoteAddr, err = decoder.ReadSockaddrFromBuff()
 17354        if err != nil {
 17355          return types.SocketDupArgs{}, err
 17356        }
 17357      }
 17358    }
 17359    return result, nil
 17360  }
 17361  
 17362  func ParseHiddenInodesArgs(decoder *Decoder) (types.HiddenInodesArgs, error) {
 17363    var result types.HiddenInodesArgs
 17364    var err error
 17365  
 17366    var numArgs uint8
 17367    err = decoder.DecodeUint8(&numArgs)
 17368    if err != nil {
 17369      return types.HiddenInodesArgs{}, err
 17370    }
 17371  
 17372    for arg := 0; arg < int(numArgs); arg++ {
 17373      var currArg uint8
 17374      err = decoder.DecodeUint8(&currArg)
 17375      if err != nil {
 17376        return types.HiddenInodesArgs{}, err
 17377      }
 17378  
 17379      switch currArg {
 17380      case 0:
 17381        result.HiddenProcess, err = decoder.ReadStringFromBuff()
 17382        if err != nil {
 17383          return types.HiddenInodesArgs{}, err
 17384        }
 17385      }
 17386    }
 17387    return result, nil
 17388  }
 17389  
 17390  func ParseKernelWriteArgs(decoder *Decoder) (types.KernelWriteArgs, error) {
 17391    var result types.KernelWriteArgs
 17392    var err error
 17393  
 17394    var numArgs uint8
 17395    err = decoder.DecodeUint8(&numArgs)
 17396    if err != nil {
 17397      return types.KernelWriteArgs{}, err
 17398    }
 17399  
 17400    for arg := 0; arg < int(numArgs); arg++ {
 17401      var currArg uint8
 17402      err = decoder.DecodeUint8(&currArg)
 17403      if err != nil {
 17404        return types.KernelWriteArgs{}, err
 17405      }
 17406  
 17407      switch currArg {
 17408      case 0:
 17409        result.Pathname, err = decoder.ReadStringFromBuff()
 17410        if err != nil {
 17411          return types.KernelWriteArgs{}, err
 17412        }
 17413      case 1:
 17414        err = decoder.DecodeUint32(&result.Dev)
 17415        if err != nil {
 17416          return types.KernelWriteArgs{}, err
 17417        }
 17418      case 2:
 17419        err = decoder.DecodeUint64(&result.Inode)
 17420        if err != nil {
 17421          return types.KernelWriteArgs{}, err
 17422        }
 17423      case 3:
 17424        err = decoder.DecodeUint64(&result.Count)
 17425        if err != nil {
 17426          return types.KernelWriteArgs{}, err
 17427        }
 17428      case 4:
 17429        err = decoder.DecodeUint64(&result.Pos)
 17430        if err != nil {
 17431          return types.KernelWriteArgs{}, err
 17432        }
 17433      }
 17434    }
 17435    return result, nil
 17436  }
 17437  
 17438  func ParseDirtyPipeSpliceArgs(decoder *Decoder) (types.DirtyPipeSpliceArgs, error) {
 17439    var result types.DirtyPipeSpliceArgs
 17440    var err error
 17441  
 17442    var numArgs uint8
 17443    err = decoder.DecodeUint8(&numArgs)
 17444    if err != nil {
 17445      return types.DirtyPipeSpliceArgs{}, err
 17446    }
 17447  
 17448    for arg := 0; arg < int(numArgs); arg++ {
 17449      var currArg uint8
 17450      err = decoder.DecodeUint8(&currArg)
 17451      if err != nil {
 17452        return types.DirtyPipeSpliceArgs{}, err
 17453      }
 17454  
 17455      switch currArg {
 17456      case 0:
 17457        err = decoder.DecodeUint64(&result.InodeIn)
 17458        if err != nil {
 17459          return types.DirtyPipeSpliceArgs{}, err
 17460        }
 17461      case 1:
 17462        err = decoder.DecodeUint16(&result.InFileType)
 17463        if err != nil {
 17464          return types.DirtyPipeSpliceArgs{}, err
 17465        }
 17466      case 2:
 17467        result.InFilePath, err = decoder.ReadStringFromBuff()
 17468        if err != nil {
 17469          return types.DirtyPipeSpliceArgs{}, err
 17470        }
 17471      case 3:
 17472        err = decoder.DecodeUint64(&result.ExposedDataStartOffset)
 17473        if err != nil {
 17474          return types.DirtyPipeSpliceArgs{}, err
 17475        }
 17476      case 4:
 17477        err = decoder.DecodeUint64(&result.ExposedDataLen)
 17478        if err != nil {
 17479          return types.DirtyPipeSpliceArgs{}, err
 17480        }
 17481      case 5:
 17482        err = decoder.DecodeUint64(&result.InodeOut)
 17483        if err != nil {
 17484          return types.DirtyPipeSpliceArgs{}, err
 17485        }
 17486      case 6:
 17487        err = decoder.DecodeUint32(&result.OutPipeLastBufferFlags)
 17488        if err != nil {
 17489          return types.DirtyPipeSpliceArgs{}, err
 17490        }
 17491      }
 17492    }
 17493    return result, nil
 17494  }
 17495  
 17496  func ParseContainerCreateArgs(decoder *Decoder) (types.ContainerCreateArgs, error) {
 17497    var result types.ContainerCreateArgs
 17498    var err error
 17499  
 17500    var numArgs uint8
 17501    err = decoder.DecodeUint8(&numArgs)
 17502    if err != nil {
 17503      return types.ContainerCreateArgs{}, err
 17504    }
 17505  
 17506    for arg := 0; arg < int(numArgs); arg++ {
 17507      var currArg uint8
 17508      err = decoder.DecodeUint8(&currArg)
 17509      if err != nil {
 17510        return types.ContainerCreateArgs{}, err
 17511      }
 17512  
 17513      switch currArg {
 17514      case 0:
 17515        result.Runtime, err = decoder.ReadStringFromBuff()
 17516        if err != nil {
 17517          return types.ContainerCreateArgs{}, err
 17518        }
 17519      case 1:
 17520        result.ContainerId, err = decoder.ReadStringFromBuff()
 17521        if err != nil {
 17522          return types.ContainerCreateArgs{}, err
 17523        }
 17524      case 2:
 17525        err = decoder.DecodeUint64(&result.Ctime)
 17526        if err != nil {
 17527          return types.ContainerCreateArgs{}, err
 17528        }
 17529      case 3:
 17530        result.ContainerImage, err = decoder.ReadStringFromBuff()
 17531        if err != nil {
 17532          return types.ContainerCreateArgs{}, err
 17533        }
 17534      case 4:
 17535        result.ContainerImageDigest, err = decoder.ReadStringFromBuff()
 17536        if err != nil {
 17537          return types.ContainerCreateArgs{}, err
 17538        }
 17539      case 5:
 17540        result.ContainerName, err = decoder.ReadStringFromBuff()
 17541        if err != nil {
 17542          return types.ContainerCreateArgs{}, err
 17543        }
 17544      case 6:
 17545        result.PodName, err = decoder.ReadStringFromBuff()
 17546        if err != nil {
 17547          return types.ContainerCreateArgs{}, err
 17548        }
 17549      case 7:
 17550        result.PodNamespace, err = decoder.ReadStringFromBuff()
 17551        if err != nil {
 17552          return types.ContainerCreateArgs{}, err
 17553        }
 17554      case 8:
 17555        result.PodUid, err = decoder.ReadStringFromBuff()
 17556        if err != nil {
 17557          return types.ContainerCreateArgs{}, err
 17558        }
 17559      case 9:
 17560        err = decoder.DecodeBool(&result.PodSandbox)
 17561        if err != nil {
 17562          return types.ContainerCreateArgs{}, err
 17563        }
 17564      }
 17565    }
 17566    return result, nil
 17567  }
 17568  
 17569  func ParseContainerRemoveArgs(decoder *Decoder) (types.ContainerRemoveArgs, error) {
 17570    var result types.ContainerRemoveArgs
 17571    var err error
 17572  
 17573    var numArgs uint8
 17574    err = decoder.DecodeUint8(&numArgs)
 17575    if err != nil {
 17576      return types.ContainerRemoveArgs{}, err
 17577    }
 17578  
 17579    for arg := 0; arg < int(numArgs); arg++ {
 17580      var currArg uint8
 17581      err = decoder.DecodeUint8(&currArg)
 17582      if err != nil {
 17583        return types.ContainerRemoveArgs{}, err
 17584      }
 17585  
 17586      switch currArg {
 17587      case 0:
 17588        result.Runtime, err = decoder.ReadStringFromBuff()
 17589        if err != nil {
 17590          return types.ContainerRemoveArgs{}, err
 17591        }
 17592      case 1:
 17593        result.ContainerId, err = decoder.ReadStringFromBuff()
 17594        if err != nil {
 17595          return types.ContainerRemoveArgs{}, err
 17596        }
 17597      }
 17598    }
 17599    return result, nil
 17600  }
 17601  
 17602  func ParseExistingContainerArgs(decoder *Decoder) (types.ExistingContainerArgs, error) {
 17603    var result types.ExistingContainerArgs
 17604    var err error
 17605  
 17606    var numArgs uint8
 17607    err = decoder.DecodeUint8(&numArgs)
 17608    if err != nil {
 17609      return types.ExistingContainerArgs{}, err
 17610    }
 17611  
 17612    for arg := 0; arg < int(numArgs); arg++ {
 17613      var currArg uint8
 17614      err = decoder.DecodeUint8(&currArg)
 17615      if err != nil {
 17616        return types.ExistingContainerArgs{}, err
 17617      }
 17618  
 17619      switch currArg {
 17620      case 0:
 17621        result.Runtime, err = decoder.ReadStringFromBuff()
 17622        if err != nil {
 17623          return types.ExistingContainerArgs{}, err
 17624        }
 17625      case 1:
 17626        result.ContainerId, err = decoder.ReadStringFromBuff()
 17627        if err != nil {
 17628          return types.ExistingContainerArgs{}, err
 17629        }
 17630      case 2:
 17631        err = decoder.DecodeUint64(&result.Ctime)
 17632        if err != nil {
 17633          return types.ExistingContainerArgs{}, err
 17634        }
 17635      case 3:
 17636        result.ContainerImage, err = decoder.ReadStringFromBuff()
 17637        if err != nil {
 17638          return types.ExistingContainerArgs{}, err
 17639        }
 17640      case 4:
 17641        result.ContainerImageDigest, err = decoder.ReadStringFromBuff()
 17642        if err != nil {
 17643          return types.ExistingContainerArgs{}, err
 17644        }
 17645      case 5:
 17646        result.ContainerName, err = decoder.ReadStringFromBuff()
 17647        if err != nil {
 17648          return types.ExistingContainerArgs{}, err
 17649        }
 17650      case 6:
 17651        result.PodName, err = decoder.ReadStringFromBuff()
 17652        if err != nil {
 17653          return types.ExistingContainerArgs{}, err
 17654        }
 17655      case 7:
 17656        result.PodNamespace, err = decoder.ReadStringFromBuff()
 17657        if err != nil {
 17658          return types.ExistingContainerArgs{}, err
 17659        }
 17660      case 8:
 17661        result.PodUid, err = decoder.ReadStringFromBuff()
 17662        if err != nil {
 17663          return types.ExistingContainerArgs{}, err
 17664        }
 17665      case 9:
 17666        err = decoder.DecodeBool(&result.PodSandbox)
 17667        if err != nil {
 17668          return types.ExistingContainerArgs{}, err
 17669        }
 17670      }
 17671    }
 17672    return result, nil
 17673  }
 17674  
 17675  func ParseProcCreateArgs(decoder *Decoder) (types.ProcCreateArgs, error) {
 17676    var result types.ProcCreateArgs
 17677    var err error
 17678  
 17679    var numArgs uint8
 17680    err = decoder.DecodeUint8(&numArgs)
 17681    if err != nil {
 17682      return types.ProcCreateArgs{}, err
 17683    }
 17684  
 17685    for arg := 0; arg < int(numArgs); arg++ {
 17686      var currArg uint8
 17687      err = decoder.DecodeUint8(&currArg)
 17688      if err != nil {
 17689        return types.ProcCreateArgs{}, err
 17690      }
 17691  
 17692      switch currArg {
 17693      case 0:
 17694        result.Name, err = decoder.ReadStringFromBuff()
 17695        if err != nil {
 17696          return types.ProcCreateArgs{}, err
 17697        }
 17698      case 1:
 17699        var dataProcOpsAddr uint64
 17700        err = decoder.DecodeUint64(&dataProcOpsAddr)
 17701        if err != nil {
 17702          return types.ProcCreateArgs{}, err
 17703        }
 17704        result.ProcOpsAddr = uintptr(dataProcOpsAddr)
 17705      }
 17706    }
 17707    return result, nil
 17708  }
 17709  
 17710  func ParseKprobeAttachArgs(decoder *Decoder) (types.KprobeAttachArgs, error) {
 17711    var result types.KprobeAttachArgs
 17712    var err error
 17713  
 17714    var numArgs uint8
 17715    err = decoder.DecodeUint8(&numArgs)
 17716    if err != nil {
 17717      return types.KprobeAttachArgs{}, err
 17718    }
 17719  
 17720    for arg := 0; arg < int(numArgs); arg++ {
 17721      var currArg uint8
 17722      err = decoder.DecodeUint8(&currArg)
 17723      if err != nil {
 17724        return types.KprobeAttachArgs{}, err
 17725      }
 17726  
 17727      switch currArg {
 17728      case 0:
 17729        result.SymbolName, err = decoder.ReadStringFromBuff()
 17730        if err != nil {
 17731          return types.KprobeAttachArgs{}, err
 17732        }
 17733      case 1:
 17734        var dataPreHandlerAddr uint64
 17735        err = decoder.DecodeUint64(&dataPreHandlerAddr)
 17736        if err != nil {
 17737          return types.KprobeAttachArgs{}, err
 17738        }
 17739        result.PreHandlerAddr = uintptr(dataPreHandlerAddr)
 17740      case 2:
 17741        var dataPostHandlerAddr uint64
 17742        err = decoder.DecodeUint64(&dataPostHandlerAddr)
 17743        if err != nil {
 17744          return types.KprobeAttachArgs{}, err
 17745        }
 17746        result.PostHandlerAddr = uintptr(dataPostHandlerAddr)
 17747      }
 17748    }
 17749    return result, nil
 17750  }
 17751  
 17752  func ParseCallUsermodeHelperArgs(decoder *Decoder) (types.CallUsermodeHelperArgs, error) {
 17753    var result types.CallUsermodeHelperArgs
 17754    var err error
 17755  
 17756    var numArgs uint8
 17757    err = decoder.DecodeUint8(&numArgs)
 17758    if err != nil {
 17759      return types.CallUsermodeHelperArgs{}, err
 17760    }
 17761  
 17762    for arg := 0; arg < int(numArgs); arg++ {
 17763      var currArg uint8
 17764      err = decoder.DecodeUint8(&currArg)
 17765      if err != nil {
 17766        return types.CallUsermodeHelperArgs{}, err
 17767      }
 17768  
 17769      switch currArg {
 17770      case 0:
 17771        result.Pathname, err = decoder.ReadStringFromBuff()
 17772        if err != nil {
 17773          return types.CallUsermodeHelperArgs{}, err
 17774        }
 17775      case 1:
 17776        result.Argv, err = decoder.ReadStringArrayFromBuff()
 17777        if err != nil {
 17778          return types.CallUsermodeHelperArgs{}, err
 17779        }
 17780      case 2:
 17781        result.Envp, err = decoder.ReadStringArrayFromBuff()
 17782        if err != nil {
 17783          return types.CallUsermodeHelperArgs{}, err
 17784        }
 17785      case 3:
 17786        err = decoder.DecodeInt32(&result.Wait)
 17787        if err != nil {
 17788          return types.CallUsermodeHelperArgs{}, err
 17789        }
 17790      }
 17791    }
 17792    return result, nil
 17793  }
 17794  
 17795  func ParseDebugfsCreateFileArgs(decoder *Decoder) (types.DebugfsCreateFileArgs, error) {
 17796    var result types.DebugfsCreateFileArgs
 17797    var err error
 17798  
 17799    var numArgs uint8
 17800    err = decoder.DecodeUint8(&numArgs)
 17801    if err != nil {
 17802      return types.DebugfsCreateFileArgs{}, err
 17803    }
 17804  
 17805    for arg := 0; arg < int(numArgs); arg++ {
 17806      var currArg uint8
 17807      err = decoder.DecodeUint8(&currArg)
 17808      if err != nil {
 17809        return types.DebugfsCreateFileArgs{}, err
 17810      }
 17811  
 17812      switch currArg {
 17813      case 0:
 17814        result.FileName, err = decoder.ReadStringFromBuff()
 17815        if err != nil {
 17816          return types.DebugfsCreateFileArgs{}, err
 17817        }
 17818      case 1:
 17819        result.Path, err = decoder.ReadStringFromBuff()
 17820        if err != nil {
 17821          return types.DebugfsCreateFileArgs{}, err
 17822        }
 17823      case 2:
 17824        err = decoder.DecodeUint32(&result.Mode)
 17825        if err != nil {
 17826          return types.DebugfsCreateFileArgs{}, err
 17827        }
 17828      case 3:
 17829        var dataProcOpsAddr uint64
 17830        err = decoder.DecodeUint64(&dataProcOpsAddr)
 17831        if err != nil {
 17832          return types.DebugfsCreateFileArgs{}, err
 17833        }
 17834        result.ProcOpsAddr = uintptr(dataProcOpsAddr)
 17835      }
 17836    }
 17837    return result, nil
 17838  }
 17839  
 17840  func ParsePrintSyscallTableArgs(decoder *Decoder) (types.PrintSyscallTableArgs, error) {
 17841    var result types.PrintSyscallTableArgs
 17842    var err error
 17843  
 17844    var numArgs uint8
 17845    err = decoder.DecodeUint8(&numArgs)
 17846    if err != nil {
 17847      return types.PrintSyscallTableArgs{}, err
 17848    }
 17849  
 17850    for arg := 0; arg < int(numArgs); arg++ {
 17851      var currArg uint8
 17852      err = decoder.DecodeUint8(&currArg)
 17853      if err != nil {
 17854        return types.PrintSyscallTableArgs{}, err
 17855      }
 17856  
 17857      switch currArg {
 17858      case 0:
 17859        err = decoder.DecodeUint64Array(&result.SyscallsAddresses)
 17860        if err != nil {
 17861          return types.PrintSyscallTableArgs{}, err
 17862        }
 17863      case 1:
 17864        err = decoder.DecodeUint64(&result.CallerContextId)
 17865        if err != nil {
 17866          return types.PrintSyscallTableArgs{}, err
 17867        }
 17868      }
 17869    }
 17870    return result, nil
 17871  }
 17872  
 17873  func ParseHiddenKernelModuleArgs(decoder *Decoder) (types.HiddenKernelModuleArgs, error) {
 17874    var result types.HiddenKernelModuleArgs
 17875    var err error
 17876  
 17877    var numArgs uint8
 17878    err = decoder.DecodeUint8(&numArgs)
 17879    if err != nil {
 17880      return types.HiddenKernelModuleArgs{}, err
 17881    }
 17882  
 17883    for arg := 0; arg < int(numArgs); arg++ {
 17884      var currArg uint8
 17885      err = decoder.DecodeUint8(&currArg)
 17886      if err != nil {
 17887        return types.HiddenKernelModuleArgs{}, err
 17888      }
 17889  
 17890      switch currArg {
 17891      case 0:
 17892        result.Address, err = decoder.ReadStringFromBuff()
 17893        if err != nil {
 17894          return types.HiddenKernelModuleArgs{}, err
 17895        }
 17896      case 1:
 17897        result.Name, err = decoder.ReadStringFromBuff()
 17898        if err != nil {
 17899          return types.HiddenKernelModuleArgs{}, err
 17900        }
 17901      case 2:
 17902        result.Srcversion, err = decoder.ReadStringFromBuff()
 17903        if err != nil {
 17904          return types.HiddenKernelModuleArgs{}, err
 17905        }
 17906      }
 17907    }
 17908    return result, nil
 17909  }
 17910  
 17911  func ParseHiddenKernelModuleSeekerArgs(decoder *Decoder) (types.HiddenKernelModuleSeekerArgs, error) {
 17912    var result types.HiddenKernelModuleSeekerArgs
 17913    var err error
 17914  
 17915    var numArgs uint8
 17916    err = decoder.DecodeUint8(&numArgs)
 17917    if err != nil {
 17918      return types.HiddenKernelModuleSeekerArgs{}, err
 17919    }
 17920  
 17921    for arg := 0; arg < int(numArgs); arg++ {
 17922      var currArg uint8
 17923      err = decoder.DecodeUint8(&currArg)
 17924      if err != nil {
 17925        return types.HiddenKernelModuleSeekerArgs{}, err
 17926      }
 17927  
 17928      switch currArg {
 17929      case 0:
 17930        err = decoder.DecodeUint64(&result.Address)
 17931        if err != nil {
 17932          return types.HiddenKernelModuleSeekerArgs{}, err
 17933        }
 17934      case 1:
 17935        result.Name, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.HiddenKernelModuleSeeker))
 17936        if err != nil {
 17937          return types.HiddenKernelModuleSeekerArgs{}, err
 17938        }
 17939      case 2:
 17940        err = decoder.DecodeUint32(&result.Flags)
 17941        if err != nil {
 17942          return types.HiddenKernelModuleSeekerArgs{}, err
 17943        }
 17944      case 3:
 17945        result.Srcversion, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.HiddenKernelModuleSeeker))
 17946        if err != nil {
 17947          return types.HiddenKernelModuleSeekerArgs{}, err
 17948        }
 17949      }
 17950    }
 17951    return result, nil
 17952  }
 17953  
 17954  func ParseHookedSyscallsArgs(decoder *Decoder) (types.HookedSyscallsArgs, error) {
 17955    var result types.HookedSyscallsArgs
 17956    var err error
 17957  
 17958    var numArgs uint8
 17959    err = decoder.DecodeUint8(&numArgs)
 17960    if err != nil {
 17961      return types.HookedSyscallsArgs{}, err
 17962    }
 17963  
 17964    for arg := 0; arg < int(numArgs); arg++ {
 17965      var currArg uint8
 17966      err = decoder.DecodeUint8(&currArg)
 17967      if err != nil {
 17968        return types.HookedSyscallsArgs{}, err
 17969      }
 17970  
 17971      switch currArg {
 17972      case 0:
 17973        var dataCheckSyscalls uint64
 17974        err = decoder.DecodeUint64(&dataCheckSyscalls)
 17975        if err != nil {
 17976          return types.HookedSyscallsArgs{}, err
 17977        }
 17978        result.CheckSyscalls = uintptr(dataCheckSyscalls)
 17979      case 1:
 17980        var dataHookedSyscalls uint64
 17981        err = decoder.DecodeUint64(&dataHookedSyscalls)
 17982        if err != nil {
 17983          return types.HookedSyscallsArgs{}, err
 17984        }
 17985        result.HookedSyscalls = uintptr(dataHookedSyscalls)
 17986      }
 17987    }
 17988    return result, nil
 17989  }
 17990  
 17991  func ParseDebugfsCreateDirArgs(decoder *Decoder) (types.DebugfsCreateDirArgs, error) {
 17992    var result types.DebugfsCreateDirArgs
 17993    var err error
 17994  
 17995    var numArgs uint8
 17996    err = decoder.DecodeUint8(&numArgs)
 17997    if err != nil {
 17998      return types.DebugfsCreateDirArgs{}, err
 17999    }
 18000  
 18001    for arg := 0; arg < int(numArgs); arg++ {
 18002      var currArg uint8
 18003      err = decoder.DecodeUint8(&currArg)
 18004      if err != nil {
 18005        return types.DebugfsCreateDirArgs{}, err
 18006      }
 18007  
 18008      switch currArg {
 18009      case 0:
 18010        result.Name, err = decoder.ReadStringFromBuff()
 18011        if err != nil {
 18012          return types.DebugfsCreateDirArgs{}, err
 18013        }
 18014      case 1:
 18015        result.Path, err = decoder.ReadStringFromBuff()
 18016        if err != nil {
 18017          return types.DebugfsCreateDirArgs{}, err
 18018        }
 18019      }
 18020    }
 18021    return result, nil
 18022  }
 18023  
 18024  func ParseDeviceAddArgs(decoder *Decoder) (types.DeviceAddArgs, error) {
 18025    var result types.DeviceAddArgs
 18026    var err error
 18027  
 18028    var numArgs uint8
 18029    err = decoder.DecodeUint8(&numArgs)
 18030    if err != nil {
 18031      return types.DeviceAddArgs{}, err
 18032    }
 18033  
 18034    for arg := 0; arg < int(numArgs); arg++ {
 18035      var currArg uint8
 18036      err = decoder.DecodeUint8(&currArg)
 18037      if err != nil {
 18038        return types.DeviceAddArgs{}, err
 18039      }
 18040  
 18041      switch currArg {
 18042      case 0:
 18043        result.Name, err = decoder.ReadStringFromBuff()
 18044        if err != nil {
 18045          return types.DeviceAddArgs{}, err
 18046        }
 18047      case 1:
 18048        result.ParentName, err = decoder.ReadStringFromBuff()
 18049        if err != nil {
 18050          return types.DeviceAddArgs{}, err
 18051        }
 18052      }
 18053    }
 18054    return result, nil
 18055  }
 18056  
 18057  func ParseRegisterChrdevArgs(decoder *Decoder) (types.RegisterChrdevArgs, error) {
 18058    var result types.RegisterChrdevArgs
 18059    var err error
 18060  
 18061    var numArgs uint8
 18062    err = decoder.DecodeUint8(&numArgs)
 18063    if err != nil {
 18064      return types.RegisterChrdevArgs{}, err
 18065    }
 18066  
 18067    for arg := 0; arg < int(numArgs); arg++ {
 18068      var currArg uint8
 18069      err = decoder.DecodeUint8(&currArg)
 18070      if err != nil {
 18071        return types.RegisterChrdevArgs{}, err
 18072      }
 18073  
 18074      switch currArg {
 18075      case 0:
 18076        err = decoder.DecodeUint32(&result.RequestedMajorNumber)
 18077        if err != nil {
 18078          return types.RegisterChrdevArgs{}, err
 18079        }
 18080      case 1:
 18081        err = decoder.DecodeUint32(&result.GrantedMajorNumber)
 18082        if err != nil {
 18083          return types.RegisterChrdevArgs{}, err
 18084        }
 18085      case 2:
 18086        result.CharDeviceName, err = decoder.ReadStringFromBuff()
 18087        if err != nil {
 18088          return types.RegisterChrdevArgs{}, err
 18089        }
 18090      case 3:
 18091        var dataCharDeviceFops uint64
 18092        err = decoder.DecodeUint64(&dataCharDeviceFops)
 18093        if err != nil {
 18094          return types.RegisterChrdevArgs{}, err
 18095        }
 18096        result.CharDeviceFops = uintptr(dataCharDeviceFops)
 18097      }
 18098    }
 18099    return result, nil
 18100  }
 18101  
 18102  func ParseSharedObjectLoadedArgs(decoder *Decoder) (types.SharedObjectLoadedArgs, error) {
 18103    var result types.SharedObjectLoadedArgs
 18104    var err error
 18105  
 18106    var numArgs uint8
 18107    err = decoder.DecodeUint8(&numArgs)
 18108    if err != nil {
 18109      return types.SharedObjectLoadedArgs{}, err
 18110    }
 18111  
 18112    for arg := 0; arg < int(numArgs); arg++ {
 18113      var currArg uint8
 18114      err = decoder.DecodeUint8(&currArg)
 18115      if err != nil {
 18116        return types.SharedObjectLoadedArgs{}, err
 18117      }
 18118  
 18119      switch currArg {
 18120      case 0:
 18121        result.Pathname, err = decoder.ReadStringFromBuff()
 18122        if err != nil {
 18123          return types.SharedObjectLoadedArgs{}, err
 18124        }
 18125      case 1:
 18126        err = decoder.DecodeInt32(&result.Flags)
 18127        if err != nil {
 18128          return types.SharedObjectLoadedArgs{}, err
 18129        }
 18130      case 2:
 18131        err = decoder.DecodeUint32(&result.Dev)
 18132        if err != nil {
 18133          return types.SharedObjectLoadedArgs{}, err
 18134        }
 18135      case 3:
 18136        err = decoder.DecodeUint64(&result.Inode)
 18137        if err != nil {
 18138          return types.SharedObjectLoadedArgs{}, err
 18139        }
 18140      case 4:
 18141        err = decoder.DecodeUint64(&result.Ctime)
 18142        if err != nil {
 18143          return types.SharedObjectLoadedArgs{}, err
 18144        }
 18145      }
 18146    }
 18147    return result, nil
 18148  }
 18149  
 18150  func ParseSymbolsLoadedArgs(decoder *Decoder) (types.SymbolsLoadedArgs, error) {
 18151    var result types.SymbolsLoadedArgs
 18152    var err error
 18153  
 18154    var numArgs uint8
 18155    err = decoder.DecodeUint8(&numArgs)
 18156    if err != nil {
 18157      return types.SymbolsLoadedArgs{}, err
 18158    }
 18159  
 18160    for arg := 0; arg < int(numArgs); arg++ {
 18161      var currArg uint8
 18162      err = decoder.DecodeUint8(&currArg)
 18163      if err != nil {
 18164        return types.SymbolsLoadedArgs{}, err
 18165      }
 18166  
 18167      switch currArg {
 18168      case 0:
 18169        result.LibraryPath, err = decoder.ReadStringFromBuff()
 18170        if err != nil {
 18171          return types.SymbolsLoadedArgs{}, err
 18172        }
 18173      case 1:
 18174        result.Symbols, err = decoder.ReadStringArrayFromBuff()
 18175        if err != nil {
 18176          return types.SymbolsLoadedArgs{}, err
 18177        }
 18178      }
 18179    }
 18180    return result, nil
 18181  }
 18182  
 18183  func ParseSymbolsCollisionArgs(decoder *Decoder) (types.SymbolsCollisionArgs, error) {
 18184    var result types.SymbolsCollisionArgs
 18185    var err error
 18186  
 18187    var numArgs uint8
 18188    err = decoder.DecodeUint8(&numArgs)
 18189    if err != nil {
 18190      return types.SymbolsCollisionArgs{}, err
 18191    }
 18192  
 18193    for arg := 0; arg < int(numArgs); arg++ {
 18194      var currArg uint8
 18195      err = decoder.DecodeUint8(&currArg)
 18196      if err != nil {
 18197        return types.SymbolsCollisionArgs{}, err
 18198      }
 18199  
 18200      switch currArg {
 18201      case 0:
 18202        result.LoadedPath, err = decoder.ReadStringFromBuff()
 18203        if err != nil {
 18204          return types.SymbolsCollisionArgs{}, err
 18205        }
 18206      case 1:
 18207        result.CollisionPath, err = decoder.ReadStringFromBuff()
 18208        if err != nil {
 18209          return types.SymbolsCollisionArgs{}, err
 18210        }
 18211      case 2:
 18212        result.Symbols, err = decoder.ReadStringArrayFromBuff()
 18213        if err != nil {
 18214          return types.SymbolsCollisionArgs{}, err
 18215        }
 18216      }
 18217    }
 18218    return result, nil
 18219  }
 18220  
 18221  func ParseCaptureFileWriteArgs(decoder *Decoder) (types.CaptureFileWriteArgs, error) {
 18222    return types.CaptureFileWriteArgs{}, nil
 18223  }
 18224  
 18225  func ParseCaptureFileReadArgs(decoder *Decoder) (types.CaptureFileReadArgs, error) {
 18226    return types.CaptureFileReadArgs{}, nil
 18227  }
 18228  
 18229  func ParseCaptureExecArgs(decoder *Decoder) (types.CaptureExecArgs, error) {
 18230    return types.CaptureExecArgs{}, nil
 18231  }
 18232  
 18233  func ParseCaptureModuleArgs(decoder *Decoder) (types.CaptureModuleArgs, error) {
 18234    return types.CaptureModuleArgs{}, nil
 18235  }
 18236  
 18237  func ParseCaptureMemArgs(decoder *Decoder) (types.CaptureMemArgs, error) {
 18238    return types.CaptureMemArgs{}, nil
 18239  }
 18240  
 18241  func ParseCaptureBpfArgs(decoder *Decoder) (types.CaptureBpfArgs, error) {
 18242    return types.CaptureBpfArgs{}, nil
 18243  }
 18244  
 18245  func ParseDoInitModuleArgs(decoder *Decoder) (types.DoInitModuleArgs, error) {
 18246    var result types.DoInitModuleArgs
 18247    var err error
 18248  
 18249    var numArgs uint8
 18250    err = decoder.DecodeUint8(&numArgs)
 18251    if err != nil {
 18252      return types.DoInitModuleArgs{}, err
 18253    }
 18254  
 18255    for arg := 0; arg < int(numArgs); arg++ {
 18256      var currArg uint8
 18257      err = decoder.DecodeUint8(&currArg)
 18258      if err != nil {
 18259        return types.DoInitModuleArgs{}, err
 18260      }
 18261  
 18262      switch currArg {
 18263      case 0:
 18264        result.Name, err = decoder.ReadStringFromBuff()
 18265        if err != nil {
 18266          return types.DoInitModuleArgs{}, err
 18267        }
 18268      case 1:
 18269        result.Version, err = decoder.ReadStringFromBuff()
 18270        if err != nil {
 18271          return types.DoInitModuleArgs{}, err
 18272        }
 18273      case 2:
 18274        result.SrcVersion, err = decoder.ReadStringFromBuff()
 18275        if err != nil {
 18276          return types.DoInitModuleArgs{}, err
 18277        }
 18278      }
 18279    }
 18280    return result, nil
 18281  }
 18282  
 18283  func ParseModuleLoadArgs(decoder *Decoder) (types.ModuleLoadArgs, error) {
 18284    var result types.ModuleLoadArgs
 18285    var err error
 18286  
 18287    var numArgs uint8
 18288    err = decoder.DecodeUint8(&numArgs)
 18289    if err != nil {
 18290      return types.ModuleLoadArgs{}, err
 18291    }
 18292  
 18293    for arg := 0; arg < int(numArgs); arg++ {
 18294      var currArg uint8
 18295      err = decoder.DecodeUint8(&currArg)
 18296      if err != nil {
 18297        return types.ModuleLoadArgs{}, err
 18298      }
 18299  
 18300      switch currArg {
 18301      case 0:
 18302        result.Name, err = decoder.ReadStringFromBuff()
 18303        if err != nil {
 18304          return types.ModuleLoadArgs{}, err
 18305        }
 18306      case 1:
 18307        result.Version, err = decoder.ReadStringFromBuff()
 18308        if err != nil {
 18309          return types.ModuleLoadArgs{}, err
 18310        }
 18311      case 2:
 18312        result.SrcVersion, err = decoder.ReadStringFromBuff()
 18313        if err != nil {
 18314          return types.ModuleLoadArgs{}, err
 18315        }
 18316      }
 18317    }
 18318    return result, nil
 18319  }
 18320  
 18321  func ParseModuleFreeArgs(decoder *Decoder) (types.ModuleFreeArgs, error) {
 18322    var result types.ModuleFreeArgs
 18323    var err error
 18324  
 18325    var numArgs uint8
 18326    err = decoder.DecodeUint8(&numArgs)
 18327    if err != nil {
 18328      return types.ModuleFreeArgs{}, err
 18329    }
 18330  
 18331    for arg := 0; arg < int(numArgs); arg++ {
 18332      var currArg uint8
 18333      err = decoder.DecodeUint8(&currArg)
 18334      if err != nil {
 18335        return types.ModuleFreeArgs{}, err
 18336      }
 18337  
 18338      switch currArg {
 18339      case 0:
 18340        result.Name, err = decoder.ReadStringFromBuff()
 18341        if err != nil {
 18342          return types.ModuleFreeArgs{}, err
 18343        }
 18344      case 1:
 18345        result.Version, err = decoder.ReadStringFromBuff()
 18346        if err != nil {
 18347          return types.ModuleFreeArgs{}, err
 18348        }
 18349      case 2:
 18350        result.SrcVersion, err = decoder.ReadStringFromBuff()
 18351        if err != nil {
 18352          return types.ModuleFreeArgs{}, err
 18353        }
 18354      }
 18355    }
 18356    return result, nil
 18357  }
 18358  
 18359  func ParseSocketAcceptArgs(decoder *Decoder) (types.SocketAcceptArgs, error) {
 18360    var result types.SocketAcceptArgs
 18361    var err error
 18362  
 18363    var numArgs uint8
 18364    err = decoder.DecodeUint8(&numArgs)
 18365    if err != nil {
 18366      return types.SocketAcceptArgs{}, err
 18367    }
 18368  
 18369    for arg := 0; arg < int(numArgs); arg++ {
 18370      var currArg uint8
 18371      err = decoder.DecodeUint8(&currArg)
 18372      if err != nil {
 18373        return types.SocketAcceptArgs{}, err
 18374      }
 18375  
 18376      switch currArg {
 18377      case 0:
 18378        err = decoder.DecodeInt32(&result.Sockfd)
 18379        if err != nil {
 18380          return types.SocketAcceptArgs{}, err
 18381        }
 18382      case 1:
 18383        result.LocalAddr, err = decoder.ReadSockaddrFromBuff()
 18384        if err != nil {
 18385          return types.SocketAcceptArgs{}, err
 18386        }
 18387      case 2:
 18388        result.RemoteAddr, err = decoder.ReadSockaddrFromBuff()
 18389        if err != nil {
 18390          return types.SocketAcceptArgs{}, err
 18391        }
 18392      }
 18393    }
 18394    return result, nil
 18395  }
 18396  
 18397  func ParseLoadElfPhdrsArgs(decoder *Decoder) (types.LoadElfPhdrsArgs, error) {
 18398    var result types.LoadElfPhdrsArgs
 18399    var err error
 18400  
 18401    var numArgs uint8
 18402    err = decoder.DecodeUint8(&numArgs)
 18403    if err != nil {
 18404      return types.LoadElfPhdrsArgs{}, err
 18405    }
 18406  
 18407    for arg := 0; arg < int(numArgs); arg++ {
 18408      var currArg uint8
 18409      err = decoder.DecodeUint8(&currArg)
 18410      if err != nil {
 18411        return types.LoadElfPhdrsArgs{}, err
 18412      }
 18413  
 18414      switch currArg {
 18415      case 0:
 18416        result.Pathname, err = decoder.ReadStringFromBuff()
 18417        if err != nil {
 18418          return types.LoadElfPhdrsArgs{}, err
 18419        }
 18420      case 1:
 18421        err = decoder.DecodeUint32(&result.Dev)
 18422        if err != nil {
 18423          return types.LoadElfPhdrsArgs{}, err
 18424        }
 18425      case 2:
 18426        err = decoder.DecodeUint64(&result.Inode)
 18427        if err != nil {
 18428          return types.LoadElfPhdrsArgs{}, err
 18429        }
 18430      }
 18431    }
 18432    return result, nil
 18433  }
 18434  
 18435  func ParsePrintNetSeqOpsArgs(decoder *Decoder) (types.PrintNetSeqOpsArgs, error) {
 18436    var result types.PrintNetSeqOpsArgs
 18437    var err error
 18438  
 18439    var numArgs uint8
 18440    err = decoder.DecodeUint8(&numArgs)
 18441    if err != nil {
 18442      return types.PrintNetSeqOpsArgs{}, err
 18443    }
 18444  
 18445    for arg := 0; arg < int(numArgs); arg++ {
 18446      var currArg uint8
 18447      err = decoder.DecodeUint8(&currArg)
 18448      if err != nil {
 18449        return types.PrintNetSeqOpsArgs{}, err
 18450      }
 18451  
 18452      switch currArg {
 18453      case 0:
 18454        err = decoder.DecodeUint64Array(&result.NetSeqOps)
 18455        if err != nil {
 18456          return types.PrintNetSeqOpsArgs{}, err
 18457        }
 18458      case 1:
 18459        err = decoder.DecodeUint64(&result.CallerContextId)
 18460        if err != nil {
 18461          return types.PrintNetSeqOpsArgs{}, err
 18462        }
 18463      }
 18464    }
 18465    return result, nil
 18466  }
 18467  
 18468  func ParseHookedSeqOpsArgs(decoder *Decoder) (types.HookedSeqOpsArgs, error) {
 18469    var result types.HookedSeqOpsArgs
 18470    var err error
 18471  
 18472    var numArgs uint8
 18473    err = decoder.DecodeUint8(&numArgs)
 18474    if err != nil {
 18475      return types.HookedSeqOpsArgs{}, err
 18476    }
 18477  
 18478    for arg := 0; arg < int(numArgs); arg++ {
 18479      var currArg uint8
 18480      err = decoder.DecodeUint8(&currArg)
 18481      if err != nil {
 18482        return types.HookedSeqOpsArgs{}, err
 18483      }
 18484  
 18485      switch currArg {
 18486      case 0:
 18487        var dataHookedSeqOps uint64
 18488        err = decoder.DecodeUint64(&dataHookedSeqOps)
 18489        if err != nil {
 18490          return types.HookedSeqOpsArgs{}, err
 18491        }
 18492        result.HookedSeqOps = uintptr(dataHookedSeqOps)
 18493      }
 18494    }
 18495    return result, nil
 18496  }
 18497  
 18498  func ParseTaskRenameArgs(decoder *Decoder) (types.TaskRenameArgs, error) {
 18499    var result types.TaskRenameArgs
 18500    var err error
 18501  
 18502    var numArgs uint8
 18503    err = decoder.DecodeUint8(&numArgs)
 18504    if err != nil {
 18505      return types.TaskRenameArgs{}, err
 18506    }
 18507  
 18508    for arg := 0; arg < int(numArgs); arg++ {
 18509      var currArg uint8
 18510      err = decoder.DecodeUint8(&currArg)
 18511      if err != nil {
 18512        return types.TaskRenameArgs{}, err
 18513      }
 18514  
 18515      switch currArg {
 18516      case 0:
 18517        result.OldName, err = decoder.ReadStringFromBuff()
 18518        if err != nil {
 18519          return types.TaskRenameArgs{}, err
 18520        }
 18521      case 1:
 18522        result.NewName, err = decoder.ReadStringFromBuff()
 18523        if err != nil {
 18524          return types.TaskRenameArgs{}, err
 18525        }
 18526      }
 18527    }
 18528    return result, nil
 18529  }
 18530  
 18531  func ParseSecurityInodeRenameArgs(decoder *Decoder) (types.SecurityInodeRenameArgs, error) {
 18532    var result types.SecurityInodeRenameArgs
 18533    var err error
 18534  
 18535    var numArgs uint8
 18536    err = decoder.DecodeUint8(&numArgs)
 18537    if err != nil {
 18538      return types.SecurityInodeRenameArgs{}, err
 18539    }
 18540  
 18541    for arg := 0; arg < int(numArgs); arg++ {
 18542      var currArg uint8
 18543      err = decoder.DecodeUint8(&currArg)
 18544      if err != nil {
 18545        return types.SecurityInodeRenameArgs{}, err
 18546      }
 18547  
 18548      switch currArg {
 18549      case 0:
 18550        result.OldPath, err = decoder.ReadStringFromBuff()
 18551        if err != nil {
 18552          return types.SecurityInodeRenameArgs{}, err
 18553        }
 18554      case 1:
 18555        result.NewPath, err = decoder.ReadStringFromBuff()
 18556        if err != nil {
 18557          return types.SecurityInodeRenameArgs{}, err
 18558        }
 18559      }
 18560    }
 18561    return result, nil
 18562  }
 18563  
 18564  func ParseDoSigactionArgs(decoder *Decoder) (types.DoSigactionArgs, error) {
 18565    var result types.DoSigactionArgs
 18566    var err error
 18567  
 18568    var numArgs uint8
 18569    err = decoder.DecodeUint8(&numArgs)
 18570    if err != nil {
 18571      return types.DoSigactionArgs{}, err
 18572    }
 18573  
 18574    for arg := 0; arg < int(numArgs); arg++ {
 18575      var currArg uint8
 18576      err = decoder.DecodeUint8(&currArg)
 18577      if err != nil {
 18578        return types.DoSigactionArgs{}, err
 18579      }
 18580  
 18581      switch currArg {
 18582      case 0:
 18583        err = decoder.DecodeInt32(&result.Sig)
 18584        if err != nil {
 18585          return types.DoSigactionArgs{}, err
 18586        }
 18587      case 1:
 18588        err = decoder.DecodeBool(&result.IsSaInitialized)
 18589        if err != nil {
 18590          return types.DoSigactionArgs{}, err
 18591        }
 18592      case 2:
 18593        err = decoder.DecodeUint64(&result.SaFlags)
 18594        if err != nil {
 18595          return types.DoSigactionArgs{}, err
 18596        }
 18597      case 3:
 18598        err = decoder.DecodeUint64(&result.SaMask)
 18599        if err != nil {
 18600          return types.DoSigactionArgs{}, err
 18601        }
 18602      case 4:
 18603        err = decoder.DecodeUint8(&result.SaHandleMethod)
 18604        if err != nil {
 18605          return types.DoSigactionArgs{}, err
 18606        }
 18607      case 5:
 18608        var dataSaHandler uint64
 18609        err = decoder.DecodeUint64(&dataSaHandler)
 18610        if err != nil {
 18611          return types.DoSigactionArgs{}, err
 18612        }
 18613        result.SaHandler = uintptr(dataSaHandler)
 18614      case 6:
 18615        err = decoder.DecodeBool(&result.IsOldSaInitialized)
 18616        if err != nil {
 18617          return types.DoSigactionArgs{}, err
 18618        }
 18619      case 7:
 18620        err = decoder.DecodeUint64(&result.OldSaFlags)
 18621        if err != nil {
 18622          return types.DoSigactionArgs{}, err
 18623        }
 18624      case 8:
 18625        err = decoder.DecodeUint64(&result.OldSaMask)
 18626        if err != nil {
 18627          return types.DoSigactionArgs{}, err
 18628        }
 18629      case 9:
 18630        err = decoder.DecodeUint8(&result.OldSaHandleMethod)
 18631        if err != nil {
 18632          return types.DoSigactionArgs{}, err
 18633        }
 18634      case 10:
 18635        var dataOldSaHandler uint64
 18636        err = decoder.DecodeUint64(&dataOldSaHandler)
 18637        if err != nil {
 18638          return types.DoSigactionArgs{}, err
 18639        }
 18640        result.OldSaHandler = uintptr(dataOldSaHandler)
 18641      }
 18642    }
 18643    return result, nil
 18644  }
 18645  
 18646  func ParseBpfAttachArgs(decoder *Decoder) (types.BpfAttachArgs, error) {
 18647    var result types.BpfAttachArgs
 18648    var err error
 18649  
 18650    var numArgs uint8
 18651    err = decoder.DecodeUint8(&numArgs)
 18652    if err != nil {
 18653      return types.BpfAttachArgs{}, err
 18654    }
 18655  
 18656    for arg := 0; arg < int(numArgs); arg++ {
 18657      var currArg uint8
 18658      err = decoder.DecodeUint8(&currArg)
 18659      if err != nil {
 18660        return types.BpfAttachArgs{}, err
 18661      }
 18662  
 18663      switch currArg {
 18664      case 0:
 18665        err = decoder.DecodeInt32(&result.ProgType)
 18666        if err != nil {
 18667          return types.BpfAttachArgs{}, err
 18668        }
 18669      case 1:
 18670        result.ProgName, err = decoder.ReadStringFromBuff()
 18671        if err != nil {
 18672          return types.BpfAttachArgs{}, err
 18673        }
 18674      case 2:
 18675        err = decoder.DecodeUint32(&result.ProgId)
 18676        if err != nil {
 18677          return types.BpfAttachArgs{}, err
 18678        }
 18679      case 3:
 18680        err = decoder.DecodeUint64Array(&result.ProgHelpers)
 18681        if err != nil {
 18682          return types.BpfAttachArgs{}, err
 18683        }
 18684      case 4:
 18685        result.SymbolName, err = decoder.ReadStringFromBuff()
 18686        if err != nil {
 18687          return types.BpfAttachArgs{}, err
 18688        }
 18689      case 5:
 18690        err = decoder.DecodeUint64(&result.SymbolAddr)
 18691        if err != nil {
 18692          return types.BpfAttachArgs{}, err
 18693        }
 18694      case 6:
 18695        err = decoder.DecodeInt32(&result.AttachType)
 18696        if err != nil {
 18697          return types.BpfAttachArgs{}, err
 18698        }
 18699      }
 18700    }
 18701    return result, nil
 18702  }
 18703  
 18704  func ParseKallsymsLookupNameArgs(decoder *Decoder) (types.KallsymsLookupNameArgs, error) {
 18705    var result types.KallsymsLookupNameArgs
 18706    var err error
 18707  
 18708    var numArgs uint8
 18709    err = decoder.DecodeUint8(&numArgs)
 18710    if err != nil {
 18711      return types.KallsymsLookupNameArgs{}, err
 18712    }
 18713  
 18714    for arg := 0; arg < int(numArgs); arg++ {
 18715      var currArg uint8
 18716      err = decoder.DecodeUint8(&currArg)
 18717      if err != nil {
 18718        return types.KallsymsLookupNameArgs{}, err
 18719      }
 18720  
 18721      switch currArg {
 18722      case 0:
 18723        result.SymbolName, err = decoder.ReadStringFromBuff()
 18724        if err != nil {
 18725          return types.KallsymsLookupNameArgs{}, err
 18726        }
 18727      case 1:
 18728        var dataSymbolAddress uint64
 18729        err = decoder.DecodeUint64(&dataSymbolAddress)
 18730        if err != nil {
 18731          return types.KallsymsLookupNameArgs{}, err
 18732        }
 18733        result.SymbolAddress = uintptr(dataSymbolAddress)
 18734      }
 18735    }
 18736    return result, nil
 18737  }
 18738  
 18739  func ParsePrintMemDumpArgs(decoder *Decoder) (types.PrintMemDumpArgs, error) {
 18740    var result types.PrintMemDumpArgs
 18741    var err error
 18742  
 18743    var numArgs uint8
 18744    err = decoder.DecodeUint8(&numArgs)
 18745    if err != nil {
 18746      return types.PrintMemDumpArgs{}, err
 18747    }
 18748  
 18749    for arg := 0; arg < int(numArgs); arg++ {
 18750      var currArg uint8
 18751      err = decoder.DecodeUint8(&currArg)
 18752      if err != nil {
 18753        return types.PrintMemDumpArgs{}, err
 18754      }
 18755  
 18756      switch currArg {
 18757      case 0:
 18758        result.Bytes, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.PrintMemDump))
 18759        if err != nil {
 18760          return types.PrintMemDumpArgs{}, err
 18761        }
 18762      case 1:
 18763        var dataAddress uint64
 18764        err = decoder.DecodeUint64(&dataAddress)
 18765        if err != nil {
 18766          return types.PrintMemDumpArgs{}, err
 18767        }
 18768        result.Address = uintptr(dataAddress)
 18769      case 2:
 18770        err = decoder.DecodeUint64(&result.Length)
 18771        if err != nil {
 18772          return types.PrintMemDumpArgs{}, err
 18773        }
 18774      case 3:
 18775        err = decoder.DecodeUint64(&result.CallerContextId)
 18776        if err != nil {
 18777          return types.PrintMemDumpArgs{}, err
 18778        }
 18779      case 4:
 18780        result.Arch, err = decoder.ReadStringFromBuff()
 18781        if err != nil {
 18782          return types.PrintMemDumpArgs{}, err
 18783        }
 18784      case 5:
 18785        result.SymbolName, err = decoder.ReadStringFromBuff()
 18786        if err != nil {
 18787          return types.PrintMemDumpArgs{}, err
 18788        }
 18789      case 6:
 18790        result.SymbolOwner, err = decoder.ReadStringFromBuff()
 18791        if err != nil {
 18792          return types.PrintMemDumpArgs{}, err
 18793        }
 18794      }
 18795    }
 18796    return result, nil
 18797  }
 18798  
 18799  func ParseVfsReadArgs(decoder *Decoder) (types.VfsReadArgs, error) {
 18800    var result types.VfsReadArgs
 18801    var err error
 18802  
 18803    var numArgs uint8
 18804    err = decoder.DecodeUint8(&numArgs)
 18805    if err != nil {
 18806      return types.VfsReadArgs{}, err
 18807    }
 18808  
 18809    for arg := 0; arg < int(numArgs); arg++ {
 18810      var currArg uint8
 18811      err = decoder.DecodeUint8(&currArg)
 18812      if err != nil {
 18813        return types.VfsReadArgs{}, err
 18814      }
 18815  
 18816      switch currArg {
 18817      case 0:
 18818        result.Pathname, err = decoder.ReadStringFromBuff()
 18819        if err != nil {
 18820          return types.VfsReadArgs{}, err
 18821        }
 18822      case 1:
 18823        err = decoder.DecodeUint32(&result.Dev)
 18824        if err != nil {
 18825          return types.VfsReadArgs{}, err
 18826        }
 18827      case 2:
 18828        err = decoder.DecodeUint64(&result.Inode)
 18829        if err != nil {
 18830          return types.VfsReadArgs{}, err
 18831        }
 18832      case 3:
 18833        err = decoder.DecodeUint64(&result.Count)
 18834        if err != nil {
 18835          return types.VfsReadArgs{}, err
 18836        }
 18837      case 4:
 18838        err = decoder.DecodeUint64(&result.Pos)
 18839        if err != nil {
 18840          return types.VfsReadArgs{}, err
 18841        }
 18842      }
 18843    }
 18844    return result, nil
 18845  }
 18846  
 18847  func ParseVfsReadvArgs(decoder *Decoder) (types.VfsReadvArgs, error) {
 18848    var result types.VfsReadvArgs
 18849    var err error
 18850  
 18851    var numArgs uint8
 18852    err = decoder.DecodeUint8(&numArgs)
 18853    if err != nil {
 18854      return types.VfsReadvArgs{}, err
 18855    }
 18856  
 18857    for arg := 0; arg < int(numArgs); arg++ {
 18858      var currArg uint8
 18859      err = decoder.DecodeUint8(&currArg)
 18860      if err != nil {
 18861        return types.VfsReadvArgs{}, err
 18862      }
 18863  
 18864      switch currArg {
 18865      case 0:
 18866        result.Pathname, err = decoder.ReadStringFromBuff()
 18867        if err != nil {
 18868          return types.VfsReadvArgs{}, err
 18869        }
 18870      case 1:
 18871        err = decoder.DecodeUint32(&result.Dev)
 18872        if err != nil {
 18873          return types.VfsReadvArgs{}, err
 18874        }
 18875      case 2:
 18876        err = decoder.DecodeUint64(&result.Inode)
 18877        if err != nil {
 18878          return types.VfsReadvArgs{}, err
 18879        }
 18880      case 3:
 18881        err = decoder.DecodeUint64(&result.Vlen)
 18882        if err != nil {
 18883          return types.VfsReadvArgs{}, err
 18884        }
 18885      case 4:
 18886        err = decoder.DecodeUint64(&result.Pos)
 18887        if err != nil {
 18888          return types.VfsReadvArgs{}, err
 18889        }
 18890      }
 18891    }
 18892    return result, nil
 18893  }
 18894  
 18895  func ParseVfsUtimesArgs(decoder *Decoder) (types.VfsUtimesArgs, error) {
 18896    var result types.VfsUtimesArgs
 18897    var err error
 18898  
 18899    var numArgs uint8
 18900    err = decoder.DecodeUint8(&numArgs)
 18901    if err != nil {
 18902      return types.VfsUtimesArgs{}, err
 18903    }
 18904  
 18905    for arg := 0; arg < int(numArgs); arg++ {
 18906      var currArg uint8
 18907      err = decoder.DecodeUint8(&currArg)
 18908      if err != nil {
 18909        return types.VfsUtimesArgs{}, err
 18910      }
 18911  
 18912      switch currArg {
 18913      case 0:
 18914        result.Pathname, err = decoder.ReadStringFromBuff()
 18915        if err != nil {
 18916          return types.VfsUtimesArgs{}, err
 18917        }
 18918      case 1:
 18919        err = decoder.DecodeUint32(&result.Dev)
 18920        if err != nil {
 18921          return types.VfsUtimesArgs{}, err
 18922        }
 18923      case 2:
 18924        err = decoder.DecodeUint64(&result.Inode)
 18925        if err != nil {
 18926          return types.VfsUtimesArgs{}, err
 18927        }
 18928      case 3:
 18929        err = decoder.DecodeUint64(&result.Atime)
 18930        if err != nil {
 18931          return types.VfsUtimesArgs{}, err
 18932        }
 18933      case 4:
 18934        err = decoder.DecodeUint64(&result.Mtime)
 18935        if err != nil {
 18936          return types.VfsUtimesArgs{}, err
 18937        }
 18938      }
 18939    }
 18940    return result, nil
 18941  }
 18942  
 18943  func ParseDoTruncateArgs(decoder *Decoder) (types.DoTruncateArgs, error) {
 18944    var result types.DoTruncateArgs
 18945    var err error
 18946  
 18947    var numArgs uint8
 18948    err = decoder.DecodeUint8(&numArgs)
 18949    if err != nil {
 18950      return types.DoTruncateArgs{}, err
 18951    }
 18952  
 18953    for arg := 0; arg < int(numArgs); arg++ {
 18954      var currArg uint8
 18955      err = decoder.DecodeUint8(&currArg)
 18956      if err != nil {
 18957        return types.DoTruncateArgs{}, err
 18958      }
 18959  
 18960      switch currArg {
 18961      case 0:
 18962        result.Pathname, err = decoder.ReadStringFromBuff()
 18963        if err != nil {
 18964          return types.DoTruncateArgs{}, err
 18965        }
 18966      case 1:
 18967        err = decoder.DecodeUint64(&result.Inode)
 18968        if err != nil {
 18969          return types.DoTruncateArgs{}, err
 18970        }
 18971      case 2:
 18972        err = decoder.DecodeUint32(&result.Dev)
 18973        if err != nil {
 18974          return types.DoTruncateArgs{}, err
 18975        }
 18976      case 3:
 18977        err = decoder.DecodeUint64(&result.Length)
 18978        if err != nil {
 18979          return types.DoTruncateArgs{}, err
 18980        }
 18981      }
 18982    }
 18983    return result, nil
 18984  }
 18985  
 18986  func ParseFileModificationArgs(decoder *Decoder) (types.FileModificationArgs, error) {
 18987    var result types.FileModificationArgs
 18988    var err error
 18989  
 18990    var numArgs uint8
 18991    err = decoder.DecodeUint8(&numArgs)
 18992    if err != nil {
 18993      return types.FileModificationArgs{}, err
 18994    }
 18995  
 18996    for arg := 0; arg < int(numArgs); arg++ {
 18997      var currArg uint8
 18998      err = decoder.DecodeUint8(&currArg)
 18999      if err != nil {
 19000        return types.FileModificationArgs{}, err
 19001      }
 19002  
 19003      switch currArg {
 19004      case 0:
 19005        result.FilePath, err = decoder.ReadStringFromBuff()
 19006        if err != nil {
 19007          return types.FileModificationArgs{}, err
 19008        }
 19009      case 1:
 19010        err = decoder.DecodeUint32(&result.Dev)
 19011        if err != nil {
 19012          return types.FileModificationArgs{}, err
 19013        }
 19014      case 2:
 19015        err = decoder.DecodeUint64(&result.Inode)
 19016        if err != nil {
 19017          return types.FileModificationArgs{}, err
 19018        }
 19019      case 3:
 19020        err = decoder.DecodeUint64(&result.OldCtime)
 19021        if err != nil {
 19022          return types.FileModificationArgs{}, err
 19023        }
 19024      case 4:
 19025        err = decoder.DecodeUint64(&result.NewCtime)
 19026        if err != nil {
 19027          return types.FileModificationArgs{}, err
 19028        }
 19029      }
 19030    }
 19031    return result, nil
 19032  }
 19033  
 19034  func ParseInotifyWatchArgs(decoder *Decoder) (types.InotifyWatchArgs, error) {
 19035    var result types.InotifyWatchArgs
 19036    var err error
 19037  
 19038    var numArgs uint8
 19039    err = decoder.DecodeUint8(&numArgs)
 19040    if err != nil {
 19041      return types.InotifyWatchArgs{}, err
 19042    }
 19043  
 19044    for arg := 0; arg < int(numArgs); arg++ {
 19045      var currArg uint8
 19046      err = decoder.DecodeUint8(&currArg)
 19047      if err != nil {
 19048        return types.InotifyWatchArgs{}, err
 19049      }
 19050  
 19051      switch currArg {
 19052      case 0:
 19053        result.Pathname, err = decoder.ReadStringFromBuff()
 19054        if err != nil {
 19055          return types.InotifyWatchArgs{}, err
 19056        }
 19057      case 1:
 19058        err = decoder.DecodeUint64(&result.Inode)
 19059        if err != nil {
 19060          return types.InotifyWatchArgs{}, err
 19061        }
 19062      case 2:
 19063        err = decoder.DecodeUint32(&result.Dev)
 19064        if err != nil {
 19065          return types.InotifyWatchArgs{}, err
 19066        }
 19067      }
 19068    }
 19069    return result, nil
 19070  }
 19071  
 19072  func ParseProcessExecuteFailedArgs(decoder *Decoder) (types.ProcessExecuteFailedArgs, error) {
 19073    var result types.ProcessExecuteFailedArgs
 19074    var err error
 19075  
 19076    var numArgs uint8
 19077    err = decoder.DecodeUint8(&numArgs)
 19078    if err != nil {
 19079      return types.ProcessExecuteFailedArgs{}, err
 19080    }
 19081  
 19082    for arg := 0; arg < int(numArgs); arg++ {
 19083      var currArg uint8
 19084      err = decoder.DecodeUint8(&currArg)
 19085      if err != nil {
 19086        return types.ProcessExecuteFailedArgs{}, err
 19087      }
 19088  
 19089      switch currArg {
 19090      case 0:
 19091        result.Path, err = decoder.ReadStringFromBuff()
 19092        if err != nil {
 19093          return types.ProcessExecuteFailedArgs{}, err
 19094        }
 19095      case 1:
 19096        result.BinaryPath, err = decoder.ReadStringFromBuff()
 19097        if err != nil {
 19098          return types.ProcessExecuteFailedArgs{}, err
 19099        }
 19100      case 2:
 19101        err = decoder.DecodeUint32(&result.BinaryDeviceId)
 19102        if err != nil {
 19103          return types.ProcessExecuteFailedArgs{}, err
 19104        }
 19105      case 3:
 19106        err = decoder.DecodeUint64(&result.BinaryInodeNumber)
 19107        if err != nil {
 19108          return types.ProcessExecuteFailedArgs{}, err
 19109        }
 19110      case 4:
 19111        err = decoder.DecodeUint64(&result.BinaryCtime)
 19112        if err != nil {
 19113          return types.ProcessExecuteFailedArgs{}, err
 19114        }
 19115      case 5:
 19116        err = decoder.DecodeUint16(&result.BinaryInodeMode)
 19117        if err != nil {
 19118          return types.ProcessExecuteFailedArgs{}, err
 19119        }
 19120      case 6:
 19121        result.InterpreterPath, err = decoder.ReadStringFromBuff()
 19122        if err != nil {
 19123          return types.ProcessExecuteFailedArgs{}, err
 19124        }
 19125      case 7:
 19126        err = decoder.DecodeUint16(&result.StdinType)
 19127        if err != nil {
 19128          return types.ProcessExecuteFailedArgs{}, err
 19129        }
 19130      case 8:
 19131        result.StdinPath, err = decoder.ReadStringFromBuff()
 19132        if err != nil {
 19133          return types.ProcessExecuteFailedArgs{}, err
 19134        }
 19135      case 9:
 19136        err = decoder.DecodeInt32(&result.KernelInvoked)
 19137        if err != nil {
 19138          return types.ProcessExecuteFailedArgs{}, err
 19139        }
 19140      case 10:
 19141        result.BinaryArguments, err = decoder.ReadStringArrayFromBuff()
 19142        if err != nil {
 19143          return types.ProcessExecuteFailedArgs{}, err
 19144        }
 19145      case 11:
 19146        result.Environment, err = decoder.ReadStringArrayFromBuff()
 19147        if err != nil {
 19148          return types.ProcessExecuteFailedArgs{}, err
 19149        }
 19150      }
 19151    }
 19152    return result, nil
 19153  }
 19154  
 19155  func ParseTtyOpenArgs(decoder *Decoder) (types.TtyOpenArgs, error) {
 19156    var result types.TtyOpenArgs
 19157    var err error
 19158  
 19159    var numArgs uint8
 19160    err = decoder.DecodeUint8(&numArgs)
 19161    if err != nil {
 19162      return types.TtyOpenArgs{}, err
 19163    }
 19164  
 19165    for arg := 0; arg < int(numArgs); arg++ {
 19166      var currArg uint8
 19167      err = decoder.DecodeUint8(&currArg)
 19168      if err != nil {
 19169        return types.TtyOpenArgs{}, err
 19170      }
 19171  
 19172      switch currArg {
 19173      case 0:
 19174        result.Path, err = decoder.ReadStringFromBuff()
 19175        if err != nil {
 19176          return types.TtyOpenArgs{}, err
 19177        }
 19178      case 1:
 19179        err = decoder.DecodeUint64(&result.Inode)
 19180        if err != nil {
 19181          return types.TtyOpenArgs{}, err
 19182        }
 19183      case 2:
 19184        err = decoder.DecodeUint16(&result.InodeMode)
 19185        if err != nil {
 19186          return types.TtyOpenArgs{}, err
 19187        }
 19188      case 3:
 19189        err = decoder.DecodeUint32(&result.Dev)
 19190        if err != nil {
 19191          return types.TtyOpenArgs{}, err
 19192        }
 19193      }
 19194    }
 19195    return result, nil
 19196  }
 19197  
 19198  func ParseNetPacketBaseArgs(decoder *Decoder) (types.NetPacketBaseArgs, error) {
 19199    return types.NetPacketBaseArgs{}, nil
 19200  }
 19201  
 19202  func ParseNetPacketIPBaseArgs(decoder *Decoder) (types.NetPacketIPBaseArgs, error) {
 19203    var result types.NetPacketIPBaseArgs
 19204    var err error
 19205  
 19206    var numArgs uint8
 19207    err = decoder.DecodeUint8(&numArgs)
 19208    if err != nil {
 19209      return types.NetPacketIPBaseArgs{}, err
 19210    }
 19211  
 19212    for arg := 0; arg < int(numArgs); arg++ {
 19213      var currArg uint8
 19214      err = decoder.DecodeUint8(&currArg)
 19215      if err != nil {
 19216        return types.NetPacketIPBaseArgs{}, err
 19217      }
 19218  
 19219      switch currArg {
 19220      case 0:
 19221        result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketIPBase))
 19222        if err != nil {
 19223          return types.NetPacketIPBaseArgs{}, err
 19224        }
 19225      }
 19226    }
 19227    return result, nil
 19228  }
 19229  
 19230  func ParseNetPacketIPv4Args(decoder *Decoder) (types.NetPacketIPv4Args, error) {
 19231    var result types.NetPacketIPv4Args
 19232    var err error
 19233  
 19234    var numArgs uint8
 19235    err = decoder.DecodeUint8(&numArgs)
 19236    if err != nil {
 19237      return types.NetPacketIPv4Args{}, err
 19238    }
 19239  
 19240    for arg := 0; arg < int(numArgs); arg++ {
 19241      var currArg uint8
 19242      err = decoder.DecodeUint8(&currArg)
 19243      if err != nil {
 19244        return types.NetPacketIPv4Args{}, err
 19245      }
 19246  
 19247      switch currArg {
 19248      case 0:
 19249        result.Src, err = decoder.ReadStringFromBuff()
 19250        if err != nil {
 19251          return types.NetPacketIPv4Args{}, err
 19252        }
 19253      case 1:
 19254        result.Dst, err = decoder.ReadStringFromBuff()
 19255        if err != nil {
 19256          return types.NetPacketIPv4Args{}, err
 19257        }
 19258      case 2:
 19259        var dataProtoIpv4 uint64
 19260        err = decoder.DecodeUint64(&dataProtoIpv4)
 19261        if err != nil {
 19262          return types.NetPacketIPv4Args{}, err
 19263        }
 19264        result.ProtoIpv4 = uintptr(dataProtoIpv4)
 19265      }
 19266    }
 19267    return result, nil
 19268  }
 19269  
 19270  func ParseNetPacketIPv6Args(decoder *Decoder) (types.NetPacketIPv6Args, error) {
 19271    var result types.NetPacketIPv6Args
 19272    var err error
 19273  
 19274    var numArgs uint8
 19275    err = decoder.DecodeUint8(&numArgs)
 19276    if err != nil {
 19277      return types.NetPacketIPv6Args{}, err
 19278    }
 19279  
 19280    for arg := 0; arg < int(numArgs); arg++ {
 19281      var currArg uint8
 19282      err = decoder.DecodeUint8(&currArg)
 19283      if err != nil {
 19284        return types.NetPacketIPv6Args{}, err
 19285      }
 19286  
 19287      switch currArg {
 19288      case 0:
 19289        result.Src, err = decoder.ReadStringFromBuff()
 19290        if err != nil {
 19291          return types.NetPacketIPv6Args{}, err
 19292        }
 19293      case 1:
 19294        result.Dst, err = decoder.ReadStringFromBuff()
 19295        if err != nil {
 19296          return types.NetPacketIPv6Args{}, err
 19297        }
 19298      case 2:
 19299        var dataProtoIpv6 uint64
 19300        err = decoder.DecodeUint64(&dataProtoIpv6)
 19301        if err != nil {
 19302          return types.NetPacketIPv6Args{}, err
 19303        }
 19304        result.ProtoIpv6 = uintptr(dataProtoIpv6)
 19305      }
 19306    }
 19307    return result, nil
 19308  }
 19309  
 19310  func ParseNetPacketTCPBaseArgs(decoder *Decoder) (types.NetPacketTCPBaseArgs, error) {
 19311    var result types.NetPacketTCPBaseArgs
 19312    var err error
 19313  
 19314    var numArgs uint8
 19315    err = decoder.DecodeUint8(&numArgs)
 19316    if err != nil {
 19317      return types.NetPacketTCPBaseArgs{}, err
 19318    }
 19319  
 19320    for arg := 0; arg < int(numArgs); arg++ {
 19321      var currArg uint8
 19322      err = decoder.DecodeUint8(&currArg)
 19323      if err != nil {
 19324        return types.NetPacketTCPBaseArgs{}, err
 19325      }
 19326  
 19327      switch currArg {
 19328      case 0:
 19329        result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketTCPBase))
 19330        if err != nil {
 19331          return types.NetPacketTCPBaseArgs{}, err
 19332        }
 19333      }
 19334    }
 19335    return result, nil
 19336  }
 19337  
 19338  func ParseNetPacketTCPArgs(decoder *Decoder) (types.NetPacketTCPArgs, error) {
 19339    var result types.NetPacketTCPArgs
 19340    var err error
 19341  
 19342    var numArgs uint8
 19343    err = decoder.DecodeUint8(&numArgs)
 19344    if err != nil {
 19345      return types.NetPacketTCPArgs{}, err
 19346    }
 19347  
 19348    for arg := 0; arg < int(numArgs); arg++ {
 19349      var currArg uint8
 19350      err = decoder.DecodeUint8(&currArg)
 19351      if err != nil {
 19352        return types.NetPacketTCPArgs{}, err
 19353      }
 19354  
 19355      switch currArg {
 19356      case 0:
 19357        result.Src, err = decoder.ReadStringFromBuff()
 19358        if err != nil {
 19359          return types.NetPacketTCPArgs{}, err
 19360        }
 19361      case 1:
 19362        result.Dst, err = decoder.ReadStringFromBuff()
 19363        if err != nil {
 19364          return types.NetPacketTCPArgs{}, err
 19365        }
 19366      case 2:
 19367        err = decoder.DecodeUint16(&result.SrcPort)
 19368        if err != nil {
 19369          return types.NetPacketTCPArgs{}, err
 19370        }
 19371      case 3:
 19372        err = decoder.DecodeUint16(&result.DstPort)
 19373        if err != nil {
 19374          return types.NetPacketTCPArgs{}, err
 19375        }
 19376      case 4:
 19377        var dataProtoTcp uint64
 19378        err = decoder.DecodeUint64(&dataProtoTcp)
 19379        if err != nil {
 19380          return types.NetPacketTCPArgs{}, err
 19381        }
 19382        result.ProtoTcp = uintptr(dataProtoTcp)
 19383      }
 19384    }
 19385    return result, nil
 19386  }
 19387  
 19388  func ParseNetPacketUDPBaseArgs(decoder *Decoder) (types.NetPacketUDPBaseArgs, error) {
 19389    var result types.NetPacketUDPBaseArgs
 19390    var err error
 19391  
 19392    var numArgs uint8
 19393    err = decoder.DecodeUint8(&numArgs)
 19394    if err != nil {
 19395      return types.NetPacketUDPBaseArgs{}, err
 19396    }
 19397  
 19398    for arg := 0; arg < int(numArgs); arg++ {
 19399      var currArg uint8
 19400      err = decoder.DecodeUint8(&currArg)
 19401      if err != nil {
 19402        return types.NetPacketUDPBaseArgs{}, err
 19403      }
 19404  
 19405      switch currArg {
 19406      case 0:
 19407        result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketUDPBase))
 19408        if err != nil {
 19409          return types.NetPacketUDPBaseArgs{}, err
 19410        }
 19411      }
 19412    }
 19413    return result, nil
 19414  }
 19415  
 19416  func ParseNetPacketUDPArgs(decoder *Decoder) (types.NetPacketUDPArgs, error) {
 19417    var result types.NetPacketUDPArgs
 19418    var err error
 19419  
 19420    var numArgs uint8
 19421    err = decoder.DecodeUint8(&numArgs)
 19422    if err != nil {
 19423      return types.NetPacketUDPArgs{}, err
 19424    }
 19425  
 19426    for arg := 0; arg < int(numArgs); arg++ {
 19427      var currArg uint8
 19428      err = decoder.DecodeUint8(&currArg)
 19429      if err != nil {
 19430        return types.NetPacketUDPArgs{}, err
 19431      }
 19432  
 19433      switch currArg {
 19434      case 0:
 19435        result.Src, err = decoder.ReadStringFromBuff()
 19436        if err != nil {
 19437          return types.NetPacketUDPArgs{}, err
 19438        }
 19439      case 1:
 19440        result.Dst, err = decoder.ReadStringFromBuff()
 19441        if err != nil {
 19442          return types.NetPacketUDPArgs{}, err
 19443        }
 19444      case 2:
 19445        err = decoder.DecodeUint16(&result.SrcPort)
 19446        if err != nil {
 19447          return types.NetPacketUDPArgs{}, err
 19448        }
 19449      case 3:
 19450        err = decoder.DecodeUint16(&result.DstPort)
 19451        if err != nil {
 19452          return types.NetPacketUDPArgs{}, err
 19453        }
 19454      case 4:
 19455        var dataProtoUdp uint64
 19456        err = decoder.DecodeUint64(&dataProtoUdp)
 19457        if err != nil {
 19458          return types.NetPacketUDPArgs{}, err
 19459        }
 19460        result.ProtoUdp = uintptr(dataProtoUdp)
 19461      }
 19462    }
 19463    return result, nil
 19464  }
 19465  
 19466  func ParseNetPacketICMPBaseArgs(decoder *Decoder) (types.NetPacketICMPBaseArgs, error) {
 19467    var result types.NetPacketICMPBaseArgs
 19468    var err error
 19469  
 19470    var numArgs uint8
 19471    err = decoder.DecodeUint8(&numArgs)
 19472    if err != nil {
 19473      return types.NetPacketICMPBaseArgs{}, err
 19474    }
 19475  
 19476    for arg := 0; arg < int(numArgs); arg++ {
 19477      var currArg uint8
 19478      err = decoder.DecodeUint8(&currArg)
 19479      if err != nil {
 19480        return types.NetPacketICMPBaseArgs{}, err
 19481      }
 19482  
 19483      switch currArg {
 19484      case 0:
 19485        result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketICMPBase))
 19486        if err != nil {
 19487          return types.NetPacketICMPBaseArgs{}, err
 19488        }
 19489      }
 19490    }
 19491    return result, nil
 19492  }
 19493  
 19494  func ParseNetPacketICMPArgs(decoder *Decoder) (types.NetPacketICMPArgs, error) {
 19495    var result types.NetPacketICMPArgs
 19496    var err error
 19497  
 19498    var numArgs uint8
 19499    err = decoder.DecodeUint8(&numArgs)
 19500    if err != nil {
 19501      return types.NetPacketICMPArgs{}, err
 19502    }
 19503  
 19504    for arg := 0; arg < int(numArgs); arg++ {
 19505      var currArg uint8
 19506      err = decoder.DecodeUint8(&currArg)
 19507      if err != nil {
 19508        return types.NetPacketICMPArgs{}, err
 19509      }
 19510  
 19511      switch currArg {
 19512      case 0:
 19513        result.Src, err = decoder.ReadStringFromBuff()
 19514        if err != nil {
 19515          return types.NetPacketICMPArgs{}, err
 19516        }
 19517      case 1:
 19518        result.Dst, err = decoder.ReadStringFromBuff()
 19519        if err != nil {
 19520          return types.NetPacketICMPArgs{}, err
 19521        }
 19522      case 2:
 19523        var dataProtoIcmp uint64
 19524        err = decoder.DecodeUint64(&dataProtoIcmp)
 19525        if err != nil {
 19526          return types.NetPacketICMPArgs{}, err
 19527        }
 19528        result.ProtoIcmp = uintptr(dataProtoIcmp)
 19529      }
 19530    }
 19531    return result, nil
 19532  }
 19533  
 19534  func ParseNetPacketICMPv6BaseArgs(decoder *Decoder) (types.NetPacketICMPv6BaseArgs, error) {
 19535    var result types.NetPacketICMPv6BaseArgs
 19536    var err error
 19537  
 19538    var numArgs uint8
 19539    err = decoder.DecodeUint8(&numArgs)
 19540    if err != nil {
 19541      return types.NetPacketICMPv6BaseArgs{}, err
 19542    }
 19543  
 19544    for arg := 0; arg < int(numArgs); arg++ {
 19545      var currArg uint8
 19546      err = decoder.DecodeUint8(&currArg)
 19547      if err != nil {
 19548        return types.NetPacketICMPv6BaseArgs{}, err
 19549      }
 19550  
 19551      switch currArg {
 19552      case 0:
 19553        result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketICMPv6Base))
 19554        if err != nil {
 19555          return types.NetPacketICMPv6BaseArgs{}, err
 19556        }
 19557      }
 19558    }
 19559    return result, nil
 19560  }
 19561  
 19562  func ParseNetPacketICMPv6Args(decoder *Decoder) (types.NetPacketICMPv6Args, error) {
 19563    var result types.NetPacketICMPv6Args
 19564    var err error
 19565  
 19566    var numArgs uint8
 19567    err = decoder.DecodeUint8(&numArgs)
 19568    if err != nil {
 19569      return types.NetPacketICMPv6Args{}, err
 19570    }
 19571  
 19572    for arg := 0; arg < int(numArgs); arg++ {
 19573      var currArg uint8
 19574      err = decoder.DecodeUint8(&currArg)
 19575      if err != nil {
 19576        return types.NetPacketICMPv6Args{}, err
 19577      }
 19578  
 19579      switch currArg {
 19580      case 0:
 19581        result.Src, err = decoder.ReadStringFromBuff()
 19582        if err != nil {
 19583          return types.NetPacketICMPv6Args{}, err
 19584        }
 19585      case 1:
 19586        result.Dst, err = decoder.ReadStringFromBuff()
 19587        if err != nil {
 19588          return types.NetPacketICMPv6Args{}, err
 19589        }
 19590      case 2:
 19591        var dataProtoIcmpv6 uint64
 19592        err = decoder.DecodeUint64(&dataProtoIcmpv6)
 19593        if err != nil {
 19594          return types.NetPacketICMPv6Args{}, err
 19595        }
 19596        result.ProtoIcmpv6 = uintptr(dataProtoIcmpv6)
 19597      }
 19598    }
 19599    return result, nil
 19600  }
 19601  
 19602  func ParseNetPacketDNSBaseArgs(decoder *Decoder) (types.NetPacketDNSBaseArgs, error) {
 19603    var result types.NetPacketDNSBaseArgs
 19604    var err error
 19605  
 19606    var numArgs uint8
 19607    err = decoder.DecodeUint8(&numArgs)
 19608    if err != nil {
 19609      return types.NetPacketDNSBaseArgs{}, err
 19610    }
 19611  
 19612    for arg := 0; arg < int(numArgs); arg++ {
 19613      var currArg uint8
 19614      err = decoder.DecodeUint8(&currArg)
 19615      if err != nil {
 19616        return types.NetPacketDNSBaseArgs{}, err
 19617      }
 19618  
 19619      switch currArg {
 19620      case 0:
 19621        result.Payload, err = decoder.ReadProtoDNS()
 19622        if err != nil {
 19623          return types.NetPacketDNSBaseArgs{}, err
 19624        }
 19625      }
 19626    }
 19627    return result, nil
 19628  }
 19629  
 19630  func ParseNetPacketDNSArgs(decoder *Decoder) (types.NetPacketDNSArgs, error) {
 19631    var result types.NetPacketDNSArgs
 19632    var err error
 19633  
 19634    var numArgs uint8
 19635    err = decoder.DecodeUint8(&numArgs)
 19636    if err != nil {
 19637      return types.NetPacketDNSArgs{}, err
 19638    }
 19639  
 19640    for arg := 0; arg < int(numArgs); arg++ {
 19641      var currArg uint8
 19642      err = decoder.DecodeUint8(&currArg)
 19643      if err != nil {
 19644        return types.NetPacketDNSArgs{}, err
 19645      }
 19646  
 19647      switch currArg {
 19648      case 0:
 19649        result.Src, err = decoder.ReadStringFromBuff()
 19650        if err != nil {
 19651          return types.NetPacketDNSArgs{}, err
 19652        }
 19653      case 1:
 19654        result.Dst, err = decoder.ReadStringFromBuff()
 19655        if err != nil {
 19656          return types.NetPacketDNSArgs{}, err
 19657        }
 19658      case 2:
 19659        err = decoder.DecodeUint16(&result.SrcPort)
 19660        if err != nil {
 19661          return types.NetPacketDNSArgs{}, err
 19662        }
 19663      case 3:
 19664        err = decoder.DecodeUint16(&result.DstPort)
 19665        if err != nil {
 19666          return types.NetPacketDNSArgs{}, err
 19667        }
 19668      case 4:
 19669        var dataProtoDns uint64
 19670        err = decoder.DecodeUint64(&dataProtoDns)
 19671        if err != nil {
 19672          return types.NetPacketDNSArgs{}, err
 19673        }
 19674        result.ProtoDns = uintptr(dataProtoDns)
 19675      }
 19676    }
 19677    return result, nil
 19678  }
 19679  
 19680  func ParseNetPacketDNSRequestArgs(decoder *Decoder) (types.NetPacketDNSRequestArgs, error) {
 19681    var result types.NetPacketDNSRequestArgs
 19682    var err error
 19683  
 19684    var numArgs uint8
 19685    err = decoder.DecodeUint8(&numArgs)
 19686    if err != nil {
 19687      return types.NetPacketDNSRequestArgs{}, err
 19688    }
 19689  
 19690    for arg := 0; arg < int(numArgs); arg++ {
 19691      var currArg uint8
 19692      err = decoder.DecodeUint8(&currArg)
 19693      if err != nil {
 19694        return types.NetPacketDNSRequestArgs{}, err
 19695      }
 19696  
 19697      switch currArg {
 19698      case 0:
 19699        var dataMetadata uint64
 19700        err = decoder.DecodeUint64(&dataMetadata)
 19701        if err != nil {
 19702          return types.NetPacketDNSRequestArgs{}, err
 19703        }
 19704        result.Metadata = uintptr(dataMetadata)
 19705      case 1:
 19706        var dataDnsQuestions uint64
 19707        err = decoder.DecodeUint64(&dataDnsQuestions)
 19708        if err != nil {
 19709          return types.NetPacketDNSRequestArgs{}, err
 19710        }
 19711        result.DnsQuestions = uintptr(dataDnsQuestions)
 19712      }
 19713    }
 19714    return result, nil
 19715  }
 19716  
 19717  func ParseNetPacketDNSResponseArgs(decoder *Decoder) (types.NetPacketDNSResponseArgs, error) {
 19718    var result types.NetPacketDNSResponseArgs
 19719    var err error
 19720  
 19721    var numArgs uint8
 19722    err = decoder.DecodeUint8(&numArgs)
 19723    if err != nil {
 19724      return types.NetPacketDNSResponseArgs{}, err
 19725    }
 19726  
 19727    for arg := 0; arg < int(numArgs); arg++ {
 19728      var currArg uint8
 19729      err = decoder.DecodeUint8(&currArg)
 19730      if err != nil {
 19731        return types.NetPacketDNSResponseArgs{}, err
 19732      }
 19733  
 19734      switch currArg {
 19735      case 0:
 19736        var dataMetadata uint64
 19737        err = decoder.DecodeUint64(&dataMetadata)
 19738        if err != nil {
 19739          return types.NetPacketDNSResponseArgs{}, err
 19740        }
 19741        result.Metadata = uintptr(dataMetadata)
 19742      case 1:
 19743        var dataDnsResponse uint64
 19744        err = decoder.DecodeUint64(&dataDnsResponse)
 19745        if err != nil {
 19746          return types.NetPacketDNSResponseArgs{}, err
 19747        }
 19748        result.DnsResponse = uintptr(dataDnsResponse)
 19749      }
 19750    }
 19751    return result, nil
 19752  }
 19753  
 19754  func ParseNetPacketHTTPBaseArgs(decoder *Decoder) (types.NetPacketHTTPBaseArgs, error) {
 19755    var result types.NetPacketHTTPBaseArgs
 19756    var err error
 19757  
 19758    var numArgs uint8
 19759    err = decoder.DecodeUint8(&numArgs)
 19760    if err != nil {
 19761      return types.NetPacketHTTPBaseArgs{}, err
 19762    }
 19763  
 19764    for arg := 0; arg < int(numArgs); arg++ {
 19765      var currArg uint8
 19766      err = decoder.DecodeUint8(&currArg)
 19767      if err != nil {
 19768        return types.NetPacketHTTPBaseArgs{}, err
 19769      }
 19770  
 19771      switch currArg {
 19772      case 0:
 19773        result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketHTTPBase))
 19774        if err != nil {
 19775          return types.NetPacketHTTPBaseArgs{}, err
 19776        }
 19777      }
 19778    }
 19779    return result, nil
 19780  }
 19781  
 19782  func ParseNetPacketHTTPArgs(decoder *Decoder) (types.NetPacketHTTPArgs, error) {
 19783    var result types.NetPacketHTTPArgs
 19784    var err error
 19785  
 19786    var numArgs uint8
 19787    err = decoder.DecodeUint8(&numArgs)
 19788    if err != nil {
 19789      return types.NetPacketHTTPArgs{}, err
 19790    }
 19791  
 19792    for arg := 0; arg < int(numArgs); arg++ {
 19793      var currArg uint8
 19794      err = decoder.DecodeUint8(&currArg)
 19795      if err != nil {
 19796        return types.NetPacketHTTPArgs{}, err
 19797      }
 19798  
 19799      switch currArg {
 19800      case 0:
 19801        result.Src, err = decoder.ReadStringFromBuff()
 19802        if err != nil {
 19803          return types.NetPacketHTTPArgs{}, err
 19804        }
 19805      case 1:
 19806        result.Dst, err = decoder.ReadStringFromBuff()
 19807        if err != nil {
 19808          return types.NetPacketHTTPArgs{}, err
 19809        }
 19810      case 2:
 19811        err = decoder.DecodeUint16(&result.SrcPort)
 19812        if err != nil {
 19813          return types.NetPacketHTTPArgs{}, err
 19814        }
 19815      case 3:
 19816        err = decoder.DecodeUint16(&result.DstPort)
 19817        if err != nil {
 19818          return types.NetPacketHTTPArgs{}, err
 19819        }
 19820      case 4:
 19821        var dataProtoHttp uint64
 19822        err = decoder.DecodeUint64(&dataProtoHttp)
 19823        if err != nil {
 19824          return types.NetPacketHTTPArgs{}, err
 19825        }
 19826        result.ProtoHttp = uintptr(dataProtoHttp)
 19827      }
 19828    }
 19829    return result, nil
 19830  }
 19831  
 19832  func ParseNetPacketHTTPRequestArgs(decoder *Decoder) (types.NetPacketHTTPRequestArgs, error) {
 19833    var result types.NetPacketHTTPRequestArgs
 19834    var err error
 19835  
 19836    var numArgs uint8
 19837    err = decoder.DecodeUint8(&numArgs)
 19838    if err != nil {
 19839      return types.NetPacketHTTPRequestArgs{}, err
 19840    }
 19841  
 19842    for arg := 0; arg < int(numArgs); arg++ {
 19843      var currArg uint8
 19844      err = decoder.DecodeUint8(&currArg)
 19845      if err != nil {
 19846        return types.NetPacketHTTPRequestArgs{}, err
 19847      }
 19848  
 19849      switch currArg {
 19850      case 0:
 19851        var dataMetadata uint64
 19852        err = decoder.DecodeUint64(&dataMetadata)
 19853        if err != nil {
 19854          return types.NetPacketHTTPRequestArgs{}, err
 19855        }
 19856        result.Metadata = uintptr(dataMetadata)
 19857      case 1:
 19858        var dataHttpRequest uint64
 19859        err = decoder.DecodeUint64(&dataHttpRequest)
 19860        if err != nil {
 19861          return types.NetPacketHTTPRequestArgs{}, err
 19862        }
 19863        result.HttpRequest = uintptr(dataHttpRequest)
 19864      }
 19865    }
 19866    return result, nil
 19867  }
 19868  
 19869  func ParseNetPacketHTTPResponseArgs(decoder *Decoder) (types.NetPacketHTTPResponseArgs, error) {
 19870    var result types.NetPacketHTTPResponseArgs
 19871    var err error
 19872  
 19873    var numArgs uint8
 19874    err = decoder.DecodeUint8(&numArgs)
 19875    if err != nil {
 19876      return types.NetPacketHTTPResponseArgs{}, err
 19877    }
 19878  
 19879    for arg := 0; arg < int(numArgs); arg++ {
 19880      var currArg uint8
 19881      err = decoder.DecodeUint8(&currArg)
 19882      if err != nil {
 19883        return types.NetPacketHTTPResponseArgs{}, err
 19884      }
 19885  
 19886      switch currArg {
 19887      case 0:
 19888        var dataMetadata uint64
 19889        err = decoder.DecodeUint64(&dataMetadata)
 19890        if err != nil {
 19891          return types.NetPacketHTTPResponseArgs{}, err
 19892        }
 19893        result.Metadata = uintptr(dataMetadata)
 19894      case 1:
 19895        var dataHttpResponse uint64
 19896        err = decoder.DecodeUint64(&dataHttpResponse)
 19897        if err != nil {
 19898          return types.NetPacketHTTPResponseArgs{}, err
 19899        }
 19900        result.HttpResponse = uintptr(dataHttpResponse)
 19901      }
 19902    }
 19903    return result, nil
 19904  }
 19905  
 19906  func ParseNetPacketSOCKS5BaseArgs(decoder *Decoder) (types.NetPacketSOCKS5BaseArgs, error) {
 19907    var result types.NetPacketSOCKS5BaseArgs
 19908    var err error
 19909  
 19910    var numArgs uint8
 19911    err = decoder.DecodeUint8(&numArgs)
 19912    if err != nil {
 19913      return types.NetPacketSOCKS5BaseArgs{}, err
 19914    }
 19915  
 19916    for arg := 0; arg < int(numArgs); arg++ {
 19917      var currArg uint8
 19918      err = decoder.DecodeUint8(&currArg)
 19919      if err != nil {
 19920        return types.NetPacketSOCKS5BaseArgs{}, err
 19921      }
 19922  
 19923      switch currArg {
 19924      case 0:
 19925        result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketSOCKS5Base))
 19926        if err != nil {
 19927          return types.NetPacketSOCKS5BaseArgs{}, err
 19928        }
 19929      }
 19930    }
 19931    return result, nil
 19932  }
 19933  
 19934  func ParseNetPacketCaptureArgs(decoder *Decoder) (types.NetPacketCaptureArgs, error) {
 19935    var result types.NetPacketCaptureArgs
 19936    var err error
 19937  
 19938    var numArgs uint8
 19939    err = decoder.DecodeUint8(&numArgs)
 19940    if err != nil {
 19941      return types.NetPacketCaptureArgs{}, err
 19942    }
 19943  
 19944    for arg := 0; arg < int(numArgs); arg++ {
 19945      var currArg uint8
 19946      err = decoder.DecodeUint8(&currArg)
 19947      if err != nil {
 19948        return types.NetPacketCaptureArgs{}, err
 19949      }
 19950  
 19951      switch currArg {
 19952      case 0:
 19953        result.Payload, err = decoder.ReadMaxByteSliceFromBuff(eventMaxByteSliceBufferSize(events.NetPacketCapture))
 19954        if err != nil {
 19955          return types.NetPacketCaptureArgs{}, err
 19956        }
 19957      }
 19958    }
 19959    return result, nil
 19960  }
 19961  
 19962  func ParseCaptureNetPacketArgs(decoder *Decoder) (types.CaptureNetPacketArgs, error) {
 19963    return types.CaptureNetPacketArgs{}, nil
 19964  }
 19965  
 19966  func ParseSockSetStateArgs(decoder *Decoder) (types.SockSetStateArgs, error) {
 19967    var result types.SockSetStateArgs
 19968    var err error
 19969  
 19970    var numArgs uint8
 19971    err = decoder.DecodeUint8(&numArgs)
 19972    if err != nil {
 19973      return types.SockSetStateArgs{}, err
 19974    }
 19975  
 19976    for arg := 0; arg < int(numArgs); arg++ {
 19977      var currArg uint8
 19978      err = decoder.DecodeUint8(&currArg)
 19979      if err != nil {
 19980        return types.SockSetStateArgs{}, err
 19981      }
 19982  
 19983      switch currArg {
 19984      case 0:
 19985        err = decoder.DecodeUint32(&result.OldState)
 19986        if err != nil {
 19987          return types.SockSetStateArgs{}, err
 19988        }
 19989      case 1:
 19990        err = decoder.DecodeUint32(&result.NewState)
 19991        if err != nil {
 19992          return types.SockSetStateArgs{}, err
 19993        }
 19994      case 2:
 19995        result.Tuple, err = decoder.ReadAddrTuple()
 19996        if err != nil {
 19997          return types.SockSetStateArgs{}, err
 19998        }
 19999      }
 20000    }
 20001    return result, nil
 20002  }
 20003  
 20004  func ParseTrackSyscallStatsArgs(decoder *Decoder) (types.TrackSyscallStatsArgs, error) {
 20005    return types.TrackSyscallStatsArgs{}, nil
 20006  }
 20007  
 20008  func ParseTestEventArgs(decoder *Decoder) (types.TestEventArgs, error) {
 20009    return types.TestEventArgs{}, nil
 20010  }
 20011  
 20012  func ParseSignalCgroupMkdirArgs(decoder *Decoder) (types.SignalCgroupMkdirArgs, error) {
 20013    var result types.SignalCgroupMkdirArgs
 20014    var err error
 20015  
 20016    var numArgs uint8
 20017    err = decoder.DecodeUint8(&numArgs)
 20018    if err != nil {
 20019      return types.SignalCgroupMkdirArgs{}, err
 20020    }
 20021  
 20022    for arg := 0; arg < int(numArgs); arg++ {
 20023      var currArg uint8
 20024      err = decoder.DecodeUint8(&currArg)
 20025      if err != nil {
 20026        return types.SignalCgroupMkdirArgs{}, err
 20027      }
 20028  
 20029      switch currArg {
 20030      case 0:
 20031        err = decoder.DecodeUint64(&result.CgroupId)
 20032        if err != nil {
 20033          return types.SignalCgroupMkdirArgs{}, err
 20034        }
 20035      case 1:
 20036        result.CgroupPath, err = decoder.ReadStringFromBuff()
 20037        if err != nil {
 20038          return types.SignalCgroupMkdirArgs{}, err
 20039        }
 20040      case 2:
 20041        err = decoder.DecodeUint32(&result.HierarchyId)
 20042        if err != nil {
 20043          return types.SignalCgroupMkdirArgs{}, err
 20044        }
 20045      }
 20046    }
 20047    return result, nil
 20048  }
 20049  
 20050  func ParseSignalCgroupRmdirArgs(decoder *Decoder) (types.SignalCgroupRmdirArgs, error) {
 20051    var result types.SignalCgroupRmdirArgs
 20052    var err error
 20053  
 20054    var numArgs uint8
 20055    err = decoder.DecodeUint8(&numArgs)
 20056    if err != nil {
 20057      return types.SignalCgroupRmdirArgs{}, err
 20058    }
 20059  
 20060    for arg := 0; arg < int(numArgs); arg++ {
 20061      var currArg uint8
 20062      err = decoder.DecodeUint8(&currArg)
 20063      if err != nil {
 20064        return types.SignalCgroupRmdirArgs{}, err
 20065      }
 20066  
 20067      switch currArg {
 20068      case 0:
 20069        err = decoder.DecodeUint64(&result.CgroupId)
 20070        if err != nil {
 20071          return types.SignalCgroupRmdirArgs{}, err
 20072        }
 20073      case 1:
 20074        result.CgroupPath, err = decoder.ReadStringFromBuff()
 20075        if err != nil {
 20076          return types.SignalCgroupRmdirArgs{}, err
 20077        }
 20078      case 2:
 20079        err = decoder.DecodeUint32(&result.HierarchyId)
 20080        if err != nil {
 20081          return types.SignalCgroupRmdirArgs{}, err
 20082        }
 20083      }
 20084    }
 20085    return result, nil
 20086  }
 20087  
 20088  func ParseNetFlowBaseArgs(decoder *Decoder) (types.NetFlowBaseArgs, error) {
 20089    var result types.NetFlowBaseArgs
 20090    var err error
 20091  
 20092    var numArgs uint8
 20093    err = decoder.DecodeUint8(&numArgs)
 20094    if err != nil {
 20095      return types.NetFlowBaseArgs{}, err
 20096    }
 20097  
 20098    for arg := 0; arg < int(numArgs); arg++ {
 20099      var currArg uint8
 20100      err = decoder.DecodeUint8(&currArg)
 20101      if err != nil {
 20102        return types.NetFlowBaseArgs{}, err
 20103      }
 20104  
 20105      switch currArg {
 20106      case 0:
 20107        err = decoder.DecodeUint8(&result.Proto)
 20108        if err != nil {
 20109          return types.NetFlowBaseArgs{}, err
 20110        }
 20111      case 1:
 20112        err = decoder.DecodeUint8(&result.Direction)
 20113        if err != nil {
 20114          return types.NetFlowBaseArgs{}, err
 20115        }
 20116      case 2:
 20117        result.Tuple, err = decoder.ReadAddrTuple()
 20118        if err != nil {
 20119          return types.NetFlowBaseArgs{}, err
 20120        }
 20121      case 3:
 20122        err = decoder.DecodeUint64(&result.TxBytes)
 20123        if err != nil {
 20124          return types.NetFlowBaseArgs{}, err
 20125        }
 20126      case 4:
 20127        err = decoder.DecodeUint64(&result.RxBytes)
 20128        if err != nil {
 20129          return types.NetFlowBaseArgs{}, err
 20130        }
 20131      case 5:
 20132        err = decoder.DecodeUint64(&result.TxPackets)
 20133        if err != nil {
 20134          return types.NetFlowBaseArgs{}, err
 20135        }
 20136      case 6:
 20137        err = decoder.DecodeUint64(&result.RxPackets)
 20138        if err != nil {
 20139          return types.NetFlowBaseArgs{}, err
 20140        }
 20141      }
 20142    }
 20143    return result, nil
 20144  }
 20145  
 20146  func ParseArgs(decoder *Decoder, event events.ID) (types.Args, error) {
 20147    switch event {
 20148    case events.Read:
 20149      return ParseReadArgs(decoder)
 20150    case events.Write:
 20151      return ParseWriteArgs(decoder)
 20152    case events.Open:
 20153      return ParseOpenArgs(decoder)
 20154    case events.Close:
 20155      return ParseCloseArgs(decoder)
 20156    case events.Stat:
 20157      return ParseStatArgs(decoder)
 20158    case events.Fstat:
 20159      return ParseFstatArgs(decoder)
 20160    case events.Lstat:
 20161      return ParseLstatArgs(decoder)
 20162    case events.Poll:
 20163      return ParsePollArgs(decoder)
 20164    case events.Lseek:
 20165      return ParseLseekArgs(decoder)
 20166    case events.Mmap:
 20167      return ParseMmapArgs(decoder)
 20168    case events.Mprotect:
 20169      return ParseMprotectArgs(decoder)
 20170    case events.Munmap:
 20171      return ParseMunmapArgs(decoder)
 20172    case events.Brk:
 20173      return ParseBrkArgs(decoder)
 20174    case events.RtSigaction:
 20175      return ParseRtSigactionArgs(decoder)
 20176    case events.RtSigprocmask:
 20177      return ParseRtSigprocmaskArgs(decoder)
 20178    case events.RtSigreturn:
 20179      return ParseRtSigreturnArgs(decoder)
 20180    case events.Ioctl:
 20181      return ParseIoctlArgs(decoder)
 20182    case events.Pread64:
 20183      return ParsePread64Args(decoder)
 20184    case events.Pwrite64:
 20185      return ParsePwrite64Args(decoder)
 20186    case events.Readv:
 20187      return ParseReadvArgs(decoder)
 20188    case events.Writev:
 20189      return ParseWritevArgs(decoder)
 20190    case events.Access:
 20191      return ParseAccessArgs(decoder)
 20192    case events.Pipe:
 20193      return ParsePipeArgs(decoder)
 20194    case events.Select:
 20195      return ParseSelectArgs(decoder)
 20196    case events.SchedYield:
 20197      return ParseSchedYieldArgs(decoder)
 20198    case events.Mremap:
 20199      return ParseMremapArgs(decoder)
 20200    case events.Msync:
 20201      return ParseMsyncArgs(decoder)
 20202    case events.Mincore:
 20203      return ParseMincoreArgs(decoder)
 20204    case events.Madvise:
 20205      return ParseMadviseArgs(decoder)
 20206    case events.Shmget:
 20207      return ParseShmgetArgs(decoder)
 20208    case events.Shmat:
 20209      return ParseShmatArgs(decoder)
 20210    case events.Shmctl:
 20211      return ParseShmctlArgs(decoder)
 20212    case events.Dup:
 20213      return ParseDupArgs(decoder)
 20214    case events.Dup2:
 20215      return ParseDup2Args(decoder)
 20216    case events.Pause:
 20217      return ParsePauseArgs(decoder)
 20218    case events.Nanosleep:
 20219      return ParseNanosleepArgs(decoder)
 20220    case events.Getitimer:
 20221      return ParseGetitimerArgs(decoder)
 20222    case events.Alarm:
 20223      return ParseAlarmArgs(decoder)
 20224    case events.Setitimer:
 20225      return ParseSetitimerArgs(decoder)
 20226    case events.Getpid:
 20227      return ParseGetpidArgs(decoder)
 20228    case events.Sendfile:
 20229      return ParseSendfileArgs(decoder)
 20230    case events.Socket:
 20231      return ParseSocketArgs(decoder)
 20232    case events.Connect:
 20233      return ParseConnectArgs(decoder)
 20234    case events.Accept:
 20235      return ParseAcceptArgs(decoder)
 20236    case events.Sendto:
 20237      return ParseSendtoArgs(decoder)
 20238    case events.Recvfrom:
 20239      return ParseRecvfromArgs(decoder)
 20240    case events.Sendmsg:
 20241      return ParseSendmsgArgs(decoder)
 20242    case events.Recvmsg:
 20243      return ParseRecvmsgArgs(decoder)
 20244    case events.Shutdown:
 20245      return ParseShutdownArgs(decoder)
 20246    case events.Bind:
 20247      return ParseBindArgs(decoder)
 20248    case events.Listen:
 20249      return ParseListenArgs(decoder)
 20250    case events.Getsockname:
 20251      return ParseGetsocknameArgs(decoder)
 20252    case events.Getpeername:
 20253      return ParseGetpeernameArgs(decoder)
 20254    case events.Socketpair:
 20255      return ParseSocketpairArgs(decoder)
 20256    case events.Setsockopt:
 20257      return ParseSetsockoptArgs(decoder)
 20258    case events.Getsockopt:
 20259      return ParseGetsockoptArgs(decoder)
 20260    case events.Clone:
 20261      return ParseCloneArgs(decoder)
 20262    case events.Fork:
 20263      return ParseForkArgs(decoder)
 20264    case events.Vfork:
 20265      return ParseVforkArgs(decoder)
 20266    case events.Execve:
 20267      return ParseExecveArgs(decoder)
 20268    case events.Exit:
 20269      return ParseExitArgs(decoder)
 20270    case events.Wait4:
 20271      return ParseWait4Args(decoder)
 20272    case events.Kill:
 20273      return ParseKillArgs(decoder)
 20274    case events.Uname:
 20275      return ParseUnameArgs(decoder)
 20276    case events.Semget:
 20277      return ParseSemgetArgs(decoder)
 20278    case events.Semop:
 20279      return ParseSemopArgs(decoder)
 20280    case events.Semctl:
 20281      return ParseSemctlArgs(decoder)
 20282    case events.Shmdt:
 20283      return ParseShmdtArgs(decoder)
 20284    case events.Msgget:
 20285      return ParseMsggetArgs(decoder)
 20286    case events.Msgsnd:
 20287      return ParseMsgsndArgs(decoder)
 20288    case events.Msgrcv:
 20289      return ParseMsgrcvArgs(decoder)
 20290    case events.Msgctl:
 20291      return ParseMsgctlArgs(decoder)
 20292    case events.Fcntl:
 20293      return ParseFcntlArgs(decoder)
 20294    case events.Flock:
 20295      return ParseFlockArgs(decoder)
 20296    case events.Fsync:
 20297      return ParseFsyncArgs(decoder)
 20298    case events.Fdatasync:
 20299      return ParseFdatasyncArgs(decoder)
 20300    case events.Truncate:
 20301      return ParseTruncateArgs(decoder)
 20302    case events.Ftruncate:
 20303      return ParseFtruncateArgs(decoder)
 20304    case events.Getdents:
 20305      return ParseGetdentsArgs(decoder)
 20306    case events.Getcwd:
 20307      return ParseGetcwdArgs(decoder)
 20308    case events.Chdir:
 20309      return ParseChdirArgs(decoder)
 20310    case events.Fchdir:
 20311      return ParseFchdirArgs(decoder)
 20312    case events.Rename:
 20313      return ParseRenameArgs(decoder)
 20314    case events.Mkdir:
 20315      return ParseMkdirArgs(decoder)
 20316    case events.Rmdir:
 20317      return ParseRmdirArgs(decoder)
 20318    case events.Creat:
 20319      return ParseCreatArgs(decoder)
 20320    case events.Link:
 20321      return ParseLinkArgs(decoder)
 20322    case events.Unlink:
 20323      return ParseUnlinkArgs(decoder)
 20324    case events.Symlink:
 20325      return ParseSymlinkArgs(decoder)
 20326    case events.Readlink:
 20327      return ParseReadlinkArgs(decoder)
 20328    case events.Chmod:
 20329      return ParseChmodArgs(decoder)
 20330    case events.Fchmod:
 20331      return ParseFchmodArgs(decoder)
 20332    case events.Chown:
 20333      return ParseChownArgs(decoder)
 20334    case events.Fchown:
 20335      return ParseFchownArgs(decoder)
 20336    case events.Lchown:
 20337      return ParseLchownArgs(decoder)
 20338    case events.Umask:
 20339      return ParseUmaskArgs(decoder)
 20340    case events.Gettimeofday:
 20341      return ParseGettimeofdayArgs(decoder)
 20342    case events.Getrlimit:
 20343      return ParseGetrlimitArgs(decoder)
 20344    case events.Getrusage:
 20345      return ParseGetrusageArgs(decoder)
 20346    case events.Sysinfo:
 20347      return ParseSysinfoArgs(decoder)
 20348    case events.Times:
 20349      return ParseTimesArgs(decoder)
 20350    case events.Ptrace:
 20351      return ParsePtraceArgs(decoder)
 20352    case events.Getuid:
 20353      return ParseGetuidArgs(decoder)
 20354    case events.Syslog:
 20355      return ParseSyslogArgs(decoder)
 20356    case events.Getgid:
 20357      return ParseGetgidArgs(decoder)
 20358    case events.Setuid:
 20359      return ParseSetuidArgs(decoder)
 20360    case events.Setgid:
 20361      return ParseSetgidArgs(decoder)
 20362    case events.Geteuid:
 20363      return ParseGeteuidArgs(decoder)
 20364    case events.Getegid:
 20365      return ParseGetegidArgs(decoder)
 20366    case events.Setpgid:
 20367      return ParseSetpgidArgs(decoder)
 20368    case events.Getppid:
 20369      return ParseGetppidArgs(decoder)
 20370    case events.Getpgrp:
 20371      return ParseGetpgrpArgs(decoder)
 20372    case events.Setsid:
 20373      return ParseSetsidArgs(decoder)
 20374    case events.Setreuid:
 20375      return ParseSetreuidArgs(decoder)
 20376    case events.Setregid:
 20377      return ParseSetregidArgs(decoder)
 20378    case events.Getgroups:
 20379      return ParseGetgroupsArgs(decoder)
 20380    case events.Setgroups:
 20381      return ParseSetgroupsArgs(decoder)
 20382    case events.Setresuid:
 20383      return ParseSetresuidArgs(decoder)
 20384    case events.Getresuid:
 20385      return ParseGetresuidArgs(decoder)
 20386    case events.Setresgid:
 20387      return ParseSetresgidArgs(decoder)
 20388    case events.Getresgid:
 20389      return ParseGetresgidArgs(decoder)
 20390    case events.Getpgid:
 20391      return ParseGetpgidArgs(decoder)
 20392    case events.Setfsuid:
 20393      return ParseSetfsuidArgs(decoder)
 20394    case events.Setfsgid:
 20395      return ParseSetfsgidArgs(decoder)
 20396    case events.Getsid:
 20397      return ParseGetsidArgs(decoder)
 20398    case events.Capget:
 20399      return ParseCapgetArgs(decoder)
 20400    case events.Capset:
 20401      return ParseCapsetArgs(decoder)
 20402    case events.RtSigpending:
 20403      return ParseRtSigpendingArgs(decoder)
 20404    case events.RtSigtimedwait:
 20405      return ParseRtSigtimedwaitArgs(decoder)
 20406    case events.RtSigqueueinfo:
 20407      return ParseRtSigqueueinfoArgs(decoder)
 20408    case events.RtSigsuspend:
 20409      return ParseRtSigsuspendArgs(decoder)
 20410    case events.Sigaltstack:
 20411      return ParseSigaltstackArgs(decoder)
 20412    case events.Utime:
 20413      return ParseUtimeArgs(decoder)
 20414    case events.Mknod:
 20415      return ParseMknodArgs(decoder)
 20416    case events.Uselib:
 20417      return ParseUselibArgs(decoder)
 20418    case events.Personality:
 20419      return ParsePersonalityArgs(decoder)
 20420    case events.Ustat:
 20421      return ParseUstatArgs(decoder)
 20422    case events.Statfs:
 20423      return ParseStatfsArgs(decoder)
 20424    case events.Fstatfs:
 20425      return ParseFstatfsArgs(decoder)
 20426    case events.Sysfs:
 20427      return ParseSysfsArgs(decoder)
 20428    case events.Getpriority:
 20429      return ParseGetpriorityArgs(decoder)
 20430    case events.Setpriority:
 20431      return ParseSetpriorityArgs(decoder)
 20432    case events.SchedSetparam:
 20433      return ParseSchedSetparamArgs(decoder)
 20434    case events.SchedGetparam:
 20435      return ParseSchedGetparamArgs(decoder)
 20436    case events.SchedSetscheduler:
 20437      return ParseSchedSetschedulerArgs(decoder)
 20438    case events.SchedGetscheduler:
 20439      return ParseSchedGetschedulerArgs(decoder)
 20440    case events.SchedGetPriorityMax:
 20441      return ParseSchedGetPriorityMaxArgs(decoder)
 20442    case events.SchedGetPriorityMin:
 20443      return ParseSchedGetPriorityMinArgs(decoder)
 20444    case events.SchedRrGetInterval:
 20445      return ParseSchedRrGetIntervalArgs(decoder)
 20446    case events.Mlock:
 20447      return ParseMlockArgs(decoder)
 20448    case events.Munlock:
 20449      return ParseMunlockArgs(decoder)
 20450    case events.Mlockall:
 20451      return ParseMlockallArgs(decoder)
 20452    case events.Munlockall:
 20453      return ParseMunlockallArgs(decoder)
 20454    case events.Vhangup:
 20455      return ParseVhangupArgs(decoder)
 20456    case events.ModifyLdt:
 20457      return ParseModifyLdtArgs(decoder)
 20458    case events.PivotRoot:
 20459      return ParsePivotRootArgs(decoder)
 20460    case events.Sysctl:
 20461      return ParseSysctlArgs(decoder)
 20462    case events.Prctl:
 20463      return ParsePrctlArgs(decoder)
 20464    case events.ArchPrctl:
 20465      return ParseArchPrctlArgs(decoder)
 20466    case events.Adjtimex:
 20467      return ParseAdjtimexArgs(decoder)
 20468    case events.Setrlimit:
 20469      return ParseSetrlimitArgs(decoder)
 20470    case events.Chroot:
 20471      return ParseChrootArgs(decoder)
 20472    case events.Sync:
 20473      return ParseSyncArgs(decoder)
 20474    case events.Acct:
 20475      return ParseAcctArgs(decoder)
 20476    case events.Settimeofday:
 20477      return ParseSettimeofdayArgs(decoder)
 20478    case events.Mount:
 20479      return ParseMountArgs(decoder)
 20480    case events.Umount2:
 20481      return ParseUmount2Args(decoder)
 20482    case events.Swapon:
 20483      return ParseSwaponArgs(decoder)
 20484    case events.Swapoff:
 20485      return ParseSwapoffArgs(decoder)
 20486    case events.Reboot:
 20487      return ParseRebootArgs(decoder)
 20488    case events.Sethostname:
 20489      return ParseSethostnameArgs(decoder)
 20490    case events.Setdomainname:
 20491      return ParseSetdomainnameArgs(decoder)
 20492    case events.Iopl:
 20493      return ParseIoplArgs(decoder)
 20494    case events.Ioperm:
 20495      return ParseIopermArgs(decoder)
 20496    case events.CreateModule:
 20497      return ParseCreateModuleArgs(decoder)
 20498    case events.InitModule:
 20499      return ParseInitModuleArgs(decoder)
 20500    case events.DeleteModule:
 20501      return ParseDeleteModuleArgs(decoder)
 20502    case events.GetKernelSyms:
 20503      return ParseGetKernelSymsArgs(decoder)
 20504    case events.QueryModule:
 20505      return ParseQueryModuleArgs(decoder)
 20506    case events.Quotactl:
 20507      return ParseQuotactlArgs(decoder)
 20508    case events.Nfsservctl:
 20509      return ParseNfsservctlArgs(decoder)
 20510    case events.Getpmsg:
 20511      return ParseGetpmsgArgs(decoder)
 20512    case events.Putpmsg:
 20513      return ParsePutpmsgArgs(decoder)
 20514    case events.Afs:
 20515      return ParseAfsArgs(decoder)
 20516    case events.Tuxcall:
 20517      return ParseTuxcallArgs(decoder)
 20518    case events.Security:
 20519      return ParseSecurityArgs(decoder)
 20520    case events.Gettid:
 20521      return ParseGettidArgs(decoder)
 20522    case events.Readahead:
 20523      return ParseReadaheadArgs(decoder)
 20524    case events.Setxattr:
 20525      return ParseSetxattrArgs(decoder)
 20526    case events.Lsetxattr:
 20527      return ParseLsetxattrArgs(decoder)
 20528    case events.Fsetxattr:
 20529      return ParseFsetxattrArgs(decoder)
 20530    case events.Getxattr:
 20531      return ParseGetxattrArgs(decoder)
 20532    case events.Lgetxattr:
 20533      return ParseLgetxattrArgs(decoder)
 20534    case events.Fgetxattr:
 20535      return ParseFgetxattrArgs(decoder)
 20536    case events.Listxattr:
 20537      return ParseListxattrArgs(decoder)
 20538    case events.Llistxattr:
 20539      return ParseLlistxattrArgs(decoder)
 20540    case events.Flistxattr:
 20541      return ParseFlistxattrArgs(decoder)
 20542    case events.Removexattr:
 20543      return ParseRemovexattrArgs(decoder)
 20544    case events.Lremovexattr:
 20545      return ParseLremovexattrArgs(decoder)
 20546    case events.Fremovexattr:
 20547      return ParseFremovexattrArgs(decoder)
 20548    case events.Tkill:
 20549      return ParseTkillArgs(decoder)
 20550    case events.Time:
 20551      return ParseTimeArgs(decoder)
 20552    case events.Futex:
 20553      return ParseFutexArgs(decoder)
 20554    case events.SchedSetaffinity:
 20555      return ParseSchedSetaffinityArgs(decoder)
 20556    case events.SchedGetaffinity:
 20557      return ParseSchedGetaffinityArgs(decoder)
 20558    case events.SetThreadArea:
 20559      return ParseSetThreadAreaArgs(decoder)
 20560    case events.IoSetup:
 20561      return ParseIoSetupArgs(decoder)
 20562    case events.IoDestroy:
 20563      return ParseIoDestroyArgs(decoder)
 20564    case events.IoGetevents:
 20565      return ParseIoGeteventsArgs(decoder)
 20566    case events.IoSubmit:
 20567      return ParseIoSubmitArgs(decoder)
 20568    case events.IoCancel:
 20569      return ParseIoCancelArgs(decoder)
 20570    case events.GetThreadArea:
 20571      return ParseGetThreadAreaArgs(decoder)
 20572    case events.LookupDcookie:
 20573      return ParseLookupDcookieArgs(decoder)
 20574    case events.EpollCreate:
 20575      return ParseEpollCreateArgs(decoder)
 20576    case events.EpollCtlOld:
 20577      return ParseEpollCtlOldArgs(decoder)
 20578    case events.EpollWaitOld:
 20579      return ParseEpollWaitOldArgs(decoder)
 20580    case events.RemapFilePages:
 20581      return ParseRemapFilePagesArgs(decoder)
 20582    case events.Getdents64:
 20583      return ParseGetdents64Args(decoder)
 20584    case events.SetTidAddress:
 20585      return ParseSetTidAddressArgs(decoder)
 20586    case events.RestartSyscall:
 20587      return ParseRestartSyscallArgs(decoder)
 20588    case events.Semtimedop:
 20589      return ParseSemtimedopArgs(decoder)
 20590    case events.Fadvise64:
 20591      return ParseFadvise64Args(decoder)
 20592    case events.TimerCreate:
 20593      return ParseTimerCreateArgs(decoder)
 20594    case events.TimerSettime:
 20595      return ParseTimerSettimeArgs(decoder)
 20596    case events.TimerGettime:
 20597      return ParseTimerGettimeArgs(decoder)
 20598    case events.TimerGetoverrun:
 20599      return ParseTimerGetoverrunArgs(decoder)
 20600    case events.TimerDelete:
 20601      return ParseTimerDeleteArgs(decoder)
 20602    case events.ClockSettime:
 20603      return ParseClockSettimeArgs(decoder)
 20604    case events.ClockGettime:
 20605      return ParseClockGettimeArgs(decoder)
 20606    case events.ClockGetres:
 20607      return ParseClockGetresArgs(decoder)
 20608    case events.ClockNanosleep:
 20609      return ParseClockNanosleepArgs(decoder)
 20610    case events.ExitGroup:
 20611      return ParseExitGroupArgs(decoder)
 20612    case events.EpollWait:
 20613      return ParseEpollWaitArgs(decoder)
 20614    case events.EpollCtl:
 20615      return ParseEpollCtlArgs(decoder)
 20616    case events.Tgkill:
 20617      return ParseTgkillArgs(decoder)
 20618    case events.Utimes:
 20619      return ParseUtimesArgs(decoder)
 20620    case events.Vserver:
 20621      return ParseVserverArgs(decoder)
 20622    case events.Mbind:
 20623      return ParseMbindArgs(decoder)
 20624    case events.SetMempolicy:
 20625      return ParseSetMempolicyArgs(decoder)
 20626    case events.GetMempolicy:
 20627      return ParseGetMempolicyArgs(decoder)
 20628    case events.MqOpen:
 20629      return ParseMqOpenArgs(decoder)
 20630    case events.MqUnlink:
 20631      return ParseMqUnlinkArgs(decoder)
 20632    case events.MqTimedsend:
 20633      return ParseMqTimedsendArgs(decoder)
 20634    case events.MqTimedreceive:
 20635      return ParseMqTimedreceiveArgs(decoder)
 20636    case events.MqNotify:
 20637      return ParseMqNotifyArgs(decoder)
 20638    case events.MqGetsetattr:
 20639      return ParseMqGetsetattrArgs(decoder)
 20640    case events.KexecLoad:
 20641      return ParseKexecLoadArgs(decoder)
 20642    case events.Waitid:
 20643      return ParseWaitidArgs(decoder)
 20644    case events.AddKey:
 20645      return ParseAddKeyArgs(decoder)
 20646    case events.RequestKey:
 20647      return ParseRequestKeyArgs(decoder)
 20648    case events.Keyctl:
 20649      return ParseKeyctlArgs(decoder)
 20650    case events.IoprioSet:
 20651      return ParseIoprioSetArgs(decoder)
 20652    case events.IoprioGet:
 20653      return ParseIoprioGetArgs(decoder)
 20654    case events.InotifyInit:
 20655      return ParseInotifyInitArgs(decoder)
 20656    case events.InotifyAddWatch:
 20657      return ParseInotifyAddWatchArgs(decoder)
 20658    case events.InotifyRmWatch:
 20659      return ParseInotifyRmWatchArgs(decoder)
 20660    case events.MigratePages:
 20661      return ParseMigratePagesArgs(decoder)
 20662    case events.Openat:
 20663      return ParseOpenatArgs(decoder)
 20664    case events.Mkdirat:
 20665      return ParseMkdiratArgs(decoder)
 20666    case events.Mknodat:
 20667      return ParseMknodatArgs(decoder)
 20668    case events.Fchownat:
 20669      return ParseFchownatArgs(decoder)
 20670    case events.Futimesat:
 20671      return ParseFutimesatArgs(decoder)
 20672    case events.Newfstatat:
 20673      return ParseNewfstatatArgs(decoder)
 20674    case events.Unlinkat:
 20675      return ParseUnlinkatArgs(decoder)
 20676    case events.Renameat:
 20677      return ParseRenameatArgs(decoder)
 20678    case events.Linkat:
 20679      return ParseLinkatArgs(decoder)
 20680    case events.Symlinkat:
 20681      return ParseSymlinkatArgs(decoder)
 20682    case events.Readlinkat:
 20683      return ParseReadlinkatArgs(decoder)
 20684    case events.Fchmodat:
 20685      return ParseFchmodatArgs(decoder)
 20686    case events.Faccessat:
 20687      return ParseFaccessatArgs(decoder)
 20688    case events.Pselect6:
 20689      return ParsePselect6Args(decoder)
 20690    case events.Ppoll:
 20691      return ParsePpollArgs(decoder)
 20692    case events.Unshare:
 20693      return ParseUnshareArgs(decoder)
 20694    case events.SetRobustList:
 20695      return ParseSetRobustListArgs(decoder)
 20696    case events.GetRobustList:
 20697      return ParseGetRobustListArgs(decoder)
 20698    case events.Splice:
 20699      return ParseSpliceArgs(decoder)
 20700    case events.Tee:
 20701      return ParseTeeArgs(decoder)
 20702    case events.SyncFileRange:
 20703      return ParseSyncFileRangeArgs(decoder)
 20704    case events.Vmsplice:
 20705      return ParseVmspliceArgs(decoder)
 20706    case events.MovePages:
 20707      return ParseMovePagesArgs(decoder)
 20708    case events.Utimensat:
 20709      return ParseUtimensatArgs(decoder)
 20710    case events.EpollPwait:
 20711      return ParseEpollPwaitArgs(decoder)
 20712    case events.Signalfd:
 20713      return ParseSignalfdArgs(decoder)
 20714    case events.TimerfdCreate:
 20715      return ParseTimerfdCreateArgs(decoder)
 20716    case events.Eventfd:
 20717      return ParseEventfdArgs(decoder)
 20718    case events.Fallocate:
 20719      return ParseFallocateArgs(decoder)
 20720    case events.TimerfdSettime:
 20721      return ParseTimerfdSettimeArgs(decoder)
 20722    case events.TimerfdGettime:
 20723      return ParseTimerfdGettimeArgs(decoder)
 20724    case events.Accept4:
 20725      return ParseAccept4Args(decoder)
 20726    case events.Signalfd4:
 20727      return ParseSignalfd4Args(decoder)
 20728    case events.Eventfd2:
 20729      return ParseEventfd2Args(decoder)
 20730    case events.EpollCreate1:
 20731      return ParseEpollCreate1Args(decoder)
 20732    case events.Dup3:
 20733      return ParseDup3Args(decoder)
 20734    case events.Pipe2:
 20735      return ParsePipe2Args(decoder)
 20736    case events.InotifyInit1:
 20737      return ParseInotifyInit1Args(decoder)
 20738    case events.Preadv:
 20739      return ParsePreadvArgs(decoder)
 20740    case events.Pwritev:
 20741      return ParsePwritevArgs(decoder)
 20742    case events.RtTgsigqueueinfo:
 20743      return ParseRtTgsigqueueinfoArgs(decoder)
 20744    case events.PerfEventOpen:
 20745      return ParsePerfEventOpenArgs(decoder)
 20746    case events.Recvmmsg:
 20747      return ParseRecvmmsgArgs(decoder)
 20748    case events.FanotifyInit:
 20749      return ParseFanotifyInitArgs(decoder)
 20750    case events.FanotifyMark:
 20751      return ParseFanotifyMarkArgs(decoder)
 20752    case events.Prlimit64:
 20753      return ParsePrlimit64Args(decoder)
 20754    case events.NameToHandleAt:
 20755      return ParseNameToHandleAtArgs(decoder)
 20756    case events.OpenByHandleAt:
 20757      return ParseOpenByHandleAtArgs(decoder)
 20758    case events.ClockAdjtime:
 20759      return ParseClockAdjtimeArgs(decoder)
 20760    case events.Syncfs:
 20761      return ParseSyncfsArgs(decoder)
 20762    case events.Sendmmsg:
 20763      return ParseSendmmsgArgs(decoder)
 20764    case events.Setns:
 20765      return ParseSetnsArgs(decoder)
 20766    case events.Getcpu:
 20767      return ParseGetcpuArgs(decoder)
 20768    case events.ProcessVmReadv:
 20769      return ParseProcessVmReadvArgs(decoder)
 20770    case events.ProcessVmWritev:
 20771      return ParseProcessVmWritevArgs(decoder)
 20772    case events.Kcmp:
 20773      return ParseKcmpArgs(decoder)
 20774    case events.FinitModule:
 20775      return ParseFinitModuleArgs(decoder)
 20776    case events.SchedSetattr:
 20777      return ParseSchedSetattrArgs(decoder)
 20778    case events.SchedGetattr:
 20779      return ParseSchedGetattrArgs(decoder)
 20780    case events.Renameat2:
 20781      return ParseRenameat2Args(decoder)
 20782    case events.Seccomp:
 20783      return ParseSeccompArgs(decoder)
 20784    case events.Getrandom:
 20785      return ParseGetrandomArgs(decoder)
 20786    case events.MemfdCreate:
 20787      return ParseMemfdCreateArgs(decoder)
 20788    case events.KexecFileLoad:
 20789      return ParseKexecFileLoadArgs(decoder)
 20790    case events.Bpf:
 20791      return ParseBpfArgs(decoder)
 20792    case events.Execveat:
 20793      return ParseExecveatArgs(decoder)
 20794    case events.Userfaultfd:
 20795      return ParseUserfaultfdArgs(decoder)
 20796    case events.Membarrier:
 20797      return ParseMembarrierArgs(decoder)
 20798    case events.Mlock2:
 20799      return ParseMlock2Args(decoder)
 20800    case events.CopyFileRange:
 20801      return ParseCopyFileRangeArgs(decoder)
 20802    case events.Preadv2:
 20803      return ParsePreadv2Args(decoder)
 20804    case events.Pwritev2:
 20805      return ParsePwritev2Args(decoder)
 20806    case events.PkeyMprotect:
 20807      return ParsePkeyMprotectArgs(decoder)
 20808    case events.PkeyAlloc:
 20809      return ParsePkeyAllocArgs(decoder)
 20810    case events.PkeyFree:
 20811      return ParsePkeyFreeArgs(decoder)
 20812    case events.Statx:
 20813      return ParseStatxArgs(decoder)
 20814    case events.IoPgetevents:
 20815      return ParseIoPgeteventsArgs(decoder)
 20816    case events.Rseq:
 20817      return ParseRseqArgs(decoder)
 20818    case events.PidfdSendSignal:
 20819      return ParsePidfdSendSignalArgs(decoder)
 20820    case events.IoUringSetup:
 20821      return ParseIoUringSetupArgs(decoder)
 20822    case events.IoUringEnter:
 20823      return ParseIoUringEnterArgs(decoder)
 20824    case events.IoUringRegister:
 20825      return ParseIoUringRegisterArgs(decoder)
 20826    case events.OpenTree:
 20827      return ParseOpenTreeArgs(decoder)
 20828    case events.MoveMount:
 20829      return ParseMoveMountArgs(decoder)
 20830    case events.Fsopen:
 20831      return ParseFsopenArgs(decoder)
 20832    case events.Fsconfig:
 20833      return ParseFsconfigArgs(decoder)
 20834    case events.Fsmount:
 20835      return ParseFsmountArgs(decoder)
 20836    case events.Fspick:
 20837      return ParseFspickArgs(decoder)
 20838    case events.PidfdOpen:
 20839      return ParsePidfdOpenArgs(decoder)
 20840    case events.Clone3:
 20841      return ParseClone3Args(decoder)
 20842    case events.CloseRange:
 20843      return ParseCloseRangeArgs(decoder)
 20844    case events.Openat2:
 20845      return ParseOpenat2Args(decoder)
 20846    case events.PidfdGetfd:
 20847      return ParsePidfdGetfdArgs(decoder)
 20848    case events.Faccessat2:
 20849      return ParseFaccessat2Args(decoder)
 20850    case events.ProcessMadvise:
 20851      return ParseProcessMadviseArgs(decoder)
 20852    case events.EpollPwait2:
 20853      return ParseEpollPwait2Args(decoder)
 20854    case events.MountSetatt:
 20855      return ParseMountSetattArgs(decoder)
 20856    case events.QuotactlFd:
 20857      return ParseQuotactlFdArgs(decoder)
 20858    case events.LandlockCreateRuleset:
 20859      return ParseLandlockCreateRulesetArgs(decoder)
 20860    case events.LandlockAddRule:
 20861      return ParseLandlockAddRuleArgs(decoder)
 20862    case events.LandloclRestrictSet:
 20863      return ParseLandloclRestrictSetArgs(decoder)
 20864    case events.MemfdSecret:
 20865      return ParseMemfdSecretArgs(decoder)
 20866    case events.ProcessMrelease:
 20867      return ParseProcessMreleaseArgs(decoder)
 20868    case events.Waitpid:
 20869      return ParseWaitpidArgs(decoder)
 20870    case events.Oldfstat:
 20871      return ParseOldfstatArgs(decoder)
 20872    case events.Break:
 20873      return ParseBreakArgs(decoder)
 20874    case events.Oldstat:
 20875      return ParseOldstatArgs(decoder)
 20876    case events.Umount:
 20877      return ParseUmountArgs(decoder)
 20878    case events.Stime:
 20879      return ParseStimeArgs(decoder)
 20880    case events.Stty:
 20881      return ParseSttyArgs(decoder)
 20882    case events.Gtty:
 20883      return ParseGttyArgs(decoder)
 20884    case events.Nice:
 20885      return ParseNiceArgs(decoder)
 20886    case events.Ftime:
 20887      return ParseFtimeArgs(decoder)
 20888    case events.Prof:
 20889      return ParseProfArgs(decoder)
 20890    case events.Signal:
 20891      return ParseSignalArgs(decoder)
 20892    case events.Lock:
 20893      return ParseLockArgs(decoder)
 20894    case events.Mpx:
 20895      return ParseMpxArgs(decoder)
 20896    case events.Ulimit:
 20897      return ParseUlimitArgs(decoder)
 20898    case events.Oldolduname:
 20899      return ParseOldoldunameArgs(decoder)
 20900    case events.Sigaction:
 20901      return ParseSigactionArgs(decoder)
 20902    case events.Sgetmask:
 20903      return ParseSgetmaskArgs(decoder)
 20904    case events.Ssetmask:
 20905      return ParseSsetmaskArgs(decoder)
 20906    case events.Sigsuspend:
 20907      return ParseSigsuspendArgs(decoder)
 20908    case events.Sigpending:
 20909      return ParseSigpendingArgs(decoder)
 20910    case events.Oldlstat:
 20911      return ParseOldlstatArgs(decoder)
 20912    case events.Readdir:
 20913      return ParseReaddirArgs(decoder)
 20914    case events.Profil:
 20915      return ParseProfilArgs(decoder)
 20916    case events.Socketcall:
 20917      return ParseSocketcallArgs(decoder)
 20918    case events.Olduname:
 20919      return ParseOldunameArgs(decoder)
 20920    case events.Idle:
 20921      return ParseIdleArgs(decoder)
 20922    case events.Vm86old:
 20923      return ParseVm86oldArgs(decoder)
 20924    case events.Ipc:
 20925      return ParseIpcArgs(decoder)
 20926    case events.Sigreturn:
 20927      return ParseSigreturnArgs(decoder)
 20928    case events.Sigprocmask:
 20929      return ParseSigprocmaskArgs(decoder)
 20930    case events.Bdflush:
 20931      return ParseBdflushArgs(decoder)
 20932    case events.Afs_syscall:
 20933      return ParseAfs_syscallArgs(decoder)
 20934    case events.Llseek:
 20935      return ParseLlseekArgs(decoder)
 20936    case events.OldSelect:
 20937      return ParseOldSelectArgs(decoder)
 20938    case events.Vm86:
 20939      return ParseVm86Args(decoder)
 20940    case events.OldGetrlimit:
 20941      return ParseOldGetrlimitArgs(decoder)
 20942    case events.Mmap2:
 20943      return ParseMmap2Args(decoder)
 20944    case events.Truncate64:
 20945      return ParseTruncate64Args(decoder)
 20946    case events.Ftruncate64:
 20947      return ParseFtruncate64Args(decoder)
 20948    case events.Stat64:
 20949      return ParseStat64Args(decoder)
 20950    case events.Lstat64:
 20951      return ParseLstat64Args(decoder)
 20952    case events.Fstat64:
 20953      return ParseFstat64Args(decoder)
 20954    case events.Lchown16:
 20955      return ParseLchown16Args(decoder)
 20956    case events.Getuid16:
 20957      return ParseGetuid16Args(decoder)
 20958    case events.Getgid16:
 20959      return ParseGetgid16Args(decoder)
 20960    case events.Geteuid16:
 20961      return ParseGeteuid16Args(decoder)
 20962    case events.Getegid16:
 20963      return ParseGetegid16Args(decoder)
 20964    case events.Setreuid16:
 20965      return ParseSetreuid16Args(decoder)
 20966    case events.Setregid16:
 20967      return ParseSetregid16Args(decoder)
 20968    case events.Getgroups16:
 20969      return ParseGetgroups16Args(decoder)
 20970    case events.Setgroups16:
 20971      return ParseSetgroups16Args(decoder)
 20972    case events.Fchown16:
 20973      return ParseFchown16Args(decoder)
 20974    case events.Setresuid16:
 20975      return ParseSetresuid16Args(decoder)
 20976    case events.Getresuid16:
 20977      return ParseGetresuid16Args(decoder)
 20978    case events.Setresgid16:
 20979      return ParseSetresgid16Args(decoder)
 20980    case events.Getresgid16:
 20981      return ParseGetresgid16Args(decoder)
 20982    case events.Chown16:
 20983      return ParseChown16Args(decoder)
 20984    case events.Setuid16:
 20985      return ParseSetuid16Args(decoder)
 20986    case events.Setgid16:
 20987      return ParseSetgid16Args(decoder)
 20988    case events.Setfsuid16:
 20989      return ParseSetfsuid16Args(decoder)
 20990    case events.Setfsgid16:
 20991      return ParseSetfsgid16Args(decoder)
 20992    case events.Fcntl64:
 20993      return ParseFcntl64Args(decoder)
 20994    case events.Sendfile32:
 20995      return ParseSendfile32Args(decoder)
 20996    case events.Statfs64:
 20997      return ParseStatfs64Args(decoder)
 20998    case events.Fstatfs64:
 20999      return ParseFstatfs64Args(decoder)
 21000    case events.Fadvise64_64:
 21001      return ParseFadvise64_64Args(decoder)
 21002    case events.ClockGettime32:
 21003      return ParseClockGettime32Args(decoder)
 21004    case events.ClockSettime32:
 21005      return ParseClockSettime32Args(decoder)
 21006    case events.ClockAdjtime64:
 21007      return ParseClockAdjtime64Args(decoder)
 21008    case events.ClockGetresTime32:
 21009      return ParseClockGetresTime32Args(decoder)
 21010    case events.ClockNanosleepTime32:
 21011      return ParseClockNanosleepTime32Args(decoder)
 21012    case events.TimerGettime32:
 21013      return ParseTimerGettime32Args(decoder)
 21014    case events.TimerSettime32:
 21015      return ParseTimerSettime32Args(decoder)
 21016    case events.TimerfdGettime32:
 21017      return ParseTimerfdGettime32Args(decoder)
 21018    case events.TimerfdSettime32:
 21019      return ParseTimerfdSettime32Args(decoder)
 21020    case events.UtimensatTime32:
 21021      return ParseUtimensatTime32Args(decoder)
 21022    case events.Pselect6Time32:
 21023      return ParsePselect6Time32Args(decoder)
 21024    case events.PpollTime32:
 21025      return ParsePpollTime32Args(decoder)
 21026    case events.IoPgeteventsTime32:
 21027      return ParseIoPgeteventsTime32Args(decoder)
 21028    case events.RecvmmsgTime32:
 21029      return ParseRecvmmsgTime32Args(decoder)
 21030    case events.MqTimedsendTime32:
 21031      return ParseMqTimedsendTime32Args(decoder)
 21032    case events.MqTimedreceiveTime32:
 21033      return ParseMqTimedreceiveTime32Args(decoder)
 21034    case events.RtSigtimedwaitTime32:
 21035      return ParseRtSigtimedwaitTime32Args(decoder)
 21036    case events.FutexTime32:
 21037      return ParseFutexTime32Args(decoder)
 21038    case events.SchedRrGetInterval32:
 21039      return ParseSchedRrGetInterval32Args(decoder)
 21040    case events.SysEnter:
 21041      return ParseSysEnterArgs(decoder)
 21042    case events.SysExit:
 21043      return ParseSysExitArgs(decoder)
 21044    case events.SchedProcessFork:
 21045      return ParseSchedProcessForkArgs(decoder)
 21046    case events.SchedProcessExec:
 21047      return ParseSchedProcessExecArgs(decoder)
 21048    case events.SchedProcessExit:
 21049      return ParseSchedProcessExitArgs(decoder)
 21050    case events.SchedSwitch:
 21051      return ParseSchedSwitchArgs(decoder)
 21052    case events.ProcessOomKilled:
 21053      return ParseProcessOomKilledArgs(decoder)
 21054    case events.DoExit:
 21055      return ParseDoExitArgs(decoder)
 21056    case events.CapCapable:
 21057      return ParseCapCapableArgs(decoder)
 21058    case events.VfsWrite:
 21059      return ParseVfsWriteArgs(decoder)
 21060    case events.VfsWritev:
 21061      return ParseVfsWritevArgs(decoder)
 21062    case events.MemProtAlert:
 21063      return ParseMemProtAlertArgs(decoder)
 21064    case events.CommitCreds:
 21065      return ParseCommitCredsArgs(decoder)
 21066    case events.SwitchTaskNS:
 21067      return ParseSwitchTaskNSArgs(decoder)
 21068    case events.MagicWrite:
 21069      return ParseMagicWriteArgs(decoder)
 21070    case events.CgroupAttachTask:
 21071      return ParseCgroupAttachTaskArgs(decoder)
 21072    case events.CgroupMkdir:
 21073      return ParseCgroupMkdirArgs(decoder)
 21074    case events.CgroupRmdir:
 21075      return ParseCgroupRmdirArgs(decoder)
 21076    case events.SecurityFileOpen:
 21077      return ParseSecurityFileOpenArgs(decoder)
 21078    case events.SecurityInodeUnlink:
 21079      return ParseSecurityInodeUnlinkArgs(decoder)
 21080    case events.SecuritySocketCreate:
 21081      return ParseSecuritySocketCreateArgs(decoder)
 21082    case events.SecuritySocketListen:
 21083      return ParseSecuritySocketListenArgs(decoder)
 21084    case events.SecuritySocketConnect:
 21085      return ParseSecuritySocketConnectArgs(decoder)
 21086    case events.SecuritySocketAccept:
 21087      return ParseSecuritySocketAcceptArgs(decoder)
 21088    case events.SecuritySocketBind:
 21089      return ParseSecuritySocketBindArgs(decoder)
 21090    case events.SecuritySocketSetsockopt:
 21091      return ParseSecuritySocketSetsockoptArgs(decoder)
 21092    case events.SecuritySbMount:
 21093      return ParseSecuritySbMountArgs(decoder)
 21094    case events.SecurityBPF:
 21095      return ParseSecurityBPFArgs(decoder)
 21096    case events.SecurityBPFMap:
 21097      return ParseSecurityBPFMapArgs(decoder)
 21098    case events.SecurityKernelReadFile:
 21099      return ParseSecurityKernelReadFileArgs(decoder)
 21100    case events.SecurityPostReadFile:
 21101      return ParseSecurityPostReadFileArgs(decoder)
 21102    case events.SecurityInodeMknod:
 21103      return ParseSecurityInodeMknodArgs(decoder)
 21104    case events.SecurityInodeSymlinkEventId:
 21105      return ParseSecurityInodeSymlinkEventIdArgs(decoder)
 21106    case events.SecurityMmapFile:
 21107      return ParseSecurityMmapFileArgs(decoder)
 21108    case events.DoMmap:
 21109      return ParseDoMmapArgs(decoder)
 21110    case events.SecurityFileMprotect:
 21111      return ParseSecurityFileMprotectArgs(decoder)
 21112    case events.InitNamespaces:
 21113      return ParseInitNamespacesArgs(decoder)
 21114    case events.SocketDup:
 21115      return ParseSocketDupArgs(decoder)
 21116    case events.HiddenInodes:
 21117      return ParseHiddenInodesArgs(decoder)
 21118    case events.KernelWrite:
 21119      return ParseKernelWriteArgs(decoder)
 21120    case events.DirtyPipeSplice:
 21121      return ParseDirtyPipeSpliceArgs(decoder)
 21122    case events.ContainerCreate:
 21123      return ParseContainerCreateArgs(decoder)
 21124    case events.ContainerRemove:
 21125      return ParseContainerRemoveArgs(decoder)
 21126    case events.ExistingContainer:
 21127      return ParseExistingContainerArgs(decoder)
 21128    case events.ProcCreate:
 21129      return ParseProcCreateArgs(decoder)
 21130    case events.KprobeAttach:
 21131      return ParseKprobeAttachArgs(decoder)
 21132    case events.CallUsermodeHelper:
 21133      return ParseCallUsermodeHelperArgs(decoder)
 21134    case events.DebugfsCreateFile:
 21135      return ParseDebugfsCreateFileArgs(decoder)
 21136    case events.PrintSyscallTable:
 21137      return ParsePrintSyscallTableArgs(decoder)
 21138    case events.HiddenKernelModule:
 21139      return ParseHiddenKernelModuleArgs(decoder)
 21140    case events.HiddenKernelModuleSeeker:
 21141      return ParseHiddenKernelModuleSeekerArgs(decoder)
 21142    case events.HookedSyscalls:
 21143      return ParseHookedSyscallsArgs(decoder)
 21144    case events.DebugfsCreateDir:
 21145      return ParseDebugfsCreateDirArgs(decoder)
 21146    case events.DeviceAdd:
 21147      return ParseDeviceAddArgs(decoder)
 21148    case events.RegisterChrdev:
 21149      return ParseRegisterChrdevArgs(decoder)
 21150    case events.SharedObjectLoaded:
 21151      return ParseSharedObjectLoadedArgs(decoder)
 21152    case events.SymbolsLoaded:
 21153      return ParseSymbolsLoadedArgs(decoder)
 21154    case events.SymbolsCollision:
 21155      return ParseSymbolsCollisionArgs(decoder)
 21156    case events.CaptureFileWrite:
 21157      return ParseCaptureFileWriteArgs(decoder)
 21158    case events.CaptureFileRead:
 21159      return ParseCaptureFileReadArgs(decoder)
 21160    case events.CaptureExec:
 21161      return ParseCaptureExecArgs(decoder)
 21162    case events.CaptureModule:
 21163      return ParseCaptureModuleArgs(decoder)
 21164    case events.CaptureMem:
 21165      return ParseCaptureMemArgs(decoder)
 21166    case events.CaptureBpf:
 21167      return ParseCaptureBpfArgs(decoder)
 21168    case events.DoInitModule:
 21169      return ParseDoInitModuleArgs(decoder)
 21170    case events.ModuleLoad:
 21171      return ParseModuleLoadArgs(decoder)
 21172    case events.ModuleFree:
 21173      return ParseModuleFreeArgs(decoder)
 21174    case events.SocketAccept:
 21175      return ParseSocketAcceptArgs(decoder)
 21176    case events.LoadElfPhdrs:
 21177      return ParseLoadElfPhdrsArgs(decoder)
 21178    case events.PrintNetSeqOps:
 21179      return ParsePrintNetSeqOpsArgs(decoder)
 21180    case events.HookedSeqOps:
 21181      return ParseHookedSeqOpsArgs(decoder)
 21182    case events.TaskRename:
 21183      return ParseTaskRenameArgs(decoder)
 21184    case events.SecurityInodeRename:
 21185      return ParseSecurityInodeRenameArgs(decoder)
 21186    case events.DoSigaction:
 21187      return ParseDoSigactionArgs(decoder)
 21188    case events.BpfAttach:
 21189      return ParseBpfAttachArgs(decoder)
 21190    case events.KallsymsLookupName:
 21191      return ParseKallsymsLookupNameArgs(decoder)
 21192    case events.PrintMemDump:
 21193      return ParsePrintMemDumpArgs(decoder)
 21194    case events.VfsRead:
 21195      return ParseVfsReadArgs(decoder)
 21196    case events.VfsReadv:
 21197      return ParseVfsReadvArgs(decoder)
 21198    case events.VfsUtimes:
 21199      return ParseVfsUtimesArgs(decoder)
 21200    case events.DoTruncate:
 21201      return ParseDoTruncateArgs(decoder)
 21202    case events.FileModification:
 21203      return ParseFileModificationArgs(decoder)
 21204    case events.InotifyWatch:
 21205      return ParseInotifyWatchArgs(decoder)
 21206    case events.ProcessExecuteFailed:
 21207      return ParseProcessExecuteFailedArgs(decoder)
 21208    case events.TtyOpen:
 21209      return ParseTtyOpenArgs(decoder)
 21210    case events.NetPacketBase:
 21211      return ParseNetPacketBaseArgs(decoder)
 21212    case events.NetPacketIPBase:
 21213      return ParseNetPacketIPBaseArgs(decoder)
 21214    case events.NetPacketIPv4:
 21215      return ParseNetPacketIPv4Args(decoder)
 21216    case events.NetPacketIPv6:
 21217      return ParseNetPacketIPv6Args(decoder)
 21218    case events.NetPacketTCPBase:
 21219      return ParseNetPacketTCPBaseArgs(decoder)
 21220    case events.NetPacketTCP:
 21221      return ParseNetPacketTCPArgs(decoder)
 21222    case events.NetPacketUDPBase:
 21223      return ParseNetPacketUDPBaseArgs(decoder)
 21224    case events.NetPacketUDP:
 21225      return ParseNetPacketUDPArgs(decoder)
 21226    case events.NetPacketICMPBase:
 21227      return ParseNetPacketICMPBaseArgs(decoder)
 21228    case events.NetPacketICMP:
 21229      return ParseNetPacketICMPArgs(decoder)
 21230    case events.NetPacketICMPv6Base:
 21231      return ParseNetPacketICMPv6BaseArgs(decoder)
 21232    case events.NetPacketICMPv6:
 21233      return ParseNetPacketICMPv6Args(decoder)
 21234    case events.NetPacketDNSBase:
 21235      return ParseNetPacketDNSBaseArgs(decoder)
 21236    case events.NetPacketDNS:
 21237      return ParseNetPacketDNSArgs(decoder)
 21238    case events.NetPacketDNSRequest:
 21239      return ParseNetPacketDNSRequestArgs(decoder)
 21240    case events.NetPacketDNSResponse:
 21241      return ParseNetPacketDNSResponseArgs(decoder)
 21242    case events.NetPacketHTTPBase:
 21243      return ParseNetPacketHTTPBaseArgs(decoder)
 21244    case events.NetPacketHTTP:
 21245      return ParseNetPacketHTTPArgs(decoder)
 21246    case events.NetPacketHTTPRequest:
 21247      return ParseNetPacketHTTPRequestArgs(decoder)
 21248    case events.NetPacketHTTPResponse:
 21249      return ParseNetPacketHTTPResponseArgs(decoder)
 21250    case events.NetPacketSOCKS5Base:
 21251      return ParseNetPacketSOCKS5BaseArgs(decoder)
 21252    case events.NetPacketCapture:
 21253      return ParseNetPacketCaptureArgs(decoder)
 21254    case events.CaptureNetPacket:
 21255      return ParseCaptureNetPacketArgs(decoder)
 21256    case events.SockSetState:
 21257      return ParseSockSetStateArgs(decoder)
 21258    case events.TrackSyscallStats:
 21259      return ParseTrackSyscallStatsArgs(decoder)
 21260    case events.TestEvent:
 21261      return ParseTestEventArgs(decoder)
 21262    case events.SignalCgroupMkdir:
 21263      return ParseSignalCgroupMkdirArgs(decoder)
 21264    case events.SignalCgroupRmdir:
 21265      return ParseSignalCgroupRmdirArgs(decoder)
 21266    case events.NetFlowBase:
 21267      return ParseNetFlowBaseArgs(decoder)
 21268    }
 21269  
 21270    return nil, ErrUnknownArgsType
 21271  }