github.com/benz9527/xboot@v0.0.0-20240504061247-c23f15593274/lib/list/x_conc_skl_node_gen.go (about)

     1  // Auto generated code; Do NOT EDIT!
     2  // Author benzheng2121@126.com
     3  
     4  package list
     5  
     6  import (
     7  	"github.com/benz9527/xboot/lib/infra"
     8  )
     9  
    10  func genXConcSklUniqueNode[K infra.OrderedKey, V any](
    11  	key K,
    12  	val V,
    13  	lvl int32,
    14  ) *xConcSklNode[K, V] {
    15  	switch lvl {
    16  	case 1: 
    17  	  n := struct {
    18  		node    xConcSklNode[K, V]
    19  		indices [1]*xConcSklNode[K, V]
    20  		xN      xNode[V]
    21  	  }{}
    22  	  n.node.indices = n.indices[:]
    23  	  n.node.key = key
    24  	  n.node.level = uint32(lvl)
    25  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
    26  	  n.xN.vptr = &val
    27  	  n.node.root = &n.xN
    28  	  n.node.count = 1
    29  	  return &n.node
    30  	case 2: 
    31  	  n := struct {
    32  		node    xConcSklNode[K, V]
    33  		indices [2]*xConcSklNode[K, V]
    34  		xN      xNode[V]
    35  	  }{}
    36  	  n.node.indices = n.indices[:]
    37  	  n.node.key = key
    38  	  n.node.level = uint32(lvl)
    39  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
    40  	  n.xN.vptr = &val
    41  	  n.node.root = &n.xN
    42  	  n.node.count = 1
    43  	  return &n.node
    44  	case 3: 
    45  	  n := struct {
    46  		node    xConcSklNode[K, V]
    47  		indices [3]*xConcSklNode[K, V]
    48  		xN      xNode[V]
    49  	  }{}
    50  	  n.node.indices = n.indices[:]
    51  	  n.node.key = key
    52  	  n.node.level = uint32(lvl)
    53  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
    54  	  n.xN.vptr = &val
    55  	  n.node.root = &n.xN
    56  	  n.node.count = 1
    57  	  return &n.node
    58  	case 4: 
    59  	  n := struct {
    60  		node    xConcSklNode[K, V]
    61  		indices [4]*xConcSklNode[K, V]
    62  		xN      xNode[V]
    63  	  }{}
    64  	  n.node.indices = n.indices[:]
    65  	  n.node.key = key
    66  	  n.node.level = uint32(lvl)
    67  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
    68  	  n.xN.vptr = &val
    69  	  n.node.root = &n.xN
    70  	  n.node.count = 1
    71  	  return &n.node
    72  	case 5: 
    73  	  n := struct {
    74  		node    xConcSklNode[K, V]
    75  		indices [5]*xConcSklNode[K, V]
    76  		xN      xNode[V]
    77  	  }{}
    78  	  n.node.indices = n.indices[:]
    79  	  n.node.key = key
    80  	  n.node.level = uint32(lvl)
    81  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
    82  	  n.xN.vptr = &val
    83  	  n.node.root = &n.xN
    84  	  n.node.count = 1
    85  	  return &n.node
    86  	case 6: 
    87  	  n := struct {
    88  		node    xConcSklNode[K, V]
    89  		indices [6]*xConcSklNode[K, V]
    90  		xN      xNode[V]
    91  	  }{}
    92  	  n.node.indices = n.indices[:]
    93  	  n.node.key = key
    94  	  n.node.level = uint32(lvl)
    95  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
    96  	  n.xN.vptr = &val
    97  	  n.node.root = &n.xN
    98  	  n.node.count = 1
    99  	  return &n.node
   100  	case 7: 
   101  	  n := struct {
   102  		node    xConcSklNode[K, V]
   103  		indices [7]*xConcSklNode[K, V]
   104  		xN      xNode[V]
   105  	  }{}
   106  	  n.node.indices = n.indices[:]
   107  	  n.node.key = key
   108  	  n.node.level = uint32(lvl)
   109  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   110  	  n.xN.vptr = &val
   111  	  n.node.root = &n.xN
   112  	  n.node.count = 1
   113  	  return &n.node
   114  	case 8: 
   115  	  n := struct {
   116  		node    xConcSklNode[K, V]
   117  		indices [8]*xConcSklNode[K, V]
   118  		xN      xNode[V]
   119  	  }{}
   120  	  n.node.indices = n.indices[:]
   121  	  n.node.key = key
   122  	  n.node.level = uint32(lvl)
   123  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   124  	  n.xN.vptr = &val
   125  	  n.node.root = &n.xN
   126  	  n.node.count = 1
   127  	  return &n.node
   128  	case 9: 
   129  	  n := struct {
   130  		node    xConcSklNode[K, V]
   131  		indices [9]*xConcSklNode[K, V]
   132  		xN      xNode[V]
   133  	  }{}
   134  	  n.node.indices = n.indices[:]
   135  	  n.node.key = key
   136  	  n.node.level = uint32(lvl)
   137  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   138  	  n.xN.vptr = &val
   139  	  n.node.root = &n.xN
   140  	  n.node.count = 1
   141  	  return &n.node
   142  	case 10: 
   143  	  n := struct {
   144  		node    xConcSklNode[K, V]
   145  		indices [10]*xConcSklNode[K, V]
   146  		xN      xNode[V]
   147  	  }{}
   148  	  n.node.indices = n.indices[:]
   149  	  n.node.key = key
   150  	  n.node.level = uint32(lvl)
   151  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   152  	  n.xN.vptr = &val
   153  	  n.node.root = &n.xN
   154  	  n.node.count = 1
   155  	  return &n.node
   156  	case 11: 
   157  	  n := struct {
   158  		node    xConcSklNode[K, V]
   159  		indices [11]*xConcSklNode[K, V]
   160  		xN      xNode[V]
   161  	  }{}
   162  	  n.node.indices = n.indices[:]
   163  	  n.node.key = key
   164  	  n.node.level = uint32(lvl)
   165  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   166  	  n.xN.vptr = &val
   167  	  n.node.root = &n.xN
   168  	  n.node.count = 1
   169  	  return &n.node
   170  	case 12: 
   171  	  n := struct {
   172  		node    xConcSklNode[K, V]
   173  		indices [12]*xConcSklNode[K, V]
   174  		xN      xNode[V]
   175  	  }{}
   176  	  n.node.indices = n.indices[:]
   177  	  n.node.key = key
   178  	  n.node.level = uint32(lvl)
   179  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   180  	  n.xN.vptr = &val
   181  	  n.node.root = &n.xN
   182  	  n.node.count = 1
   183  	  return &n.node
   184  	case 13: 
   185  	  n := struct {
   186  		node    xConcSklNode[K, V]
   187  		indices [13]*xConcSklNode[K, V]
   188  		xN      xNode[V]
   189  	  }{}
   190  	  n.node.indices = n.indices[:]
   191  	  n.node.key = key
   192  	  n.node.level = uint32(lvl)
   193  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   194  	  n.xN.vptr = &val
   195  	  n.node.root = &n.xN
   196  	  n.node.count = 1
   197  	  return &n.node
   198  	case 14: 
   199  	  n := struct {
   200  		node    xConcSklNode[K, V]
   201  		indices [14]*xConcSklNode[K, V]
   202  		xN      xNode[V]
   203  	  }{}
   204  	  n.node.indices = n.indices[:]
   205  	  n.node.key = key
   206  	  n.node.level = uint32(lvl)
   207  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   208  	  n.xN.vptr = &val
   209  	  n.node.root = &n.xN
   210  	  n.node.count = 1
   211  	  return &n.node
   212  	case 15: 
   213  	  n := struct {
   214  		node    xConcSklNode[K, V]
   215  		indices [15]*xConcSklNode[K, V]
   216  		xN      xNode[V]
   217  	  }{}
   218  	  n.node.indices = n.indices[:]
   219  	  n.node.key = key
   220  	  n.node.level = uint32(lvl)
   221  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   222  	  n.xN.vptr = &val
   223  	  n.node.root = &n.xN
   224  	  n.node.count = 1
   225  	  return &n.node
   226  	case 16: 
   227  	  n := struct {
   228  		node    xConcSklNode[K, V]
   229  		indices [16]*xConcSklNode[K, V]
   230  		xN      xNode[V]
   231  	  }{}
   232  	  n.node.indices = n.indices[:]
   233  	  n.node.key = key
   234  	  n.node.level = uint32(lvl)
   235  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   236  	  n.xN.vptr = &val
   237  	  n.node.root = &n.xN
   238  	  n.node.count = 1
   239  	  return &n.node
   240  	case 17: 
   241  	  n := struct {
   242  		node    xConcSklNode[K, V]
   243  		indices [17]*xConcSklNode[K, V]
   244  		xN      xNode[V]
   245  	  }{}
   246  	  n.node.indices = n.indices[:]
   247  	  n.node.key = key
   248  	  n.node.level = uint32(lvl)
   249  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   250  	  n.xN.vptr = &val
   251  	  n.node.root = &n.xN
   252  	  n.node.count = 1
   253  	  return &n.node
   254  	case 18: 
   255  	  n := struct {
   256  		node    xConcSklNode[K, V]
   257  		indices [18]*xConcSklNode[K, V]
   258  		xN      xNode[V]
   259  	  }{}
   260  	  n.node.indices = n.indices[:]
   261  	  n.node.key = key
   262  	  n.node.level = uint32(lvl)
   263  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   264  	  n.xN.vptr = &val
   265  	  n.node.root = &n.xN
   266  	  n.node.count = 1
   267  	  return &n.node
   268  	case 19: 
   269  	  n := struct {
   270  		node    xConcSklNode[K, V]
   271  		indices [19]*xConcSklNode[K, V]
   272  		xN      xNode[V]
   273  	  }{}
   274  	  n.node.indices = n.indices[:]
   275  	  n.node.key = key
   276  	  n.node.level = uint32(lvl)
   277  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   278  	  n.xN.vptr = &val
   279  	  n.node.root = &n.xN
   280  	  n.node.count = 1
   281  	  return &n.node
   282  	case 20: 
   283  	  n := struct {
   284  		node    xConcSklNode[K, V]
   285  		indices [20]*xConcSklNode[K, V]
   286  		xN      xNode[V]
   287  	  }{}
   288  	  n.node.indices = n.indices[:]
   289  	  n.node.key = key
   290  	  n.node.level = uint32(lvl)
   291  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   292  	  n.xN.vptr = &val
   293  	  n.node.root = &n.xN
   294  	  n.node.count = 1
   295  	  return &n.node
   296  	case 21: 
   297  	  n := struct {
   298  		node    xConcSklNode[K, V]
   299  		indices [21]*xConcSklNode[K, V]
   300  		xN      xNode[V]
   301  	  }{}
   302  	  n.node.indices = n.indices[:]
   303  	  n.node.key = key
   304  	  n.node.level = uint32(lvl)
   305  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   306  	  n.xN.vptr = &val
   307  	  n.node.root = &n.xN
   308  	  n.node.count = 1
   309  	  return &n.node
   310  	case 22: 
   311  	  n := struct {
   312  		node    xConcSklNode[K, V]
   313  		indices [22]*xConcSklNode[K, V]
   314  		xN      xNode[V]
   315  	  }{}
   316  	  n.node.indices = n.indices[:]
   317  	  n.node.key = key
   318  	  n.node.level = uint32(lvl)
   319  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   320  	  n.xN.vptr = &val
   321  	  n.node.root = &n.xN
   322  	  n.node.count = 1
   323  	  return &n.node
   324  	case 23: 
   325  	  n := struct {
   326  		node    xConcSklNode[K, V]
   327  		indices [23]*xConcSklNode[K, V]
   328  		xN      xNode[V]
   329  	  }{}
   330  	  n.node.indices = n.indices[:]
   331  	  n.node.key = key
   332  	  n.node.level = uint32(lvl)
   333  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   334  	  n.xN.vptr = &val
   335  	  n.node.root = &n.xN
   336  	  n.node.count = 1
   337  	  return &n.node
   338  	case 24: 
   339  	  n := struct {
   340  		node    xConcSklNode[K, V]
   341  		indices [24]*xConcSklNode[K, V]
   342  		xN      xNode[V]
   343  	  }{}
   344  	  n.node.indices = n.indices[:]
   345  	  n.node.key = key
   346  	  n.node.level = uint32(lvl)
   347  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   348  	  n.xN.vptr = &val
   349  	  n.node.root = &n.xN
   350  	  n.node.count = 1
   351  	  return &n.node
   352  	case 25: 
   353  	  n := struct {
   354  		node    xConcSklNode[K, V]
   355  		indices [25]*xConcSklNode[K, V]
   356  		xN      xNode[V]
   357  	  }{}
   358  	  n.node.indices = n.indices[:]
   359  	  n.node.key = key
   360  	  n.node.level = uint32(lvl)
   361  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   362  	  n.xN.vptr = &val
   363  	  n.node.root = &n.xN
   364  	  n.node.count = 1
   365  	  return &n.node
   366  	case 26: 
   367  	  n := struct {
   368  		node    xConcSklNode[K, V]
   369  		indices [26]*xConcSklNode[K, V]
   370  		xN      xNode[V]
   371  	  }{}
   372  	  n.node.indices = n.indices[:]
   373  	  n.node.key = key
   374  	  n.node.level = uint32(lvl)
   375  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   376  	  n.xN.vptr = &val
   377  	  n.node.root = &n.xN
   378  	  n.node.count = 1
   379  	  return &n.node
   380  	case 27: 
   381  	  n := struct {
   382  		node    xConcSklNode[K, V]
   383  		indices [27]*xConcSklNode[K, V]
   384  		xN      xNode[V]
   385  	  }{}
   386  	  n.node.indices = n.indices[:]
   387  	  n.node.key = key
   388  	  n.node.level = uint32(lvl)
   389  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   390  	  n.xN.vptr = &val
   391  	  n.node.root = &n.xN
   392  	  n.node.count = 1
   393  	  return &n.node
   394  	case 28: 
   395  	  n := struct {
   396  		node    xConcSklNode[K, V]
   397  		indices [28]*xConcSklNode[K, V]
   398  		xN      xNode[V]
   399  	  }{}
   400  	  n.node.indices = n.indices[:]
   401  	  n.node.key = key
   402  	  n.node.level = uint32(lvl)
   403  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   404  	  n.xN.vptr = &val
   405  	  n.node.root = &n.xN
   406  	  n.node.count = 1
   407  	  return &n.node
   408  	case 29: 
   409  	  n := struct {
   410  		node    xConcSklNode[K, V]
   411  		indices [29]*xConcSklNode[K, V]
   412  		xN      xNode[V]
   413  	  }{}
   414  	  n.node.indices = n.indices[:]
   415  	  n.node.key = key
   416  	  n.node.level = uint32(lvl)
   417  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   418  	  n.xN.vptr = &val
   419  	  n.node.root = &n.xN
   420  	  n.node.count = 1
   421  	  return &n.node
   422  	case 30: 
   423  	  n := struct {
   424  		node    xConcSklNode[K, V]
   425  		indices [30]*xConcSklNode[K, V]
   426  		xN      xNode[V]
   427  	  }{}
   428  	  n.node.indices = n.indices[:]
   429  	  n.node.key = key
   430  	  n.node.level = uint32(lvl)
   431  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   432  	  n.xN.vptr = &val
   433  	  n.node.root = &n.xN
   434  	  n.node.count = 1
   435  	  return &n.node
   436  	case 31: 
   437  	  n := struct {
   438  		node    xConcSklNode[K, V]
   439  		indices [31]*xConcSklNode[K, V]
   440  		xN      xNode[V]
   441  	  }{}
   442  	  n.node.indices = n.indices[:]
   443  	  n.node.key = key
   444  	  n.node.level = uint32(lvl)
   445  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   446  	  n.xN.vptr = &val
   447  	  n.node.root = &n.xN
   448  	  n.node.count = 1
   449  	  return &n.node
   450  	case 32: 
   451  	  n := struct {
   452  		node    xConcSklNode[K, V]
   453  		indices [32]*xConcSklNode[K, V]
   454  		xN      xNode[V]
   455  	  }{}
   456  	  n.node.indices = n.indices[:]
   457  	  n.node.key = key
   458  	  n.node.level = uint32(lvl)
   459  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(unique))
   460  	  n.xN.vptr = &val
   461  	  n.node.root = &n.xN
   462  	  n.node.count = 1
   463  	  return &n.node
   464  	default:
   465  	}
   466  	panic("unable to generate ")
   467  }
   468  
   469  func genXConcSklLinkedListNode[K infra.OrderedKey, V any](
   470  	key K,
   471  	val V,
   472  	lvl int32,
   473  ) *xConcSklNode[K, V] {
   474  	switch lvl {
   475  	case 1: 
   476  	  n := struct {
   477  		node    xConcSklNode[K, V]
   478  		indices [1]*xConcSklNode[K, V]
   479  		xN      [2]xNode[V]
   480  	  }{}
   481  	  n.node.indices = n.indices[:]
   482  	  n.node.key = key
   483  	  n.node.level = uint32(lvl)
   484  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   485  	  n.xN[1].vptr = &val
   486  	  n.node.root = &n.xN[0]
   487  	  n.node.root.parent = &n.xN[1]
   488  	  n.node.count = 1
   489  	  return &n.node
   490  	case 2: 
   491  	  n := struct {
   492  		node    xConcSklNode[K, V]
   493  		indices [2]*xConcSklNode[K, V]
   494  		xN      [2]xNode[V]
   495  	  }{}
   496  	  n.node.indices = n.indices[:]
   497  	  n.node.key = key
   498  	  n.node.level = uint32(lvl)
   499  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   500  	  n.xN[1].vptr = &val
   501  	  n.node.root = &n.xN[0]
   502  	  n.node.root.parent = &n.xN[1]
   503  	  n.node.count = 1
   504  	  return &n.node
   505  	case 3: 
   506  	  n := struct {
   507  		node    xConcSklNode[K, V]
   508  		indices [3]*xConcSklNode[K, V]
   509  		xN      [2]xNode[V]
   510  	  }{}
   511  	  n.node.indices = n.indices[:]
   512  	  n.node.key = key
   513  	  n.node.level = uint32(lvl)
   514  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   515  	  n.xN[1].vptr = &val
   516  	  n.node.root = &n.xN[0]
   517  	  n.node.root.parent = &n.xN[1]
   518  	  n.node.count = 1
   519  	  return &n.node
   520  	case 4: 
   521  	  n := struct {
   522  		node    xConcSklNode[K, V]
   523  		indices [4]*xConcSklNode[K, V]
   524  		xN      [2]xNode[V]
   525  	  }{}
   526  	  n.node.indices = n.indices[:]
   527  	  n.node.key = key
   528  	  n.node.level = uint32(lvl)
   529  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   530  	  n.xN[1].vptr = &val
   531  	  n.node.root = &n.xN[0]
   532  	  n.node.root.parent = &n.xN[1]
   533  	  n.node.count = 1
   534  	  return &n.node
   535  	case 5: 
   536  	  n := struct {
   537  		node    xConcSklNode[K, V]
   538  		indices [5]*xConcSklNode[K, V]
   539  		xN      [2]xNode[V]
   540  	  }{}
   541  	  n.node.indices = n.indices[:]
   542  	  n.node.key = key
   543  	  n.node.level = uint32(lvl)
   544  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   545  	  n.xN[1].vptr = &val
   546  	  n.node.root = &n.xN[0]
   547  	  n.node.root.parent = &n.xN[1]
   548  	  n.node.count = 1
   549  	  return &n.node
   550  	case 6: 
   551  	  n := struct {
   552  		node    xConcSklNode[K, V]
   553  		indices [6]*xConcSklNode[K, V]
   554  		xN      [2]xNode[V]
   555  	  }{}
   556  	  n.node.indices = n.indices[:]
   557  	  n.node.key = key
   558  	  n.node.level = uint32(lvl)
   559  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   560  	  n.xN[1].vptr = &val
   561  	  n.node.root = &n.xN[0]
   562  	  n.node.root.parent = &n.xN[1]
   563  	  n.node.count = 1
   564  	  return &n.node
   565  	case 7: 
   566  	  n := struct {
   567  		node    xConcSklNode[K, V]
   568  		indices [7]*xConcSklNode[K, V]
   569  		xN      [2]xNode[V]
   570  	  }{}
   571  	  n.node.indices = n.indices[:]
   572  	  n.node.key = key
   573  	  n.node.level = uint32(lvl)
   574  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   575  	  n.xN[1].vptr = &val
   576  	  n.node.root = &n.xN[0]
   577  	  n.node.root.parent = &n.xN[1]
   578  	  n.node.count = 1
   579  	  return &n.node
   580  	case 8: 
   581  	  n := struct {
   582  		node    xConcSklNode[K, V]
   583  		indices [8]*xConcSklNode[K, V]
   584  		xN      [2]xNode[V]
   585  	  }{}
   586  	  n.node.indices = n.indices[:]
   587  	  n.node.key = key
   588  	  n.node.level = uint32(lvl)
   589  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   590  	  n.xN[1].vptr = &val
   591  	  n.node.root = &n.xN[0]
   592  	  n.node.root.parent = &n.xN[1]
   593  	  n.node.count = 1
   594  	  return &n.node
   595  	case 9: 
   596  	  n := struct {
   597  		node    xConcSklNode[K, V]
   598  		indices [9]*xConcSklNode[K, V]
   599  		xN      [2]xNode[V]
   600  	  }{}
   601  	  n.node.indices = n.indices[:]
   602  	  n.node.key = key
   603  	  n.node.level = uint32(lvl)
   604  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   605  	  n.xN[1].vptr = &val
   606  	  n.node.root = &n.xN[0]
   607  	  n.node.root.parent = &n.xN[1]
   608  	  n.node.count = 1
   609  	  return &n.node
   610  	case 10: 
   611  	  n := struct {
   612  		node    xConcSklNode[K, V]
   613  		indices [10]*xConcSklNode[K, V]
   614  		xN      [2]xNode[V]
   615  	  }{}
   616  	  n.node.indices = n.indices[:]
   617  	  n.node.key = key
   618  	  n.node.level = uint32(lvl)
   619  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   620  	  n.xN[1].vptr = &val
   621  	  n.node.root = &n.xN[0]
   622  	  n.node.root.parent = &n.xN[1]
   623  	  n.node.count = 1
   624  	  return &n.node
   625  	case 11: 
   626  	  n := struct {
   627  		node    xConcSklNode[K, V]
   628  		indices [11]*xConcSklNode[K, V]
   629  		xN      [2]xNode[V]
   630  	  }{}
   631  	  n.node.indices = n.indices[:]
   632  	  n.node.key = key
   633  	  n.node.level = uint32(lvl)
   634  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   635  	  n.xN[1].vptr = &val
   636  	  n.node.root = &n.xN[0]
   637  	  n.node.root.parent = &n.xN[1]
   638  	  n.node.count = 1
   639  	  return &n.node
   640  	case 12: 
   641  	  n := struct {
   642  		node    xConcSklNode[K, V]
   643  		indices [12]*xConcSklNode[K, V]
   644  		xN      [2]xNode[V]
   645  	  }{}
   646  	  n.node.indices = n.indices[:]
   647  	  n.node.key = key
   648  	  n.node.level = uint32(lvl)
   649  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   650  	  n.xN[1].vptr = &val
   651  	  n.node.root = &n.xN[0]
   652  	  n.node.root.parent = &n.xN[1]
   653  	  n.node.count = 1
   654  	  return &n.node
   655  	case 13: 
   656  	  n := struct {
   657  		node    xConcSklNode[K, V]
   658  		indices [13]*xConcSklNode[K, V]
   659  		xN      [2]xNode[V]
   660  	  }{}
   661  	  n.node.indices = n.indices[:]
   662  	  n.node.key = key
   663  	  n.node.level = uint32(lvl)
   664  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   665  	  n.xN[1].vptr = &val
   666  	  n.node.root = &n.xN[0]
   667  	  n.node.root.parent = &n.xN[1]
   668  	  n.node.count = 1
   669  	  return &n.node
   670  	case 14: 
   671  	  n := struct {
   672  		node    xConcSklNode[K, V]
   673  		indices [14]*xConcSklNode[K, V]
   674  		xN      [2]xNode[V]
   675  	  }{}
   676  	  n.node.indices = n.indices[:]
   677  	  n.node.key = key
   678  	  n.node.level = uint32(lvl)
   679  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   680  	  n.xN[1].vptr = &val
   681  	  n.node.root = &n.xN[0]
   682  	  n.node.root.parent = &n.xN[1]
   683  	  n.node.count = 1
   684  	  return &n.node
   685  	case 15: 
   686  	  n := struct {
   687  		node    xConcSklNode[K, V]
   688  		indices [15]*xConcSklNode[K, V]
   689  		xN      [2]xNode[V]
   690  	  }{}
   691  	  n.node.indices = n.indices[:]
   692  	  n.node.key = key
   693  	  n.node.level = uint32(lvl)
   694  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   695  	  n.xN[1].vptr = &val
   696  	  n.node.root = &n.xN[0]
   697  	  n.node.root.parent = &n.xN[1]
   698  	  n.node.count = 1
   699  	  return &n.node
   700  	case 16: 
   701  	  n := struct {
   702  		node    xConcSklNode[K, V]
   703  		indices [16]*xConcSklNode[K, V]
   704  		xN      [2]xNode[V]
   705  	  }{}
   706  	  n.node.indices = n.indices[:]
   707  	  n.node.key = key
   708  	  n.node.level = uint32(lvl)
   709  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   710  	  n.xN[1].vptr = &val
   711  	  n.node.root = &n.xN[0]
   712  	  n.node.root.parent = &n.xN[1]
   713  	  n.node.count = 1
   714  	  return &n.node
   715  	case 17: 
   716  	  n := struct {
   717  		node    xConcSklNode[K, V]
   718  		indices [17]*xConcSklNode[K, V]
   719  		xN      [2]xNode[V]
   720  	  }{}
   721  	  n.node.indices = n.indices[:]
   722  	  n.node.key = key
   723  	  n.node.level = uint32(lvl)
   724  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   725  	  n.xN[1].vptr = &val
   726  	  n.node.root = &n.xN[0]
   727  	  n.node.root.parent = &n.xN[1]
   728  	  n.node.count = 1
   729  	  return &n.node
   730  	case 18: 
   731  	  n := struct {
   732  		node    xConcSklNode[K, V]
   733  		indices [18]*xConcSklNode[K, V]
   734  		xN      [2]xNode[V]
   735  	  }{}
   736  	  n.node.indices = n.indices[:]
   737  	  n.node.key = key
   738  	  n.node.level = uint32(lvl)
   739  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   740  	  n.xN[1].vptr = &val
   741  	  n.node.root = &n.xN[0]
   742  	  n.node.root.parent = &n.xN[1]
   743  	  n.node.count = 1
   744  	  return &n.node
   745  	case 19: 
   746  	  n := struct {
   747  		node    xConcSklNode[K, V]
   748  		indices [19]*xConcSklNode[K, V]
   749  		xN      [2]xNode[V]
   750  	  }{}
   751  	  n.node.indices = n.indices[:]
   752  	  n.node.key = key
   753  	  n.node.level = uint32(lvl)
   754  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   755  	  n.xN[1].vptr = &val
   756  	  n.node.root = &n.xN[0]
   757  	  n.node.root.parent = &n.xN[1]
   758  	  n.node.count = 1
   759  	  return &n.node
   760  	case 20: 
   761  	  n := struct {
   762  		node    xConcSklNode[K, V]
   763  		indices [20]*xConcSklNode[K, V]
   764  		xN      [2]xNode[V]
   765  	  }{}
   766  	  n.node.indices = n.indices[:]
   767  	  n.node.key = key
   768  	  n.node.level = uint32(lvl)
   769  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   770  	  n.xN[1].vptr = &val
   771  	  n.node.root = &n.xN[0]
   772  	  n.node.root.parent = &n.xN[1]
   773  	  n.node.count = 1
   774  	  return &n.node
   775  	case 21: 
   776  	  n := struct {
   777  		node    xConcSklNode[K, V]
   778  		indices [21]*xConcSklNode[K, V]
   779  		xN      [2]xNode[V]
   780  	  }{}
   781  	  n.node.indices = n.indices[:]
   782  	  n.node.key = key
   783  	  n.node.level = uint32(lvl)
   784  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   785  	  n.xN[1].vptr = &val
   786  	  n.node.root = &n.xN[0]
   787  	  n.node.root.parent = &n.xN[1]
   788  	  n.node.count = 1
   789  	  return &n.node
   790  	case 22: 
   791  	  n := struct {
   792  		node    xConcSklNode[K, V]
   793  		indices [22]*xConcSklNode[K, V]
   794  		xN      [2]xNode[V]
   795  	  }{}
   796  	  n.node.indices = n.indices[:]
   797  	  n.node.key = key
   798  	  n.node.level = uint32(lvl)
   799  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   800  	  n.xN[1].vptr = &val
   801  	  n.node.root = &n.xN[0]
   802  	  n.node.root.parent = &n.xN[1]
   803  	  n.node.count = 1
   804  	  return &n.node
   805  	case 23: 
   806  	  n := struct {
   807  		node    xConcSklNode[K, V]
   808  		indices [23]*xConcSklNode[K, V]
   809  		xN      [2]xNode[V]
   810  	  }{}
   811  	  n.node.indices = n.indices[:]
   812  	  n.node.key = key
   813  	  n.node.level = uint32(lvl)
   814  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   815  	  n.xN[1].vptr = &val
   816  	  n.node.root = &n.xN[0]
   817  	  n.node.root.parent = &n.xN[1]
   818  	  n.node.count = 1
   819  	  return &n.node
   820  	case 24: 
   821  	  n := struct {
   822  		node    xConcSklNode[K, V]
   823  		indices [24]*xConcSklNode[K, V]
   824  		xN      [2]xNode[V]
   825  	  }{}
   826  	  n.node.indices = n.indices[:]
   827  	  n.node.key = key
   828  	  n.node.level = uint32(lvl)
   829  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   830  	  n.xN[1].vptr = &val
   831  	  n.node.root = &n.xN[0]
   832  	  n.node.root.parent = &n.xN[1]
   833  	  n.node.count = 1
   834  	  return &n.node
   835  	case 25: 
   836  	  n := struct {
   837  		node    xConcSklNode[K, V]
   838  		indices [25]*xConcSklNode[K, V]
   839  		xN      [2]xNode[V]
   840  	  }{}
   841  	  n.node.indices = n.indices[:]
   842  	  n.node.key = key
   843  	  n.node.level = uint32(lvl)
   844  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   845  	  n.xN[1].vptr = &val
   846  	  n.node.root = &n.xN[0]
   847  	  n.node.root.parent = &n.xN[1]
   848  	  n.node.count = 1
   849  	  return &n.node
   850  	case 26: 
   851  	  n := struct {
   852  		node    xConcSklNode[K, V]
   853  		indices [26]*xConcSklNode[K, V]
   854  		xN      [2]xNode[V]
   855  	  }{}
   856  	  n.node.indices = n.indices[:]
   857  	  n.node.key = key
   858  	  n.node.level = uint32(lvl)
   859  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   860  	  n.xN[1].vptr = &val
   861  	  n.node.root = &n.xN[0]
   862  	  n.node.root.parent = &n.xN[1]
   863  	  n.node.count = 1
   864  	  return &n.node
   865  	case 27: 
   866  	  n := struct {
   867  		node    xConcSklNode[K, V]
   868  		indices [27]*xConcSklNode[K, V]
   869  		xN      [2]xNode[V]
   870  	  }{}
   871  	  n.node.indices = n.indices[:]
   872  	  n.node.key = key
   873  	  n.node.level = uint32(lvl)
   874  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   875  	  n.xN[1].vptr = &val
   876  	  n.node.root = &n.xN[0]
   877  	  n.node.root.parent = &n.xN[1]
   878  	  n.node.count = 1
   879  	  return &n.node
   880  	case 28: 
   881  	  n := struct {
   882  		node    xConcSklNode[K, V]
   883  		indices [28]*xConcSklNode[K, V]
   884  		xN      [2]xNode[V]
   885  	  }{}
   886  	  n.node.indices = n.indices[:]
   887  	  n.node.key = key
   888  	  n.node.level = uint32(lvl)
   889  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   890  	  n.xN[1].vptr = &val
   891  	  n.node.root = &n.xN[0]
   892  	  n.node.root.parent = &n.xN[1]
   893  	  n.node.count = 1
   894  	  return &n.node
   895  	case 29: 
   896  	  n := struct {
   897  		node    xConcSklNode[K, V]
   898  		indices [29]*xConcSklNode[K, V]
   899  		xN      [2]xNode[V]
   900  	  }{}
   901  	  n.node.indices = n.indices[:]
   902  	  n.node.key = key
   903  	  n.node.level = uint32(lvl)
   904  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   905  	  n.xN[1].vptr = &val
   906  	  n.node.root = &n.xN[0]
   907  	  n.node.root.parent = &n.xN[1]
   908  	  n.node.count = 1
   909  	  return &n.node
   910  	case 30: 
   911  	  n := struct {
   912  		node    xConcSklNode[K, V]
   913  		indices [30]*xConcSklNode[K, V]
   914  		xN      [2]xNode[V]
   915  	  }{}
   916  	  n.node.indices = n.indices[:]
   917  	  n.node.key = key
   918  	  n.node.level = uint32(lvl)
   919  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   920  	  n.xN[1].vptr = &val
   921  	  n.node.root = &n.xN[0]
   922  	  n.node.root.parent = &n.xN[1]
   923  	  n.node.count = 1
   924  	  return &n.node
   925  	case 31: 
   926  	  n := struct {
   927  		node    xConcSklNode[K, V]
   928  		indices [31]*xConcSklNode[K, V]
   929  		xN      [2]xNode[V]
   930  	  }{}
   931  	  n.node.indices = n.indices[:]
   932  	  n.node.key = key
   933  	  n.node.level = uint32(lvl)
   934  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   935  	  n.xN[1].vptr = &val
   936  	  n.node.root = &n.xN[0]
   937  	  n.node.root.parent = &n.xN[1]
   938  	  n.node.count = 1
   939  	  return &n.node
   940  	case 32: 
   941  	  n := struct {
   942  		node    xConcSklNode[K, V]
   943  		indices [32]*xConcSklNode[K, V]
   944  		xN      [2]xNode[V]
   945  	  }{}
   946  	  n.node.indices = n.indices[:]
   947  	  n.node.key = key
   948  	  n.node.level = uint32(lvl)
   949  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(linkedList))
   950  	  n.xN[1].vptr = &val
   951  	  n.node.root = &n.xN[0]
   952  	  n.node.root.parent = &n.xN[1]
   953  	  n.node.count = 1
   954  	  return &n.node
   955  	default:
   956  	}
   957  	panic("unable to generate ")
   958  }
   959  
   960  func genXConcSklRbtreeNode[K infra.OrderedKey, V any](
   961  	key K,
   962  	val V,
   963  	vcmp SklValComparator[V],
   964  	lvl int32,
   965  ) *xConcSklNode[K, V] {
   966  	switch lvl {
   967  	case 1: 
   968  	  n := struct {
   969  		node    xConcSklNode[K, V]
   970  		indices [1]*xConcSklNode[K, V]
   971  	  }{}
   972  	  n.node.indices = n.indices[:]
   973  	  n.node.key = key
   974  	  n.node.level = uint32(lvl)
   975  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
   976  	  n.node.rbInsert(val, vcmp)
   977  	  n.node.count = 1
   978  	  return &n.node
   979  	case 2: 
   980  	  n := struct {
   981  		node    xConcSklNode[K, V]
   982  		indices [2]*xConcSklNode[K, V]
   983  	  }{}
   984  	  n.node.indices = n.indices[:]
   985  	  n.node.key = key
   986  	  n.node.level = uint32(lvl)
   987  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
   988  	  n.node.rbInsert(val, vcmp)
   989  	  n.node.count = 1
   990  	  return &n.node
   991  	case 3: 
   992  	  n := struct {
   993  		node    xConcSklNode[K, V]
   994  		indices [3]*xConcSklNode[K, V]
   995  	  }{}
   996  	  n.node.indices = n.indices[:]
   997  	  n.node.key = key
   998  	  n.node.level = uint32(lvl)
   999  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1000  	  n.node.rbInsert(val, vcmp)
  1001  	  n.node.count = 1
  1002  	  return &n.node
  1003  	case 4: 
  1004  	  n := struct {
  1005  		node    xConcSklNode[K, V]
  1006  		indices [4]*xConcSklNode[K, V]
  1007  	  }{}
  1008  	  n.node.indices = n.indices[:]
  1009  	  n.node.key = key
  1010  	  n.node.level = uint32(lvl)
  1011  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1012  	  n.node.rbInsert(val, vcmp)
  1013  	  n.node.count = 1
  1014  	  return &n.node
  1015  	case 5: 
  1016  	  n := struct {
  1017  		node    xConcSklNode[K, V]
  1018  		indices [5]*xConcSklNode[K, V]
  1019  	  }{}
  1020  	  n.node.indices = n.indices[:]
  1021  	  n.node.key = key
  1022  	  n.node.level = uint32(lvl)
  1023  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1024  	  n.node.rbInsert(val, vcmp)
  1025  	  n.node.count = 1
  1026  	  return &n.node
  1027  	case 6: 
  1028  	  n := struct {
  1029  		node    xConcSklNode[K, V]
  1030  		indices [6]*xConcSklNode[K, V]
  1031  	  }{}
  1032  	  n.node.indices = n.indices[:]
  1033  	  n.node.key = key
  1034  	  n.node.level = uint32(lvl)
  1035  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1036  	  n.node.rbInsert(val, vcmp)
  1037  	  n.node.count = 1
  1038  	  return &n.node
  1039  	case 7: 
  1040  	  n := struct {
  1041  		node    xConcSklNode[K, V]
  1042  		indices [7]*xConcSklNode[K, V]
  1043  	  }{}
  1044  	  n.node.indices = n.indices[:]
  1045  	  n.node.key = key
  1046  	  n.node.level = uint32(lvl)
  1047  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1048  	  n.node.rbInsert(val, vcmp)
  1049  	  n.node.count = 1
  1050  	  return &n.node
  1051  	case 8: 
  1052  	  n := struct {
  1053  		node    xConcSklNode[K, V]
  1054  		indices [8]*xConcSklNode[K, V]
  1055  	  }{}
  1056  	  n.node.indices = n.indices[:]
  1057  	  n.node.key = key
  1058  	  n.node.level = uint32(lvl)
  1059  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1060  	  n.node.rbInsert(val, vcmp)
  1061  	  n.node.count = 1
  1062  	  return &n.node
  1063  	case 9: 
  1064  	  n := struct {
  1065  		node    xConcSklNode[K, V]
  1066  		indices [9]*xConcSklNode[K, V]
  1067  	  }{}
  1068  	  n.node.indices = n.indices[:]
  1069  	  n.node.key = key
  1070  	  n.node.level = uint32(lvl)
  1071  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1072  	  n.node.rbInsert(val, vcmp)
  1073  	  n.node.count = 1
  1074  	  return &n.node
  1075  	case 10: 
  1076  	  n := struct {
  1077  		node    xConcSklNode[K, V]
  1078  		indices [10]*xConcSklNode[K, V]
  1079  	  }{}
  1080  	  n.node.indices = n.indices[:]
  1081  	  n.node.key = key
  1082  	  n.node.level = uint32(lvl)
  1083  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1084  	  n.node.rbInsert(val, vcmp)
  1085  	  n.node.count = 1
  1086  	  return &n.node
  1087  	case 11: 
  1088  	  n := struct {
  1089  		node    xConcSklNode[K, V]
  1090  		indices [11]*xConcSklNode[K, V]
  1091  	  }{}
  1092  	  n.node.indices = n.indices[:]
  1093  	  n.node.key = key
  1094  	  n.node.level = uint32(lvl)
  1095  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1096  	  n.node.rbInsert(val, vcmp)
  1097  	  n.node.count = 1
  1098  	  return &n.node
  1099  	case 12: 
  1100  	  n := struct {
  1101  		node    xConcSklNode[K, V]
  1102  		indices [12]*xConcSklNode[K, V]
  1103  	  }{}
  1104  	  n.node.indices = n.indices[:]
  1105  	  n.node.key = key
  1106  	  n.node.level = uint32(lvl)
  1107  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1108  	  n.node.rbInsert(val, vcmp)
  1109  	  n.node.count = 1
  1110  	  return &n.node
  1111  	case 13: 
  1112  	  n := struct {
  1113  		node    xConcSklNode[K, V]
  1114  		indices [13]*xConcSklNode[K, V]
  1115  	  }{}
  1116  	  n.node.indices = n.indices[:]
  1117  	  n.node.key = key
  1118  	  n.node.level = uint32(lvl)
  1119  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1120  	  n.node.rbInsert(val, vcmp)
  1121  	  n.node.count = 1
  1122  	  return &n.node
  1123  	case 14: 
  1124  	  n := struct {
  1125  		node    xConcSklNode[K, V]
  1126  		indices [14]*xConcSklNode[K, V]
  1127  	  }{}
  1128  	  n.node.indices = n.indices[:]
  1129  	  n.node.key = key
  1130  	  n.node.level = uint32(lvl)
  1131  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1132  	  n.node.rbInsert(val, vcmp)
  1133  	  n.node.count = 1
  1134  	  return &n.node
  1135  	case 15: 
  1136  	  n := struct {
  1137  		node    xConcSklNode[K, V]
  1138  		indices [15]*xConcSklNode[K, V]
  1139  	  }{}
  1140  	  n.node.indices = n.indices[:]
  1141  	  n.node.key = key
  1142  	  n.node.level = uint32(lvl)
  1143  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1144  	  n.node.rbInsert(val, vcmp)
  1145  	  n.node.count = 1
  1146  	  return &n.node
  1147  	case 16: 
  1148  	  n := struct {
  1149  		node    xConcSklNode[K, V]
  1150  		indices [16]*xConcSklNode[K, V]
  1151  	  }{}
  1152  	  n.node.indices = n.indices[:]
  1153  	  n.node.key = key
  1154  	  n.node.level = uint32(lvl)
  1155  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1156  	  n.node.rbInsert(val, vcmp)
  1157  	  n.node.count = 1
  1158  	  return &n.node
  1159  	case 17: 
  1160  	  n := struct {
  1161  		node    xConcSklNode[K, V]
  1162  		indices [17]*xConcSklNode[K, V]
  1163  	  }{}
  1164  	  n.node.indices = n.indices[:]
  1165  	  n.node.key = key
  1166  	  n.node.level = uint32(lvl)
  1167  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1168  	  n.node.rbInsert(val, vcmp)
  1169  	  n.node.count = 1
  1170  	  return &n.node
  1171  	case 18: 
  1172  	  n := struct {
  1173  		node    xConcSklNode[K, V]
  1174  		indices [18]*xConcSklNode[K, V]
  1175  	  }{}
  1176  	  n.node.indices = n.indices[:]
  1177  	  n.node.key = key
  1178  	  n.node.level = uint32(lvl)
  1179  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1180  	  n.node.rbInsert(val, vcmp)
  1181  	  n.node.count = 1
  1182  	  return &n.node
  1183  	case 19: 
  1184  	  n := struct {
  1185  		node    xConcSklNode[K, V]
  1186  		indices [19]*xConcSklNode[K, V]
  1187  	  }{}
  1188  	  n.node.indices = n.indices[:]
  1189  	  n.node.key = key
  1190  	  n.node.level = uint32(lvl)
  1191  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1192  	  n.node.rbInsert(val, vcmp)
  1193  	  n.node.count = 1
  1194  	  return &n.node
  1195  	case 20: 
  1196  	  n := struct {
  1197  		node    xConcSklNode[K, V]
  1198  		indices [20]*xConcSklNode[K, V]
  1199  	  }{}
  1200  	  n.node.indices = n.indices[:]
  1201  	  n.node.key = key
  1202  	  n.node.level = uint32(lvl)
  1203  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1204  	  n.node.rbInsert(val, vcmp)
  1205  	  n.node.count = 1
  1206  	  return &n.node
  1207  	case 21: 
  1208  	  n := struct {
  1209  		node    xConcSklNode[K, V]
  1210  		indices [21]*xConcSklNode[K, V]
  1211  	  }{}
  1212  	  n.node.indices = n.indices[:]
  1213  	  n.node.key = key
  1214  	  n.node.level = uint32(lvl)
  1215  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1216  	  n.node.rbInsert(val, vcmp)
  1217  	  n.node.count = 1
  1218  	  return &n.node
  1219  	case 22: 
  1220  	  n := struct {
  1221  		node    xConcSklNode[K, V]
  1222  		indices [22]*xConcSklNode[K, V]
  1223  	  }{}
  1224  	  n.node.indices = n.indices[:]
  1225  	  n.node.key = key
  1226  	  n.node.level = uint32(lvl)
  1227  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1228  	  n.node.rbInsert(val, vcmp)
  1229  	  n.node.count = 1
  1230  	  return &n.node
  1231  	case 23: 
  1232  	  n := struct {
  1233  		node    xConcSklNode[K, V]
  1234  		indices [23]*xConcSklNode[K, V]
  1235  	  }{}
  1236  	  n.node.indices = n.indices[:]
  1237  	  n.node.key = key
  1238  	  n.node.level = uint32(lvl)
  1239  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1240  	  n.node.rbInsert(val, vcmp)
  1241  	  n.node.count = 1
  1242  	  return &n.node
  1243  	case 24: 
  1244  	  n := struct {
  1245  		node    xConcSklNode[K, V]
  1246  		indices [24]*xConcSklNode[K, V]
  1247  	  }{}
  1248  	  n.node.indices = n.indices[:]
  1249  	  n.node.key = key
  1250  	  n.node.level = uint32(lvl)
  1251  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1252  	  n.node.rbInsert(val, vcmp)
  1253  	  n.node.count = 1
  1254  	  return &n.node
  1255  	case 25: 
  1256  	  n := struct {
  1257  		node    xConcSklNode[K, V]
  1258  		indices [25]*xConcSklNode[K, V]
  1259  	  }{}
  1260  	  n.node.indices = n.indices[:]
  1261  	  n.node.key = key
  1262  	  n.node.level = uint32(lvl)
  1263  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1264  	  n.node.rbInsert(val, vcmp)
  1265  	  n.node.count = 1
  1266  	  return &n.node
  1267  	case 26: 
  1268  	  n := struct {
  1269  		node    xConcSklNode[K, V]
  1270  		indices [26]*xConcSklNode[K, V]
  1271  	  }{}
  1272  	  n.node.indices = n.indices[:]
  1273  	  n.node.key = key
  1274  	  n.node.level = uint32(lvl)
  1275  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1276  	  n.node.rbInsert(val, vcmp)
  1277  	  n.node.count = 1
  1278  	  return &n.node
  1279  	case 27: 
  1280  	  n := struct {
  1281  		node    xConcSklNode[K, V]
  1282  		indices [27]*xConcSklNode[K, V]
  1283  	  }{}
  1284  	  n.node.indices = n.indices[:]
  1285  	  n.node.key = key
  1286  	  n.node.level = uint32(lvl)
  1287  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1288  	  n.node.rbInsert(val, vcmp)
  1289  	  n.node.count = 1
  1290  	  return &n.node
  1291  	case 28: 
  1292  	  n := struct {
  1293  		node    xConcSklNode[K, V]
  1294  		indices [28]*xConcSklNode[K, V]
  1295  	  }{}
  1296  	  n.node.indices = n.indices[:]
  1297  	  n.node.key = key
  1298  	  n.node.level = uint32(lvl)
  1299  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1300  	  n.node.rbInsert(val, vcmp)
  1301  	  n.node.count = 1
  1302  	  return &n.node
  1303  	case 29: 
  1304  	  n := struct {
  1305  		node    xConcSklNode[K, V]
  1306  		indices [29]*xConcSklNode[K, V]
  1307  	  }{}
  1308  	  n.node.indices = n.indices[:]
  1309  	  n.node.key = key
  1310  	  n.node.level = uint32(lvl)
  1311  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1312  	  n.node.rbInsert(val, vcmp)
  1313  	  n.node.count = 1
  1314  	  return &n.node
  1315  	case 30: 
  1316  	  n := struct {
  1317  		node    xConcSklNode[K, V]
  1318  		indices [30]*xConcSklNode[K, V]
  1319  	  }{}
  1320  	  n.node.indices = n.indices[:]
  1321  	  n.node.key = key
  1322  	  n.node.level = uint32(lvl)
  1323  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1324  	  n.node.rbInsert(val, vcmp)
  1325  	  n.node.count = 1
  1326  	  return &n.node
  1327  	case 31: 
  1328  	  n := struct {
  1329  		node    xConcSklNode[K, V]
  1330  		indices [31]*xConcSklNode[K, V]
  1331  	  }{}
  1332  	  n.node.indices = n.indices[:]
  1333  	  n.node.key = key
  1334  	  n.node.level = uint32(lvl)
  1335  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1336  	  n.node.rbInsert(val, vcmp)
  1337  	  n.node.count = 1
  1338  	  return &n.node
  1339  	case 32: 
  1340  	  n := struct {
  1341  		node    xConcSklNode[K, V]
  1342  		indices [32]*xConcSklNode[K, V]
  1343  	  }{}
  1344  	  n.node.indices = n.indices[:]
  1345  	  n.node.key = key
  1346  	  n.node.level = uint32(lvl)
  1347  	  n.node.flags = setBitsAs(0, xNodeModeFlagBits, uint32(rbtree))
  1348  	  n.node.rbInsert(val, vcmp)
  1349  	  n.node.count = 1
  1350  	  return &n.node
  1351  	default:
  1352  	}
  1353  	panic("unable to generate ")
  1354  }