1 /*
2  * Copyright (C) 2021 Intel Corporation
3  *
4  * SPDX-License-Identifier: MIT
5  *
6  */
7 
8 // This is a generated file - please don't modify directly
9 #pragma once
10 #include "wsl_compute_helper_types_tokens.h"
11 
12 template <TOK StrT>
13 struct Demarshaller;
14 
15 template <>
16 struct Demarshaller<TOK_S_GT_SUBSLICE_INFO> {
17     template <typename GT_SUBSLICE_INFOT>
18     static bool demarshall(GT_SUBSLICE_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
19         const TokenHeader *tok = srcTokensBeg;
20         while (tok < srcTokensEnd) {
21             if (false == tok->flags.flag4IsVariableLength) {
22                 switch (tok->id) {
23                 default:
24                     if (tok->flags.flag3IsMandatory) {
25                         return false;
26                     }
27                     break;
28                 case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: {
29                     dst.Enabled = readTokValue<decltype(dst.Enabled)>(*tok);
30                 } break;
31                 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: {
32                     dst.EuEnabledCount = readTokValue<decltype(dst.EuEnabledCount)>(*tok);
33                 } break;
34                 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: {
35                     dst.EuEnabledMask = readTokValue<decltype(dst.EuEnabledMask)>(*tok);
36                 } break;
37                 };
38                 tok = tok + 1 + tok->valueDwordCount;
39             } else {
40                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
41                 switch (tok->id) {
42                 default:
43                     if (tok->flags.flag3IsMandatory) {
44                         return false;
45                     }
46                     break;
47                 case TOK_S_GT_SUBSLICE_INFO:
48                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
49                         return false;
50                     }
51                     break;
52                 };
53                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
54             }
55         }
56         WCH_ASSERT(tok == srcTokensEnd);
57         return true;
58     }
59 };
60 
61 template <>
62 struct Demarshaller<TOK_S_GT_DUALSUBSLICE_INFO> {
63     template <typename GT_DUALSUBSLICE_INFOT>
64     static bool demarshall(GT_DUALSUBSLICE_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
65         const TokenHeader *tok = srcTokensBeg;
66         while (tok < srcTokensEnd) {
67             if (false == tok->flags.flag4IsVariableLength) {
68                 switch (tok->id) {
69                 default:
70                     if (tok->flags.flag3IsMandatory) {
71                         return false;
72                     }
73                     break;
74                 case TOK_FBB_GT_DUALSUBSLICE_INFO__ENABLED: {
75                     dst.Enabled = readTokValue<decltype(dst.Enabled)>(*tok);
76                 } break;
77                 };
78                 tok = tok + 1 + tok->valueDwordCount;
79             } else {
80                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
81                 switch (tok->id) {
82                 default:
83                     if (tok->flags.flag3IsMandatory) {
84                         return false;
85                     }
86                     break;
87                 case TOK_S_GT_DUALSUBSLICE_INFO:
88                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
89                         return false;
90                     }
91                     break;
92                 case TOK_FS_GT_DUALSUBSLICE_INFO__SUB_SLICE: {
93                     uint32_t arrayElementIdSubSlice = varLen->arrayElementId;
94                     const TokenHeader *tokSubSlice = varLen->getValue<TokenHeader>();
95                     const TokenHeader *tokSubSliceEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
96                     while (tokSubSlice < tokSubSliceEnd) {
97                         if (false == tokSubSlice->flags.flag4IsVariableLength) {
98                             switch (tokSubSlice->id) {
99                             default:
100                                 if (tokSubSlice->flags.flag3IsMandatory) {
101                                     return false;
102                                 }
103                                 break;
104                             case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: {
105                                 dst.SubSlice[arrayElementIdSubSlice].Enabled = readTokValue<decltype(dst.SubSlice[arrayElementIdSubSlice].Enabled)>(*tokSubSlice);
106                             } break;
107                             case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: {
108                                 dst.SubSlice[arrayElementIdSubSlice].EuEnabledCount = readTokValue<decltype(dst.SubSlice[arrayElementIdSubSlice].EuEnabledCount)>(*tokSubSlice);
109                             } break;
110                             case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: {
111                                 dst.SubSlice[arrayElementIdSubSlice].EuEnabledMask = readTokValue<decltype(dst.SubSlice[arrayElementIdSubSlice].EuEnabledMask)>(*tokSubSlice);
112                             } break;
113                             };
114                             tokSubSlice = tokSubSlice + 1 + tokSubSlice->valueDwordCount;
115                         } else {
116                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSubSlice);
117                             if (tokSubSlice->flags.flag3IsMandatory) {
118                                 return false;
119                             }
120                             tokSubSlice = tokSubSlice + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
121                         }
122                     }
123                     WCH_ASSERT(tokSubSlice == tokSubSliceEnd);
124                 } break;
125                 };
126                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
127             }
128         }
129         WCH_ASSERT(tok == srcTokensEnd);
130         return true;
131     }
132 };
133 
134 template <>
135 struct Demarshaller<TOK_S_GT_SLICE_INFO> {
136     template <typename GT_SLICE_INFOT>
137     static bool demarshall(GT_SLICE_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
138         const TokenHeader *tok = srcTokensBeg;
139         while (tok < srcTokensEnd) {
140             if (false == tok->flags.flag4IsVariableLength) {
141                 switch (tok->id) {
142                 default:
143                     if (tok->flags.flag3IsMandatory) {
144                         return false;
145                     }
146                     break;
147                 case TOK_FBB_GT_SLICE_INFO__ENABLED: {
148                     dst.Enabled = readTokValue<decltype(dst.Enabled)>(*tok);
149                 } break;
150                 case TOK_FBD_GT_SLICE_INFO__SUB_SLICE_ENABLED_COUNT: {
151                     dst.SubSliceEnabledCount = readTokValue<decltype(dst.SubSliceEnabledCount)>(*tok);
152                 } break;
153                 case TOK_FBD_GT_SLICE_INFO__DUAL_SUB_SLICE_ENABLED_COUNT: {
154                     dst.DualSubSliceEnabledCount = readTokValue<decltype(dst.DualSubSliceEnabledCount)>(*tok);
155                 } break;
156                 };
157                 tok = tok + 1 + tok->valueDwordCount;
158             } else {
159                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
160                 switch (tok->id) {
161                 default:
162                     if (tok->flags.flag3IsMandatory) {
163                         return false;
164                     }
165                     break;
166                 case TOK_S_GT_SLICE_INFO:
167                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
168                         return false;
169                     }
170                     break;
171                 case TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO: {
172                     uint32_t arrayElementIdSubSliceInfo = varLen->arrayElementId;
173                     const TokenHeader *tokSubSliceInfo = varLen->getValue<TokenHeader>();
174                     const TokenHeader *tokSubSliceInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
175                     while (tokSubSliceInfo < tokSubSliceInfoEnd) {
176                         if (false == tokSubSliceInfo->flags.flag4IsVariableLength) {
177                             switch (tokSubSliceInfo->id) {
178                             default:
179                                 if (tokSubSliceInfo->flags.flag3IsMandatory) {
180                                     return false;
181                                 }
182                                 break;
183                             case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: {
184                                 dst.SubSliceInfo[arrayElementIdSubSliceInfo].Enabled = readTokValue<decltype(dst.SubSliceInfo[arrayElementIdSubSliceInfo].Enabled)>(*tokSubSliceInfo);
185                             } break;
186                             case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: {
187                                 dst.SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledCount = readTokValue<decltype(dst.SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledCount)>(*tokSubSliceInfo);
188                             } break;
189                             case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: {
190                                 dst.SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledMask = readTokValue<decltype(dst.SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledMask)>(*tokSubSliceInfo);
191                             } break;
192                             };
193                             tokSubSliceInfo = tokSubSliceInfo + 1 + tokSubSliceInfo->valueDwordCount;
194                         } else {
195                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSubSliceInfo);
196                             if (tokSubSliceInfo->flags.flag3IsMandatory) {
197                                 return false;
198                             }
199                             tokSubSliceInfo = tokSubSliceInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
200                         }
201                     }
202                     WCH_ASSERT(tokSubSliceInfo == tokSubSliceInfoEnd);
203                 } break;
204                 case TOK_FS_GT_SLICE_INFO__DSSINFO: {
205                     uint32_t arrayElementIdDSSInfo = varLen->arrayElementId;
206                     const TokenHeader *tokDSSInfo = varLen->getValue<TokenHeader>();
207                     const TokenHeader *tokDSSInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
208                     while (tokDSSInfo < tokDSSInfoEnd) {
209                         if (false == tokDSSInfo->flags.flag4IsVariableLength) {
210                             switch (tokDSSInfo->id) {
211                             default:
212                                 if (tokDSSInfo->flags.flag3IsMandatory) {
213                                     return false;
214                                 }
215                                 break;
216                             case TOK_FBB_GT_DUALSUBSLICE_INFO__ENABLED: {
217                                 dst.DSSInfo[arrayElementIdDSSInfo].Enabled = readTokValue<decltype(dst.DSSInfo[arrayElementIdDSSInfo].Enabled)>(*tokDSSInfo);
218                             } break;
219                             };
220                             tokDSSInfo = tokDSSInfo + 1 + tokDSSInfo->valueDwordCount;
221                         } else {
222                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokDSSInfo);
223                             switch (tokDSSInfo->id) {
224                             default:
225                                 if (tokDSSInfo->flags.flag3IsMandatory) {
226                                     return false;
227                                 }
228                                 break;
229                             case TOK_FS_GT_DUALSUBSLICE_INFO__SUB_SLICE: {
230                                 uint32_t arrayElementIdSubSlice = varLen->arrayElementId;
231                                 const TokenHeader *tokSubSlice = varLen->getValue<TokenHeader>();
232                                 const TokenHeader *tokSubSliceEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
233                                 while (tokSubSlice < tokSubSliceEnd) {
234                                     if (false == tokSubSlice->flags.flag4IsVariableLength) {
235                                         switch (tokSubSlice->id) {
236                                         default:
237                                             if (tokSubSlice->flags.flag3IsMandatory) {
238                                                 return false;
239                                             }
240                                             break;
241                                         case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: {
242                                             dst.DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].Enabled = readTokValue<decltype(dst.DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].Enabled)>(*tokSubSlice);
243                                         } break;
244                                         case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: {
245                                             dst.DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledCount = readTokValue<decltype(dst.DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledCount)>(*tokSubSlice);
246                                         } break;
247                                         case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: {
248                                             dst.DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledMask = readTokValue<decltype(dst.DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledMask)>(*tokSubSlice);
249                                         } break;
250                                         };
251                                         tokSubSlice = tokSubSlice + 1 + tokSubSlice->valueDwordCount;
252                                     } else {
253                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSubSlice);
254                                         if (tokSubSlice->flags.flag3IsMandatory) {
255                                             return false;
256                                         }
257                                         tokSubSlice = tokSubSlice + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
258                                     }
259                                 }
260                                 WCH_ASSERT(tokSubSlice == tokSubSliceEnd);
261                             } break;
262                             };
263                             tokDSSInfo = tokDSSInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
264                         }
265                     }
266                     WCH_ASSERT(tokDSSInfo == tokDSSInfoEnd);
267                 } break;
268                 };
269                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
270             }
271         }
272         WCH_ASSERT(tok == srcTokensEnd);
273         return true;
274     }
275 };
276 
277 template <>
278 struct Demarshaller<TOK_S_GT_VEBOX_INFO> {
279     template <typename GT_VEBOX_INFOT>
280     static bool demarshall(GT_VEBOX_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
281         const TokenHeader *tok = srcTokensBeg;
282         while (tok < srcTokensEnd) {
283             if (false == tok->flags.flag4IsVariableLength) {
284                 switch (tok->id) {
285                 default:
286                     if (tok->flags.flag3IsMandatory) {
287                         return false;
288                     }
289                     break;
290                 case TOK_FBD_GT_VEBOX_INFO__NUMBER_OF_VEBOX_ENABLED: {
291                     dst.NumberOfVEBoxEnabled = readTokValue<decltype(dst.NumberOfVEBoxEnabled)>(*tok);
292                 } break;
293                 case TOK_FBB_GT_VEBOX_INFO__IS_VALID: {
294                     dst.IsValid = readTokValue<decltype(dst.IsValid)>(*tok);
295                 } break;
296                 };
297                 tok = tok + 1 + tok->valueDwordCount;
298             } else {
299                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
300                 switch (tok->id) {
301                 default:
302                     if (tok->flags.flag3IsMandatory) {
303                         return false;
304                     }
305                     break;
306                 case TOK_S_GT_VEBOX_INFO:
307                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
308                         return false;
309                     }
310                     break;
311                 case TOK_FS_GT_VEBOX_INFO__INSTANCES: {
312                     const TokenHeader *tokInstances = varLen->getValue<TokenHeader>();
313                     const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
314                     while (tokInstances < tokInstancesEnd) {
315                         if (false == tokInstances->flags.flag4IsVariableLength) {
316                             switch (tokInstances->id) {
317                             default:
318                                 if (tokInstances->flags.flag3IsMandatory) {
319                                     return false;
320                                 }
321                                 break;
322                             case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBOX_ENABLE_MASK: {
323                                 dst.Instances.VEBoxEnableMask = readTokValue<decltype(dst.Instances.VEBoxEnableMask)>(*tokInstances);
324                             } break;
325                             };
326                             tokInstances = tokInstances + 1 + tokInstances->valueDwordCount;
327                         } else {
328                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances);
329                             switch (tokInstances->id) {
330                             default:
331                                 if (tokInstances->flags.flag3IsMandatory) {
332                                     return false;
333                                 }
334                                 break;
335                             case TOK_FS_GT_VEBOX_INFO__VEBOX_INSTANCES__BITS: {
336                                 const TokenHeader *tokBits = varLen->getValue<TokenHeader>();
337                                 const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
338                                 while (tokBits < tokBitsEnd) {
339                                     if (false == tokBits->flags.flag4IsVariableLength) {
340                                         switch (tokBits->id) {
341                                         default:
342                                             if (tokBits->flags.flag3IsMandatory) {
343                                                 return false;
344                                             }
345                                             break;
346                                         case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX0ENABLED: {
347                                             dst.Instances.Bits.VEBox0Enabled = readTokValue<decltype(dst.Instances.Bits.VEBox0Enabled)>(*tokBits);
348                                         } break;
349                                         case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX1ENABLED: {
350                                             dst.Instances.Bits.VEBox1Enabled = readTokValue<decltype(dst.Instances.Bits.VEBox1Enabled)>(*tokBits);
351                                         } break;
352                                         case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX2ENABLED: {
353                                             dst.Instances.Bits.VEBox2Enabled = readTokValue<decltype(dst.Instances.Bits.VEBox2Enabled)>(*tokBits);
354                                         } break;
355                                         case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX3ENABLED: {
356                                             dst.Instances.Bits.VEBox3Enabled = readTokValue<decltype(dst.Instances.Bits.VEBox3Enabled)>(*tokBits);
357                                         } break;
358                                         };
359                                         tokBits = tokBits + 1 + tokBits->valueDwordCount;
360                                     } else {
361                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits);
362                                         if (tokBits->flags.flag3IsMandatory) {
363                                             return false;
364                                         }
365                                         tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
366                                     }
367                                 }
368                                 WCH_ASSERT(tokBits == tokBitsEnd);
369                             } break;
370                             };
371                             tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
372                         }
373                     }
374                     WCH_ASSERT(tokInstances == tokInstancesEnd);
375                 } break;
376                 case TOK_FS_GT_VEBOX_INFO__SFCSUPPORT: {
377                     const TokenHeader *tokSFCSupport = varLen->getValue<TokenHeader>();
378                     const TokenHeader *tokSFCSupportEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
379                     while (tokSFCSupport < tokSFCSupportEnd) {
380                         if (false == tokSFCSupport->flags.flag4IsVariableLength) {
381                             switch (tokSFCSupport->id) {
382                             default:
383                                 if (tokSFCSupport->flags.flag3IsMandatory) {
384                                     return false;
385                                 }
386                                 break;
387                             case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__VALUE: {
388                                 dst.SFCSupport.Value = readTokValue<decltype(dst.SFCSupport.Value)>(*tokSFCSupport);
389                             } break;
390                             };
391                             tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount;
392                         } else {
393                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSFCSupport);
394                             switch (tokSFCSupport->id) {
395                             default:
396                                 if (tokSFCSupport->flags.flag3IsMandatory) {
397                                     return false;
398                                 }
399                                 break;
400                             case TOK_FS_GT_VEBOX_INFO__ANONYMOUS3862__SFC_SUPPORTED_BITS: {
401                                 const TokenHeader *tokSfcSupportedBits = varLen->getValue<TokenHeader>();
402                                 const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
403                                 while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) {
404                                     if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) {
405                                         switch (tokSfcSupportedBits->id) {
406                                         default:
407                                             if (tokSfcSupportedBits->flags.flag3IsMandatory) {
408                                                 return false;
409                                             }
410                                             break;
411                                         case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX0: {
412                                             dst.SFCSupport.SfcSupportedBits.VEBox0 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VEBox0)>(*tokSfcSupportedBits);
413                                         } break;
414                                         case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX1: {
415                                             dst.SFCSupport.SfcSupportedBits.VEBox1 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VEBox1)>(*tokSfcSupportedBits);
416                                         } break;
417                                         case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX2: {
418                                             dst.SFCSupport.SfcSupportedBits.VEBox2 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VEBox2)>(*tokSfcSupportedBits);
419                                         } break;
420                                         case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX3: {
421                                             dst.SFCSupport.SfcSupportedBits.VEBox3 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VEBox3)>(*tokSfcSupportedBits);
422                                         } break;
423                                         };
424                                         tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount;
425                                     } else {
426                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSfcSupportedBits);
427                                         if (tokSfcSupportedBits->flags.flag3IsMandatory) {
428                                             return false;
429                                         }
430                                         tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
431                                     }
432                                 }
433                                 WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd);
434                             } break;
435                             };
436                             tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
437                         }
438                     }
439                     WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd);
440                 } break;
441                 };
442                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
443             }
444         }
445         WCH_ASSERT(tok == srcTokensEnd);
446         return true;
447     }
448 };
449 
450 template <>
451 struct Demarshaller<TOK_S_GT_VDBOX_INFO> {
452     template <typename GT_VDBOX_INFOT>
453     static bool demarshall(GT_VDBOX_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
454         const TokenHeader *tok = srcTokensBeg;
455         while (tok < srcTokensEnd) {
456             if (false == tok->flags.flag4IsVariableLength) {
457                 switch (tok->id) {
458                 default:
459                     if (tok->flags.flag3IsMandatory) {
460                         return false;
461                     }
462                     break;
463                 case TOK_FBD_GT_VDBOX_INFO__NUMBER_OF_VDBOX_ENABLED: {
464                     dst.NumberOfVDBoxEnabled = readTokValue<decltype(dst.NumberOfVDBoxEnabled)>(*tok);
465                 } break;
466                 case TOK_FBB_GT_VDBOX_INFO__IS_VALID: {
467                     dst.IsValid = readTokValue<decltype(dst.IsValid)>(*tok);
468                 } break;
469                 };
470                 tok = tok + 1 + tok->valueDwordCount;
471             } else {
472                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
473                 switch (tok->id) {
474                 default:
475                     if (tok->flags.flag3IsMandatory) {
476                         return false;
477                     }
478                     break;
479                 case TOK_S_GT_VDBOX_INFO:
480                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
481                         return false;
482                     }
483                     break;
484                 case TOK_FS_GT_VDBOX_INFO__INSTANCES: {
485                     const TokenHeader *tokInstances = varLen->getValue<TokenHeader>();
486                     const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
487                     while (tokInstances < tokInstancesEnd) {
488                         if (false == tokInstances->flags.flag4IsVariableLength) {
489                             switch (tokInstances->id) {
490                             default:
491                                 if (tokInstances->flags.flag3IsMandatory) {
492                                     return false;
493                                 }
494                                 break;
495                             case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBOX_ENABLE_MASK: {
496                                 dst.Instances.VDBoxEnableMask = readTokValue<decltype(dst.Instances.VDBoxEnableMask)>(*tokInstances);
497                             } break;
498                             };
499                             tokInstances = tokInstances + 1 + tokInstances->valueDwordCount;
500                         } else {
501                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances);
502                             switch (tokInstances->id) {
503                             default:
504                                 if (tokInstances->flags.flag3IsMandatory) {
505                                     return false;
506                                 }
507                                 break;
508                             case TOK_FS_GT_VDBOX_INFO__VDBOX_INSTANCES__BITS: {
509                                 const TokenHeader *tokBits = varLen->getValue<TokenHeader>();
510                                 const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
511                                 while (tokBits < tokBitsEnd) {
512                                     if (false == tokBits->flags.flag4IsVariableLength) {
513                                         switch (tokBits->id) {
514                                         default:
515                                             if (tokBits->flags.flag3IsMandatory) {
516                                                 return false;
517                                             }
518                                             break;
519                                         case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX0ENABLED: {
520                                             dst.Instances.Bits.VDBox0Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox0Enabled)>(*tokBits);
521                                         } break;
522                                         case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX1ENABLED: {
523                                             dst.Instances.Bits.VDBox1Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox1Enabled)>(*tokBits);
524                                         } break;
525                                         case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX2ENABLED: {
526                                             dst.Instances.Bits.VDBox2Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox2Enabled)>(*tokBits);
527                                         } break;
528                                         case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX3ENABLED: {
529                                             dst.Instances.Bits.VDBox3Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox3Enabled)>(*tokBits);
530                                         } break;
531                                         case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX4ENABLED: {
532                                             dst.Instances.Bits.VDBox4Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox4Enabled)>(*tokBits);
533                                         } break;
534                                         case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX5ENABLED: {
535                                             dst.Instances.Bits.VDBox5Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox5Enabled)>(*tokBits);
536                                         } break;
537                                         case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX6ENABLED: {
538                                             dst.Instances.Bits.VDBox6Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox6Enabled)>(*tokBits);
539                                         } break;
540                                         case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX7ENABLED: {
541                                             dst.Instances.Bits.VDBox7Enabled = readTokValue<decltype(dst.Instances.Bits.VDBox7Enabled)>(*tokBits);
542                                         } break;
543                                         };
544                                         tokBits = tokBits + 1 + tokBits->valueDwordCount;
545                                     } else {
546                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits);
547                                         if (tokBits->flags.flag3IsMandatory) {
548                                             return false;
549                                         }
550                                         tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
551                                     }
552                                 }
553                                 WCH_ASSERT(tokBits == tokBitsEnd);
554                             } break;
555                             };
556                             tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
557                         }
558                     }
559                     WCH_ASSERT(tokInstances == tokInstancesEnd);
560                 } break;
561                 case TOK_FS_GT_VDBOX_INFO__SFCSUPPORT: {
562                     const TokenHeader *tokSFCSupport = varLen->getValue<TokenHeader>();
563                     const TokenHeader *tokSFCSupportEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
564                     while (tokSFCSupport < tokSFCSupportEnd) {
565                         if (false == tokSFCSupport->flags.flag4IsVariableLength) {
566                             switch (tokSFCSupport->id) {
567                             default:
568                                 if (tokSFCSupport->flags.flag3IsMandatory) {
569                                     return false;
570                                 }
571                                 break;
572                             case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__VALUE: {
573                                 dst.SFCSupport.Value = readTokValue<decltype(dst.SFCSupport.Value)>(*tokSFCSupport);
574                             } break;
575                             };
576                             tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount;
577                         } else {
578                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSFCSupport);
579                             switch (tokSFCSupport->id) {
580                             default:
581                                 if (tokSFCSupport->flags.flag3IsMandatory) {
582                                     return false;
583                                 }
584                                 break;
585                             case TOK_FS_GT_VDBOX_INFO__ANONYMOUS5662__SFC_SUPPORTED_BITS: {
586                                 const TokenHeader *tokSfcSupportedBits = varLen->getValue<TokenHeader>();
587                                 const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
588                                 while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) {
589                                     if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) {
590                                         switch (tokSfcSupportedBits->id) {
591                                         default:
592                                             if (tokSfcSupportedBits->flags.flag3IsMandatory) {
593                                                 return false;
594                                             }
595                                             break;
596                                         case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX0: {
597                                             dst.SFCSupport.SfcSupportedBits.VDBox0 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox0)>(*tokSfcSupportedBits);
598                                         } break;
599                                         case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX1: {
600                                             dst.SFCSupport.SfcSupportedBits.VDBox1 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox1)>(*tokSfcSupportedBits);
601                                         } break;
602                                         case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX2: {
603                                             dst.SFCSupport.SfcSupportedBits.VDBox2 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox2)>(*tokSfcSupportedBits);
604                                         } break;
605                                         case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX3: {
606                                             dst.SFCSupport.SfcSupportedBits.VDBox3 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox3)>(*tokSfcSupportedBits);
607                                         } break;
608                                         case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX4: {
609                                             dst.SFCSupport.SfcSupportedBits.VDBox4 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox4)>(*tokSfcSupportedBits);
610                                         } break;
611                                         case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX5: {
612                                             dst.SFCSupport.SfcSupportedBits.VDBox5 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox5)>(*tokSfcSupportedBits);
613                                         } break;
614                                         case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX6: {
615                                             dst.SFCSupport.SfcSupportedBits.VDBox6 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox6)>(*tokSfcSupportedBits);
616                                         } break;
617                                         case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX7: {
618                                             dst.SFCSupport.SfcSupportedBits.VDBox7 = readTokValue<decltype(dst.SFCSupport.SfcSupportedBits.VDBox7)>(*tokSfcSupportedBits);
619                                         } break;
620                                         };
621                                         tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount;
622                                     } else {
623                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSfcSupportedBits);
624                                         if (tokSfcSupportedBits->flags.flag3IsMandatory) {
625                                             return false;
626                                         }
627                                         tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
628                                     }
629                                 }
630                                 WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd);
631                             } break;
632                             };
633                             tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
634                         }
635                     }
636                     WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd);
637                 } break;
638                 };
639                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
640             }
641         }
642         WCH_ASSERT(tok == srcTokensEnd);
643         return true;
644     }
645 };
646 
647 template <>
648 struct Demarshaller<TOK_S_GT_CCS_INFO> {
649     template <typename GT_CCS_INFOT>
650     static bool demarshall(GT_CCS_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
651         const TokenHeader *tok = srcTokensBeg;
652         while (tok < srcTokensEnd) {
653             if (false == tok->flags.flag4IsVariableLength) {
654                 switch (tok->id) {
655                 default:
656                     if (tok->flags.flag3IsMandatory) {
657                         return false;
658                     }
659                     break;
660                 case TOK_FBD_GT_CCS_INFO__NUMBER_OF_CCSENABLED: {
661                     dst.NumberOfCCSEnabled = readTokValue<decltype(dst.NumberOfCCSEnabled)>(*tok);
662                 } break;
663                 case TOK_FBB_GT_CCS_INFO__IS_VALID: {
664                     dst.IsValid = readTokValue<decltype(dst.IsValid)>(*tok);
665                 } break;
666                 };
667                 tok = tok + 1 + tok->valueDwordCount;
668             } else {
669                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
670                 switch (tok->id) {
671                 default:
672                     if (tok->flags.flag3IsMandatory) {
673                         return false;
674                     }
675                     break;
676                 case TOK_S_GT_CCS_INFO:
677                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
678                         return false;
679                     }
680                     break;
681                 case TOK_FS_GT_CCS_INFO__INSTANCES: {
682                     const TokenHeader *tokInstances = varLen->getValue<TokenHeader>();
683                     const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
684                     while (tokInstances < tokInstancesEnd) {
685                         if (false == tokInstances->flags.flag4IsVariableLength) {
686                             switch (tokInstances->id) {
687                             default:
688                                 if (tokInstances->flags.flag3IsMandatory) {
689                                     return false;
690                                 }
691                                 break;
692                             case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSENABLE_MASK: {
693                                 dst.Instances.CCSEnableMask = readTokValue<decltype(dst.Instances.CCSEnableMask)>(*tokInstances);
694                             } break;
695                             };
696                             tokInstances = tokInstances + 1 + tokInstances->valueDwordCount;
697                         } else {
698                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances);
699                             switch (tokInstances->id) {
700                             default:
701                                 if (tokInstances->flags.flag3IsMandatory) {
702                                     return false;
703                                 }
704                                 break;
705                             case TOK_FS_GT_CCS_INFO__CCSINSTANCES__BITS: {
706                                 const TokenHeader *tokBits = varLen->getValue<TokenHeader>();
707                                 const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
708                                 while (tokBits < tokBitsEnd) {
709                                     if (false == tokBits->flags.flag4IsVariableLength) {
710                                         switch (tokBits->id) {
711                                         default:
712                                             if (tokBits->flags.flag3IsMandatory) {
713                                                 return false;
714                                             }
715                                             break;
716                                         case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS0ENABLED: {
717                                             dst.Instances.Bits.CCS0Enabled = readTokValue<decltype(dst.Instances.Bits.CCS0Enabled)>(*tokBits);
718                                         } break;
719                                         case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS1ENABLED: {
720                                             dst.Instances.Bits.CCS1Enabled = readTokValue<decltype(dst.Instances.Bits.CCS1Enabled)>(*tokBits);
721                                         } break;
722                                         case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS2ENABLED: {
723                                             dst.Instances.Bits.CCS2Enabled = readTokValue<decltype(dst.Instances.Bits.CCS2Enabled)>(*tokBits);
724                                         } break;
725                                         case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS3ENABLED: {
726                                             dst.Instances.Bits.CCS3Enabled = readTokValue<decltype(dst.Instances.Bits.CCS3Enabled)>(*tokBits);
727                                         } break;
728                                         };
729                                         tokBits = tokBits + 1 + tokBits->valueDwordCount;
730                                     } else {
731                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits);
732                                         if (tokBits->flags.flag3IsMandatory) {
733                                             return false;
734                                         }
735                                         tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
736                                     }
737                                 }
738                                 WCH_ASSERT(tokBits == tokBitsEnd);
739                             } break;
740                             };
741                             tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
742                         }
743                     }
744                     WCH_ASSERT(tokInstances == tokInstancesEnd);
745                 } break;
746                 };
747                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
748             }
749         }
750         WCH_ASSERT(tok == srcTokensEnd);
751         return true;
752     }
753 };
754 
755 template <>
756 struct Demarshaller<TOK_S_GT_MULTI_TILE_ARCH_INFO> {
757     template <typename GT_MULTI_TILE_ARCH_INFOT>
758     static bool demarshall(GT_MULTI_TILE_ARCH_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
759         const TokenHeader *tok = srcTokensBeg;
760         while (tok < srcTokensEnd) {
761             if (false == tok->flags.flag4IsVariableLength) {
762                 switch (tok->id) {
763                 default:
764                     if (tok->flags.flag3IsMandatory) {
765                         return false;
766                     }
767                     break;
768                 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__TILE_COUNT: {
769                     dst.TileCount = readTokValue<decltype(dst.TileCount)>(*tok);
770                 } break;
771                 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE0: {
772                     dst.Tile0 = readTokValue<decltype(dst.Tile0)>(*tok);
773                 } break;
774                 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE1: {
775                     dst.Tile1 = readTokValue<decltype(dst.Tile1)>(*tok);
776                 } break;
777                 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE2: {
778                     dst.Tile2 = readTokValue<decltype(dst.Tile2)>(*tok);
779                 } break;
780                 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE3: {
781                     dst.Tile3 = readTokValue<decltype(dst.Tile3)>(*tok);
782                 } break;
783                 case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__TILE_MASK: {
784                     dst.TileMask = readTokValue<decltype(dst.TileMask)>(*tok);
785                 } break;
786                 case TOK_FBB_GT_MULTI_TILE_ARCH_INFO__IS_VALID: {
787                     dst.IsValid = readTokValue<decltype(dst.IsValid)>(*tok);
788                 } break;
789                 };
790                 tok = tok + 1 + tok->valueDwordCount;
791             } else {
792                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
793                 switch (tok->id) {
794                 default:
795                     if (tok->flags.flag3IsMandatory) {
796                         return false;
797                     }
798                     break;
799                 case TOK_S_GT_MULTI_TILE_ARCH_INFO:
800                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
801                         return false;
802                     }
803                     break;
804                 };
805                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
806             }
807         }
808         WCH_ASSERT(tok == srcTokensEnd);
809         return true;
810     }
811 };
812 
813 template <>
814 struct Demarshaller<TOK_S_GT_SQIDI_INFO> {
815     template <typename GT_SQIDI_INFOT>
816     static bool demarshall(GT_SQIDI_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
817         const TokenHeader *tok = srcTokensBeg;
818         while (tok < srcTokensEnd) {
819             if (false == tok->flags.flag4IsVariableLength) {
820                 switch (tok->id) {
821                 default:
822                     if (tok->flags.flag3IsMandatory) {
823                         return false;
824                     }
825                     break;
826                 case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_SQIDI: {
827                     dst.NumberofSQIDI = readTokValue<decltype(dst.NumberofSQIDI)>(*tok);
828                 } break;
829                 case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_DOORBELL_PER_SQIDI: {
830                     dst.NumberofDoorbellPerSQIDI = readTokValue<decltype(dst.NumberofDoorbellPerSQIDI)>(*tok);
831                 } break;
832                 };
833                 tok = tok + 1 + tok->valueDwordCount;
834             } else {
835                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
836                 switch (tok->id) {
837                 default:
838                     if (tok->flags.flag3IsMandatory) {
839                         return false;
840                     }
841                     break;
842                 case TOK_S_GT_SQIDI_INFO:
843                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
844                         return false;
845                     }
846                     break;
847                 };
848                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
849             }
850         }
851         WCH_ASSERT(tok == srcTokensEnd);
852         return true;
853     }
854 };
855 
856 template <>
857 struct Demarshaller<TOK_S_GT_CACHE_TYPES> {
858     template <typename _GT_CACHE_TYPEST>
859     static bool demarshall(_GT_CACHE_TYPEST &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
860         const TokenHeader *tok = srcTokensBeg;
861         while (tok < srcTokensEnd) {
862             if (false == tok->flags.flag4IsVariableLength) {
863                 switch (tok->id) {
864                 default:
865                     if (tok->flags.flag3IsMandatory) {
866                         return false;
867                     }
868                     break;
869                 case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__L3: {
870                     dst.L3 = readTokValue<decltype(dst.L3)>(*tok);
871                 } break;
872                 case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__LLC: {
873                     dst.LLC = readTokValue<decltype(dst.LLC)>(*tok);
874                 } break;
875                 case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__E_DRAM: {
876                     dst.eDRAM = readTokValue<decltype(dst.eDRAM)>(*tok);
877                 } break;
878                 case TOK_FBD_GT_CACHE_TYPES__CACHE_TYPE_MASK: {
879                     dst.CacheTypeMask = readTokValue<decltype(dst.CacheTypeMask)>(*tok);
880                 } break;
881                 };
882                 tok = tok + 1 + tok->valueDwordCount;
883             } else {
884                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
885                 switch (tok->id) {
886                 default:
887                     if (tok->flags.flag3IsMandatory) {
888                         return false;
889                     }
890                     break;
891                 case TOK_S_GT_CACHE_TYPES:
892                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
893                         return false;
894                     }
895                     break;
896                 };
897                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
898             }
899         }
900         WCH_ASSERT(tok == srcTokensEnd);
901         return true;
902     }
903 };
904 
905 template <>
906 struct Demarshaller<TOK_S_GT_SYSTEM_INFO> {
907     template <typename GT_SYSTEM_INFOT>
908     static bool demarshall(GT_SYSTEM_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
909         const TokenHeader *tok = srcTokensBeg;
910         while (tok < srcTokensEnd) {
911             if (false == tok->flags.flag4IsVariableLength) {
912                 switch (tok->id) {
913                 default:
914                     if (tok->flags.flag3IsMandatory) {
915                         return false;
916                     }
917                     break;
918                 case TOK_FBD_GT_SYSTEM_INFO__EUCOUNT: {
919                     dst.EUCount = readTokValue<decltype(dst.EUCount)>(*tok);
920                 } break;
921                 case TOK_FBD_GT_SYSTEM_INFO__THREAD_COUNT: {
922                     dst.ThreadCount = readTokValue<decltype(dst.ThreadCount)>(*tok);
923                 } break;
924                 case TOK_FBD_GT_SYSTEM_INFO__SLICE_COUNT: {
925                     dst.SliceCount = readTokValue<decltype(dst.SliceCount)>(*tok);
926                 } break;
927                 case TOK_FBD_GT_SYSTEM_INFO__SUB_SLICE_COUNT: {
928                     dst.SubSliceCount = readTokValue<decltype(dst.SubSliceCount)>(*tok);
929                 } break;
930                 case TOK_FBD_GT_SYSTEM_INFO__DUAL_SUB_SLICE_COUNT: {
931                     dst.DualSubSliceCount = readTokValue<decltype(dst.DualSubSliceCount)>(*tok);
932                 } break;
933                 case TOK_FBQ_GT_SYSTEM_INFO__L3CACHE_SIZE_IN_KB: {
934                     dst.L3CacheSizeInKb = readTokValue<decltype(dst.L3CacheSizeInKb)>(*tok);
935                 } break;
936                 case TOK_FBQ_GT_SYSTEM_INFO__LLCCACHE_SIZE_IN_KB: {
937                     dst.LLCCacheSizeInKb = readTokValue<decltype(dst.LLCCacheSizeInKb)>(*tok);
938                 } break;
939                 case TOK_FBQ_GT_SYSTEM_INFO__EDRAM_SIZE_IN_KB: {
940                     dst.EdramSizeInKb = readTokValue<decltype(dst.EdramSizeInKb)>(*tok);
941                 } break;
942                 case TOK_FBD_GT_SYSTEM_INFO__L3BANK_COUNT: {
943                     dst.L3BankCount = readTokValue<decltype(dst.L3BankCount)>(*tok);
944                 } break;
945                 case TOK_FBD_GT_SYSTEM_INFO__MAX_FILL_RATE: {
946                     dst.MaxFillRate = readTokValue<decltype(dst.MaxFillRate)>(*tok);
947                 } break;
948                 case TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MAX: {
949                     dst.EuCountPerPoolMax = readTokValue<decltype(dst.EuCountPerPoolMax)>(*tok);
950                 } break;
951                 case TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MIN: {
952                     dst.EuCountPerPoolMin = readTokValue<decltype(dst.EuCountPerPoolMin)>(*tok);
953                 } break;
954                 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS: {
955                     dst.TotalVsThreads = readTokValue<decltype(dst.TotalVsThreads)>(*tok);
956                 } break;
957                 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_HS_THREADS: {
958                     dst.TotalHsThreads = readTokValue<decltype(dst.TotalHsThreads)>(*tok);
959                 } break;
960                 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_DS_THREADS: {
961                     dst.TotalDsThreads = readTokValue<decltype(dst.TotalDsThreads)>(*tok);
962                 } break;
963                 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_GS_THREADS: {
964                     dst.TotalGsThreads = readTokValue<decltype(dst.TotalGsThreads)>(*tok);
965                 } break;
966                 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_PS_THREADS_WINDOWER_RANGE: {
967                     dst.TotalPsThreadsWindowerRange = readTokValue<decltype(dst.TotalPsThreadsWindowerRange)>(*tok);
968                 } break;
969                 case TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS_POCS: {
970                     dst.TotalVsThreads_Pocs = readTokValue<decltype(dst.TotalVsThreads_Pocs)>(*tok);
971                 } break;
972                 case TOK_FBD_GT_SYSTEM_INFO__CSR_SIZE_IN_MB: {
973                     dst.CsrSizeInMb = readTokValue<decltype(dst.CsrSizeInMb)>(*tok);
974                 } break;
975                 case TOK_FBD_GT_SYSTEM_INFO__MAX_EU_PER_SUB_SLICE: {
976                     dst.MaxEuPerSubSlice = readTokValue<decltype(dst.MaxEuPerSubSlice)>(*tok);
977                 } break;
978                 case TOK_FBD_GT_SYSTEM_INFO__MAX_SLICES_SUPPORTED: {
979                     dst.MaxSlicesSupported = readTokValue<decltype(dst.MaxSlicesSupported)>(*tok);
980                 } break;
981                 case TOK_FBD_GT_SYSTEM_INFO__MAX_SUB_SLICES_SUPPORTED: {
982                     dst.MaxSubSlicesSupported = readTokValue<decltype(dst.MaxSubSlicesSupported)>(*tok);
983                 } break;
984                 case TOK_FBD_GT_SYSTEM_INFO__MAX_DUAL_SUB_SLICES_SUPPORTED: {
985                     dst.MaxDualSubSlicesSupported = readTokValue<decltype(dst.MaxDualSubSlicesSupported)>(*tok);
986                 } break;
987                 case TOK_FBB_GT_SYSTEM_INFO__IS_L3HASH_MODE_ENABLED: {
988                     dst.IsL3HashModeEnabled = readTokValue<decltype(dst.IsL3HashModeEnabled)>(*tok);
989                 } break;
990                 case TOK_FBB_GT_SYSTEM_INFO__IS_DYNAMICALLY_POPULATED: {
991                     dst.IsDynamicallyPopulated = readTokValue<decltype(dst.IsDynamicallyPopulated)>(*tok);
992                 } break;
993                 case TOK_FBD_GT_SYSTEM_INFO__RESERVED_CCSWAYS: {
994                     dst.ReservedCCSWays = readTokValue<decltype(dst.ReservedCCSWays)>(*tok);
995                 } break;
996                 case TOK_FBD_GT_SYSTEM_INFO__NUM_THREADS_PER_EU: {
997                     dst.NumThreadsPerEu = readTokValue<decltype(dst.NumThreadsPerEu)>(*tok);
998                 } break;
999                 case TOK_FBD_GT_SYSTEM_INFO__MAX_VECS: {
1000                     dst.MaxVECS = readTokValue<decltype(dst.MaxVECS)>(*tok);
1001                 } break;
1002                 };
1003                 tok = tok + 1 + tok->valueDwordCount;
1004             } else {
1005                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
1006                 switch (tok->id) {
1007                 default:
1008                     if (tok->flags.flag3IsMandatory) {
1009                         return false;
1010                     }
1011                     break;
1012                 case TOK_S_GT_SYSTEM_INFO:
1013                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
1014                         return false;
1015                     }
1016                     break;
1017                 case TOK_FS_GT_SYSTEM_INFO__SLICE_INFO: {
1018                     uint32_t arrayElementIdSliceInfo = varLen->arrayElementId;
1019                     const TokenHeader *tokSliceInfo = varLen->getValue<TokenHeader>();
1020                     const TokenHeader *tokSliceInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1021                     static constexpr auto maxDstSlicesInfo = sizeof(dst.SystemInfo.SliceInfo) / sizeof(dst.SystemInfo.SliceInfo[0]);
1022                     if (arrayElementIdSliceInfo >= maxDstSlicesInfo) {
1023                         tokSliceInfo = tokSliceInfoEnd;
1024                     }
1025                     while (tokSliceInfo < tokSliceInfoEnd) {
1026                         if (false == tokSliceInfo->flags.flag4IsVariableLength) {
1027                             switch (tokSliceInfo->id) {
1028                             default:
1029                                 if (tokSliceInfo->flags.flag3IsMandatory) {
1030                                     return false;
1031                                 }
1032                                 break;
1033                             case TOK_FBB_GT_SLICE_INFO__ENABLED: {
1034                                 dst.SliceInfo[arrayElementIdSliceInfo].Enabled = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].Enabled)>(*tokSliceInfo);
1035                             } break;
1036                             case TOK_FBD_GT_SLICE_INFO__SUB_SLICE_ENABLED_COUNT: {
1037                                 dst.SliceInfo[arrayElementIdSliceInfo].SubSliceEnabledCount = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].SubSliceEnabledCount)>(*tokSliceInfo);
1038                             } break;
1039                             case TOK_FBD_GT_SLICE_INFO__DUAL_SUB_SLICE_ENABLED_COUNT: {
1040                                 dst.SliceInfo[arrayElementIdSliceInfo].DualSubSliceEnabledCount = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].DualSubSliceEnabledCount)>(*tokSliceInfo);
1041                             } break;
1042                             };
1043                             tokSliceInfo = tokSliceInfo + 1 + tokSliceInfo->valueDwordCount;
1044                         } else {
1045                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSliceInfo);
1046                             switch (tokSliceInfo->id) {
1047                             default:
1048                                 if (tokSliceInfo->flags.flag3IsMandatory) {
1049                                     return false;
1050                                 }
1051                                 break;
1052                             case TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO: {
1053                                 uint32_t arrayElementIdSubSliceInfo = varLen->arrayElementId;
1054                                 const TokenHeader *tokSubSliceInfo = varLen->getValue<TokenHeader>();
1055                                 const TokenHeader *tokSubSliceInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1056                                 while (tokSubSliceInfo < tokSubSliceInfoEnd) {
1057                                     if (false == tokSubSliceInfo->flags.flag4IsVariableLength) {
1058                                         switch (tokSubSliceInfo->id) {
1059                                         default:
1060                                             if (tokSubSliceInfo->flags.flag3IsMandatory) {
1061                                                 return false;
1062                                             }
1063                                             break;
1064                                         case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: {
1065                                             dst.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].Enabled = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].Enabled)>(*tokSubSliceInfo);
1066                                         } break;
1067                                         case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: {
1068                                             dst.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledCount = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledCount)>(*tokSubSliceInfo);
1069                                         } break;
1070                                         case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: {
1071                                             dst.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledMask = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledMask)>(*tokSubSliceInfo);
1072                                         } break;
1073                                         };
1074                                         tokSubSliceInfo = tokSubSliceInfo + 1 + tokSubSliceInfo->valueDwordCount;
1075                                     } else {
1076                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSubSliceInfo);
1077                                         if (tokSubSliceInfo->flags.flag3IsMandatory) {
1078                                             return false;
1079                                         }
1080                                         tokSubSliceInfo = tokSubSliceInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1081                                     }
1082                                 }
1083                                 WCH_ASSERT(tokSubSliceInfo == tokSubSliceInfoEnd);
1084                             } break;
1085                             case TOK_FS_GT_SLICE_INFO__DSSINFO: {
1086                                 uint32_t arrayElementIdDSSInfo = varLen->arrayElementId;
1087                                 const TokenHeader *tokDSSInfo = varLen->getValue<TokenHeader>();
1088                                 const TokenHeader *tokDSSInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1089                                 while (tokDSSInfo < tokDSSInfoEnd) {
1090                                     if (false == tokDSSInfo->flags.flag4IsVariableLength) {
1091                                         switch (tokDSSInfo->id) {
1092                                         default:
1093                                             if (tokDSSInfo->flags.flag3IsMandatory) {
1094                                                 return false;
1095                                             }
1096                                             break;
1097                                         case TOK_FBB_GT_DUALSUBSLICE_INFO__ENABLED: {
1098                                             dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].Enabled = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].Enabled)>(*tokDSSInfo);
1099                                         } break;
1100                                         };
1101                                         tokDSSInfo = tokDSSInfo + 1 + tokDSSInfo->valueDwordCount;
1102                                     } else {
1103                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokDSSInfo);
1104                                         switch (tokDSSInfo->id) {
1105                                         default:
1106                                             if (tokDSSInfo->flags.flag3IsMandatory) {
1107                                                 return false;
1108                                             }
1109                                             break;
1110                                         case TOK_FS_GT_DUALSUBSLICE_INFO__SUB_SLICE: {
1111                                             uint32_t arrayElementIdSubSlice = varLen->arrayElementId;
1112                                             const TokenHeader *tokSubSlice = varLen->getValue<TokenHeader>();
1113                                             const TokenHeader *tokSubSliceEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1114                                             while (tokSubSlice < tokSubSliceEnd) {
1115                                                 if (false == tokSubSlice->flags.flag4IsVariableLength) {
1116                                                     switch (tokSubSlice->id) {
1117                                                     default:
1118                                                         if (tokSubSlice->flags.flag3IsMandatory) {
1119                                                             return false;
1120                                                         }
1121                                                         break;
1122                                                     case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: {
1123                                                         dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].Enabled = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].Enabled)>(*tokSubSlice);
1124                                                     } break;
1125                                                     case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: {
1126                                                         dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledCount = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledCount)>(*tokSubSlice);
1127                                                     } break;
1128                                                     case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: {
1129                                                         dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledMask = readTokValue<decltype(dst.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledMask)>(*tokSubSlice);
1130                                                     } break;
1131                                                     };
1132                                                     tokSubSlice = tokSubSlice + 1 + tokSubSlice->valueDwordCount;
1133                                                 } else {
1134                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSubSlice);
1135                                                     if (tokSubSlice->flags.flag3IsMandatory) {
1136                                                         return false;
1137                                                     }
1138                                                     tokSubSlice = tokSubSlice + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1139                                                 }
1140                                             }
1141                                             WCH_ASSERT(tokSubSlice == tokSubSliceEnd);
1142                                         } break;
1143                                         };
1144                                         tokDSSInfo = tokDSSInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1145                                     }
1146                                 }
1147                                 WCH_ASSERT(tokDSSInfo == tokDSSInfoEnd);
1148                             } break;
1149                             };
1150                             tokSliceInfo = tokSliceInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1151                         }
1152                     }
1153                     WCH_ASSERT(tokSliceInfo == tokSliceInfoEnd);
1154                 } break;
1155                 case TOK_FS_GT_SYSTEM_INFO__SQIDI_INFO: {
1156                     const TokenHeader *tokSqidiInfo = varLen->getValue<TokenHeader>();
1157                     const TokenHeader *tokSqidiInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1158                     while (tokSqidiInfo < tokSqidiInfoEnd) {
1159                         if (false == tokSqidiInfo->flags.flag4IsVariableLength) {
1160                             switch (tokSqidiInfo->id) {
1161                             default:
1162                                 if (tokSqidiInfo->flags.flag3IsMandatory) {
1163                                     return false;
1164                                 }
1165                                 break;
1166                             case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_SQIDI: {
1167                                 dst.SqidiInfo.NumberofSQIDI = readTokValue<decltype(dst.SqidiInfo.NumberofSQIDI)>(*tokSqidiInfo);
1168                             } break;
1169                             case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_DOORBELL_PER_SQIDI: {
1170                                 dst.SqidiInfo.NumberofDoorbellPerSQIDI = readTokValue<decltype(dst.SqidiInfo.NumberofDoorbellPerSQIDI)>(*tokSqidiInfo);
1171                             } break;
1172                             };
1173                             tokSqidiInfo = tokSqidiInfo + 1 + tokSqidiInfo->valueDwordCount;
1174                         } else {
1175                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSqidiInfo);
1176                             if (tokSqidiInfo->flags.flag3IsMandatory) {
1177                                 return false;
1178                             }
1179                             tokSqidiInfo = tokSqidiInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1180                         }
1181                     }
1182                     WCH_ASSERT(tokSqidiInfo == tokSqidiInfoEnd);
1183                 } break;
1184                 case TOK_FS_GT_SYSTEM_INFO__CCSINFO: {
1185                     const TokenHeader *tokCCSInfo = varLen->getValue<TokenHeader>();
1186                     const TokenHeader *tokCCSInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1187                     while (tokCCSInfo < tokCCSInfoEnd) {
1188                         if (false == tokCCSInfo->flags.flag4IsVariableLength) {
1189                             switch (tokCCSInfo->id) {
1190                             default:
1191                                 if (tokCCSInfo->flags.flag3IsMandatory) {
1192                                     return false;
1193                                 }
1194                                 break;
1195                             case TOK_FBD_GT_CCS_INFO__NUMBER_OF_CCSENABLED: {
1196                                 dst.CCSInfo.NumberOfCCSEnabled = readTokValue<decltype(dst.CCSInfo.NumberOfCCSEnabled)>(*tokCCSInfo);
1197                             } break;
1198                             case TOK_FBB_GT_CCS_INFO__IS_VALID: {
1199                                 dst.CCSInfo.IsValid = readTokValue<decltype(dst.CCSInfo.IsValid)>(*tokCCSInfo);
1200                             } break;
1201                             };
1202                             tokCCSInfo = tokCCSInfo + 1 + tokCCSInfo->valueDwordCount;
1203                         } else {
1204                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCCSInfo);
1205                             switch (tokCCSInfo->id) {
1206                             default:
1207                                 if (tokCCSInfo->flags.flag3IsMandatory) {
1208                                     return false;
1209                                 }
1210                                 break;
1211                             case TOK_FS_GT_CCS_INFO__INSTANCES: {
1212                                 const TokenHeader *tokInstances = varLen->getValue<TokenHeader>();
1213                                 const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1214                                 while (tokInstances < tokInstancesEnd) {
1215                                     if (false == tokInstances->flags.flag4IsVariableLength) {
1216                                         switch (tokInstances->id) {
1217                                         default:
1218                                             if (tokInstances->flags.flag3IsMandatory) {
1219                                                 return false;
1220                                             }
1221                                             break;
1222                                         case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSENABLE_MASK: {
1223                                             dst.CCSInfo.Instances.CCSEnableMask = readTokValue<decltype(dst.CCSInfo.Instances.CCSEnableMask)>(*tokInstances);
1224                                         } break;
1225                                         };
1226                                         tokInstances = tokInstances + 1 + tokInstances->valueDwordCount;
1227                                     } else {
1228                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances);
1229                                         switch (tokInstances->id) {
1230                                         default:
1231                                             if (tokInstances->flags.flag3IsMandatory) {
1232                                                 return false;
1233                                             }
1234                                             break;
1235                                         case TOK_FS_GT_CCS_INFO__CCSINSTANCES__BITS: {
1236                                             const TokenHeader *tokBits = varLen->getValue<TokenHeader>();
1237                                             const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1238                                             while (tokBits < tokBitsEnd) {
1239                                                 if (false == tokBits->flags.flag4IsVariableLength) {
1240                                                     switch (tokBits->id) {
1241                                                     default:
1242                                                         if (tokBits->flags.flag3IsMandatory) {
1243                                                             return false;
1244                                                         }
1245                                                         break;
1246                                                     case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS0ENABLED: {
1247                                                         dst.CCSInfo.Instances.Bits.CCS0Enabled = readTokValue<decltype(dst.CCSInfo.Instances.Bits.CCS0Enabled)>(*tokBits);
1248                                                     } break;
1249                                                     case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS1ENABLED: {
1250                                                         dst.CCSInfo.Instances.Bits.CCS1Enabled = readTokValue<decltype(dst.CCSInfo.Instances.Bits.CCS1Enabled)>(*tokBits);
1251                                                     } break;
1252                                                     case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS2ENABLED: {
1253                                                         dst.CCSInfo.Instances.Bits.CCS2Enabled = readTokValue<decltype(dst.CCSInfo.Instances.Bits.CCS2Enabled)>(*tokBits);
1254                                                     } break;
1255                                                     case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS3ENABLED: {
1256                                                         dst.CCSInfo.Instances.Bits.CCS3Enabled = readTokValue<decltype(dst.CCSInfo.Instances.Bits.CCS3Enabled)>(*tokBits);
1257                                                     } break;
1258                                                     };
1259                                                     tokBits = tokBits + 1 + tokBits->valueDwordCount;
1260                                                 } else {
1261                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits);
1262                                                     if (tokBits->flags.flag3IsMandatory) {
1263                                                         return false;
1264                                                     }
1265                                                     tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1266                                                 }
1267                                             }
1268                                             WCH_ASSERT(tokBits == tokBitsEnd);
1269                                         } break;
1270                                         };
1271                                         tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1272                                     }
1273                                 }
1274                                 WCH_ASSERT(tokInstances == tokInstancesEnd);
1275                             } break;
1276                             };
1277                             tokCCSInfo = tokCCSInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1278                         }
1279                     }
1280                     WCH_ASSERT(tokCCSInfo == tokCCSInfoEnd);
1281                 } break;
1282                 case TOK_FS_GT_SYSTEM_INFO__MULTI_TILE_ARCH_INFO: {
1283                     const TokenHeader *tokMultiTileArchInfo = varLen->getValue<TokenHeader>();
1284                     const TokenHeader *tokMultiTileArchInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1285                     while (tokMultiTileArchInfo < tokMultiTileArchInfoEnd) {
1286                         if (false == tokMultiTileArchInfo->flags.flag4IsVariableLength) {
1287                             switch (tokMultiTileArchInfo->id) {
1288                             default:
1289                                 if (tokMultiTileArchInfo->flags.flag3IsMandatory) {
1290                                     return false;
1291                                 }
1292                                 break;
1293                             case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__TILE_COUNT: {
1294                                 dst.MultiTileArchInfo.TileCount = readTokValue<decltype(dst.MultiTileArchInfo.TileCount)>(*tokMultiTileArchInfo);
1295                             } break;
1296                             case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE0: {
1297                                 dst.MultiTileArchInfo.Tile0 = readTokValue<decltype(dst.MultiTileArchInfo.Tile0)>(*tokMultiTileArchInfo);
1298                             } break;
1299                             case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE1: {
1300                                 dst.MultiTileArchInfo.Tile1 = readTokValue<decltype(dst.MultiTileArchInfo.Tile1)>(*tokMultiTileArchInfo);
1301                             } break;
1302                             case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE2: {
1303                                 dst.MultiTileArchInfo.Tile2 = readTokValue<decltype(dst.MultiTileArchInfo.Tile2)>(*tokMultiTileArchInfo);
1304                             } break;
1305                             case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE3: {
1306                                 dst.MultiTileArchInfo.Tile3 = readTokValue<decltype(dst.MultiTileArchInfo.Tile3)>(*tokMultiTileArchInfo);
1307                             } break;
1308                             case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__TILE_MASK: {
1309                                 dst.MultiTileArchInfo.TileMask = readTokValue<decltype(dst.MultiTileArchInfo.TileMask)>(*tokMultiTileArchInfo);
1310                             } break;
1311                             case TOK_FBB_GT_MULTI_TILE_ARCH_INFO__IS_VALID: {
1312                                 dst.MultiTileArchInfo.IsValid = readTokValue<decltype(dst.MultiTileArchInfo.IsValid)>(*tokMultiTileArchInfo);
1313                             } break;
1314                             };
1315                             tokMultiTileArchInfo = tokMultiTileArchInfo + 1 + tokMultiTileArchInfo->valueDwordCount;
1316                         } else {
1317                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMultiTileArchInfo);
1318                             if (tokMultiTileArchInfo->flags.flag3IsMandatory) {
1319                                 return false;
1320                             }
1321                             tokMultiTileArchInfo = tokMultiTileArchInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1322                         }
1323                     }
1324                     WCH_ASSERT(tokMultiTileArchInfo == tokMultiTileArchInfoEnd);
1325                 } break;
1326                 case TOK_FS_GT_SYSTEM_INFO__VDBOX_INFO: {
1327                     const TokenHeader *tokVDBoxInfo = varLen->getValue<TokenHeader>();
1328                     const TokenHeader *tokVDBoxInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1329                     while (tokVDBoxInfo < tokVDBoxInfoEnd) {
1330                         if (false == tokVDBoxInfo->flags.flag4IsVariableLength) {
1331                             switch (tokVDBoxInfo->id) {
1332                             default:
1333                                 if (tokVDBoxInfo->flags.flag3IsMandatory) {
1334                                     return false;
1335                                 }
1336                                 break;
1337                             case TOK_FBD_GT_VDBOX_INFO__NUMBER_OF_VDBOX_ENABLED: {
1338                                 dst.VDBoxInfo.NumberOfVDBoxEnabled = readTokValue<decltype(dst.VDBoxInfo.NumberOfVDBoxEnabled)>(*tokVDBoxInfo);
1339                             } break;
1340                             case TOK_FBB_GT_VDBOX_INFO__IS_VALID: {
1341                                 dst.VDBoxInfo.IsValid = readTokValue<decltype(dst.VDBoxInfo.IsValid)>(*tokVDBoxInfo);
1342                             } break;
1343                             };
1344                             tokVDBoxInfo = tokVDBoxInfo + 1 + tokVDBoxInfo->valueDwordCount;
1345                         } else {
1346                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokVDBoxInfo);
1347                             switch (tokVDBoxInfo->id) {
1348                             default:
1349                                 if (tokVDBoxInfo->flags.flag3IsMandatory) {
1350                                     return false;
1351                                 }
1352                                 break;
1353                             case TOK_FS_GT_VDBOX_INFO__INSTANCES: {
1354                                 const TokenHeader *tokInstances = varLen->getValue<TokenHeader>();
1355                                 const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1356                                 while (tokInstances < tokInstancesEnd) {
1357                                     if (false == tokInstances->flags.flag4IsVariableLength) {
1358                                         switch (tokInstances->id) {
1359                                         default:
1360                                             if (tokInstances->flags.flag3IsMandatory) {
1361                                                 return false;
1362                                             }
1363                                             break;
1364                                         case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBOX_ENABLE_MASK: {
1365                                             dst.VDBoxInfo.Instances.VDBoxEnableMask = readTokValue<decltype(dst.VDBoxInfo.Instances.VDBoxEnableMask)>(*tokInstances);
1366                                         } break;
1367                                         };
1368                                         tokInstances = tokInstances + 1 + tokInstances->valueDwordCount;
1369                                     } else {
1370                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances);
1371                                         switch (tokInstances->id) {
1372                                         default:
1373                                             if (tokInstances->flags.flag3IsMandatory) {
1374                                                 return false;
1375                                             }
1376                                             break;
1377                                         case TOK_FS_GT_VDBOX_INFO__VDBOX_INSTANCES__BITS: {
1378                                             const TokenHeader *tokBits = varLen->getValue<TokenHeader>();
1379                                             const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1380                                             while (tokBits < tokBitsEnd) {
1381                                                 if (false == tokBits->flags.flag4IsVariableLength) {
1382                                                     switch (tokBits->id) {
1383                                                     default:
1384                                                         if (tokBits->flags.flag3IsMandatory) {
1385                                                             return false;
1386                                                         }
1387                                                         break;
1388                                                     case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX0ENABLED: {
1389                                                         dst.VDBoxInfo.Instances.Bits.VDBox0Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox0Enabled)>(*tokBits);
1390                                                     } break;
1391                                                     case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX1ENABLED: {
1392                                                         dst.VDBoxInfo.Instances.Bits.VDBox1Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox1Enabled)>(*tokBits);
1393                                                     } break;
1394                                                     case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX2ENABLED: {
1395                                                         dst.VDBoxInfo.Instances.Bits.VDBox2Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox2Enabled)>(*tokBits);
1396                                                     } break;
1397                                                     case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX3ENABLED: {
1398                                                         dst.VDBoxInfo.Instances.Bits.VDBox3Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox3Enabled)>(*tokBits);
1399                                                     } break;
1400                                                     case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX4ENABLED: {
1401                                                         dst.VDBoxInfo.Instances.Bits.VDBox4Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox4Enabled)>(*tokBits);
1402                                                     } break;
1403                                                     case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX5ENABLED: {
1404                                                         dst.VDBoxInfo.Instances.Bits.VDBox5Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox5Enabled)>(*tokBits);
1405                                                     } break;
1406                                                     case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX6ENABLED: {
1407                                                         dst.VDBoxInfo.Instances.Bits.VDBox6Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox6Enabled)>(*tokBits);
1408                                                     } break;
1409                                                     case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX7ENABLED: {
1410                                                         dst.VDBoxInfo.Instances.Bits.VDBox7Enabled = readTokValue<decltype(dst.VDBoxInfo.Instances.Bits.VDBox7Enabled)>(*tokBits);
1411                                                     } break;
1412                                                     };
1413                                                     tokBits = tokBits + 1 + tokBits->valueDwordCount;
1414                                                 } else {
1415                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits);
1416                                                     if (tokBits->flags.flag3IsMandatory) {
1417                                                         return false;
1418                                                     }
1419                                                     tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1420                                                 }
1421                                             }
1422                                             WCH_ASSERT(tokBits == tokBitsEnd);
1423                                         } break;
1424                                         };
1425                                         tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1426                                     }
1427                                 }
1428                                 WCH_ASSERT(tokInstances == tokInstancesEnd);
1429                             } break;
1430                             case TOK_FS_GT_VDBOX_INFO__SFCSUPPORT: {
1431                                 const TokenHeader *tokSFCSupport = varLen->getValue<TokenHeader>();
1432                                 const TokenHeader *tokSFCSupportEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1433                                 while (tokSFCSupport < tokSFCSupportEnd) {
1434                                     if (false == tokSFCSupport->flags.flag4IsVariableLength) {
1435                                         switch (tokSFCSupport->id) {
1436                                         default:
1437                                             if (tokSFCSupport->flags.flag3IsMandatory) {
1438                                                 return false;
1439                                             }
1440                                             break;
1441                                         case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__VALUE: {
1442                                             dst.VDBoxInfo.SFCSupport.Value = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.Value)>(*tokSFCSupport);
1443                                         } break;
1444                                         };
1445                                         tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount;
1446                                     } else {
1447                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSFCSupport);
1448                                         switch (tokSFCSupport->id) {
1449                                         default:
1450                                             if (tokSFCSupport->flags.flag3IsMandatory) {
1451                                                 return false;
1452                                             }
1453                                             break;
1454                                         case TOK_FS_GT_VDBOX_INFO__ANONYMOUS5662__SFC_SUPPORTED_BITS: {
1455                                             const TokenHeader *tokSfcSupportedBits = varLen->getValue<TokenHeader>();
1456                                             const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1457                                             while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) {
1458                                                 if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) {
1459                                                     switch (tokSfcSupportedBits->id) {
1460                                                     default:
1461                                                         if (tokSfcSupportedBits->flags.flag3IsMandatory) {
1462                                                             return false;
1463                                                         }
1464                                                         break;
1465                                                     case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX0: {
1466                                                         dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox0 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox0)>(*tokSfcSupportedBits);
1467                                                     } break;
1468                                                     case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX1: {
1469                                                         dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox1 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox1)>(*tokSfcSupportedBits);
1470                                                     } break;
1471                                                     case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX2: {
1472                                                         dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox2 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox2)>(*tokSfcSupportedBits);
1473                                                     } break;
1474                                                     case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX3: {
1475                                                         dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox3 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox3)>(*tokSfcSupportedBits);
1476                                                     } break;
1477                                                     case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX4: {
1478                                                         dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox4 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox4)>(*tokSfcSupportedBits);
1479                                                     } break;
1480                                                     case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX5: {
1481                                                         dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox5 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox5)>(*tokSfcSupportedBits);
1482                                                     } break;
1483                                                     case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX6: {
1484                                                         dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox6 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox6)>(*tokSfcSupportedBits);
1485                                                     } break;
1486                                                     case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX7: {
1487                                                         dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox7 = readTokValue<decltype(dst.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox7)>(*tokSfcSupportedBits);
1488                                                     } break;
1489                                                     };
1490                                                     tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount;
1491                                                 } else {
1492                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSfcSupportedBits);
1493                                                     if (tokSfcSupportedBits->flags.flag3IsMandatory) {
1494                                                         return false;
1495                                                     }
1496                                                     tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1497                                                 }
1498                                             }
1499                                             WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd);
1500                                         } break;
1501                                         };
1502                                         tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1503                                     }
1504                                 }
1505                                 WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd);
1506                             } break;
1507                             };
1508                             tokVDBoxInfo = tokVDBoxInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1509                         }
1510                     }
1511                     WCH_ASSERT(tokVDBoxInfo == tokVDBoxInfoEnd);
1512                 } break;
1513                 case TOK_FS_GT_SYSTEM_INFO__VEBOX_INFO: {
1514                     const TokenHeader *tokVEBoxInfo = varLen->getValue<TokenHeader>();
1515                     const TokenHeader *tokVEBoxInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1516                     while (tokVEBoxInfo < tokVEBoxInfoEnd) {
1517                         if (false == tokVEBoxInfo->flags.flag4IsVariableLength) {
1518                             switch (tokVEBoxInfo->id) {
1519                             default:
1520                                 if (tokVEBoxInfo->flags.flag3IsMandatory) {
1521                                     return false;
1522                                 }
1523                                 break;
1524                             case TOK_FBD_GT_VEBOX_INFO__NUMBER_OF_VEBOX_ENABLED: {
1525                                 dst.VEBoxInfo.NumberOfVEBoxEnabled = readTokValue<decltype(dst.VEBoxInfo.NumberOfVEBoxEnabled)>(*tokVEBoxInfo);
1526                             } break;
1527                             case TOK_FBB_GT_VEBOX_INFO__IS_VALID: {
1528                                 dst.VEBoxInfo.IsValid = readTokValue<decltype(dst.VEBoxInfo.IsValid)>(*tokVEBoxInfo);
1529                             } break;
1530                             };
1531                             tokVEBoxInfo = tokVEBoxInfo + 1 + tokVEBoxInfo->valueDwordCount;
1532                         } else {
1533                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokVEBoxInfo);
1534                             switch (tokVEBoxInfo->id) {
1535                             default:
1536                                 if (tokVEBoxInfo->flags.flag3IsMandatory) {
1537                                     return false;
1538                                 }
1539                                 break;
1540                             case TOK_FS_GT_VEBOX_INFO__INSTANCES: {
1541                                 const TokenHeader *tokInstances = varLen->getValue<TokenHeader>();
1542                                 const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1543                                 while (tokInstances < tokInstancesEnd) {
1544                                     if (false == tokInstances->flags.flag4IsVariableLength) {
1545                                         switch (tokInstances->id) {
1546                                         default:
1547                                             if (tokInstances->flags.flag3IsMandatory) {
1548                                                 return false;
1549                                             }
1550                                             break;
1551                                         case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBOX_ENABLE_MASK: {
1552                                             dst.VEBoxInfo.Instances.VEBoxEnableMask = readTokValue<decltype(dst.VEBoxInfo.Instances.VEBoxEnableMask)>(*tokInstances);
1553                                         } break;
1554                                         };
1555                                         tokInstances = tokInstances + 1 + tokInstances->valueDwordCount;
1556                                     } else {
1557                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances);
1558                                         switch (tokInstances->id) {
1559                                         default:
1560                                             if (tokInstances->flags.flag3IsMandatory) {
1561                                                 return false;
1562                                             }
1563                                             break;
1564                                         case TOK_FS_GT_VEBOX_INFO__VEBOX_INSTANCES__BITS: {
1565                                             const TokenHeader *tokBits = varLen->getValue<TokenHeader>();
1566                                             const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1567                                             while (tokBits < tokBitsEnd) {
1568                                                 if (false == tokBits->flags.flag4IsVariableLength) {
1569                                                     switch (tokBits->id) {
1570                                                     default:
1571                                                         if (tokBits->flags.flag3IsMandatory) {
1572                                                             return false;
1573                                                         }
1574                                                         break;
1575                                                     case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX0ENABLED: {
1576                                                         dst.VEBoxInfo.Instances.Bits.VEBox0Enabled = readTokValue<decltype(dst.VEBoxInfo.Instances.Bits.VEBox0Enabled)>(*tokBits);
1577                                                     } break;
1578                                                     case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX1ENABLED: {
1579                                                         dst.VEBoxInfo.Instances.Bits.VEBox1Enabled = readTokValue<decltype(dst.VEBoxInfo.Instances.Bits.VEBox1Enabled)>(*tokBits);
1580                                                     } break;
1581                                                     case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX2ENABLED: {
1582                                                         dst.VEBoxInfo.Instances.Bits.VEBox2Enabled = readTokValue<decltype(dst.VEBoxInfo.Instances.Bits.VEBox2Enabled)>(*tokBits);
1583                                                     } break;
1584                                                     case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX3ENABLED: {
1585                                                         dst.VEBoxInfo.Instances.Bits.VEBox3Enabled = readTokValue<decltype(dst.VEBoxInfo.Instances.Bits.VEBox3Enabled)>(*tokBits);
1586                                                     } break;
1587                                                     };
1588                                                     tokBits = tokBits + 1 + tokBits->valueDwordCount;
1589                                                 } else {
1590                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits);
1591                                                     if (tokBits->flags.flag3IsMandatory) {
1592                                                         return false;
1593                                                     }
1594                                                     tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1595                                                 }
1596                                             }
1597                                             WCH_ASSERT(tokBits == tokBitsEnd);
1598                                         } break;
1599                                         };
1600                                         tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1601                                     }
1602                                 }
1603                                 WCH_ASSERT(tokInstances == tokInstancesEnd);
1604                             } break;
1605                             case TOK_FS_GT_VEBOX_INFO__SFCSUPPORT: {
1606                                 const TokenHeader *tokSFCSupport = varLen->getValue<TokenHeader>();
1607                                 const TokenHeader *tokSFCSupportEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1608                                 while (tokSFCSupport < tokSFCSupportEnd) {
1609                                     if (false == tokSFCSupport->flags.flag4IsVariableLength) {
1610                                         switch (tokSFCSupport->id) {
1611                                         default:
1612                                             if (tokSFCSupport->flags.flag3IsMandatory) {
1613                                                 return false;
1614                                             }
1615                                             break;
1616                                         case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__VALUE: {
1617                                             dst.VEBoxInfo.SFCSupport.Value = readTokValue<decltype(dst.VEBoxInfo.SFCSupport.Value)>(*tokSFCSupport);
1618                                         } break;
1619                                         };
1620                                         tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount;
1621                                     } else {
1622                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSFCSupport);
1623                                         switch (tokSFCSupport->id) {
1624                                         default:
1625                                             if (tokSFCSupport->flags.flag3IsMandatory) {
1626                                                 return false;
1627                                             }
1628                                             break;
1629                                         case TOK_FS_GT_VEBOX_INFO__ANONYMOUS3862__SFC_SUPPORTED_BITS: {
1630                                             const TokenHeader *tokSfcSupportedBits = varLen->getValue<TokenHeader>();
1631                                             const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1632                                             while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) {
1633                                                 if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) {
1634                                                     switch (tokSfcSupportedBits->id) {
1635                                                     default:
1636                                                         if (tokSfcSupportedBits->flags.flag3IsMandatory) {
1637                                                             return false;
1638                                                         }
1639                                                         break;
1640                                                     case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX0: {
1641                                                         dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox0 = readTokValue<decltype(dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox0)>(*tokSfcSupportedBits);
1642                                                     } break;
1643                                                     case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX1: {
1644                                                         dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox1 = readTokValue<decltype(dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox1)>(*tokSfcSupportedBits);
1645                                                     } break;
1646                                                     case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX2: {
1647                                                         dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox2 = readTokValue<decltype(dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox2)>(*tokSfcSupportedBits);
1648                                                     } break;
1649                                                     case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX3: {
1650                                                         dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox3 = readTokValue<decltype(dst.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox3)>(*tokSfcSupportedBits);
1651                                                     } break;
1652                                                     };
1653                                                     tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount;
1654                                                 } else {
1655                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSfcSupportedBits);
1656                                                     if (tokSfcSupportedBits->flags.flag3IsMandatory) {
1657                                                         return false;
1658                                                     }
1659                                                     tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1660                                                 }
1661                                             }
1662                                             WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd);
1663                                         } break;
1664                                         };
1665                                         tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1666                                     }
1667                                 }
1668                                 WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd);
1669                             } break;
1670                             };
1671                             tokVEBoxInfo = tokVEBoxInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1672                         }
1673                     }
1674                     WCH_ASSERT(tokVEBoxInfo == tokVEBoxInfoEnd);
1675                 } break;
1676                 case TOK_FS_GT_SYSTEM_INFO__CACHE_TYPES: {
1677                     const TokenHeader *tokCacheTypes = varLen->getValue<TokenHeader>();
1678                     const TokenHeader *tokCacheTypesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
1679                     while (tokCacheTypes < tokCacheTypesEnd) {
1680                         if (false == tokCacheTypes->flags.flag4IsVariableLength) {
1681                             switch (tokCacheTypes->id) {
1682                             default:
1683                                 if (tokCacheTypes->flags.flag3IsMandatory) {
1684                                     return false;
1685                                 }
1686                                 break;
1687                             case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__L3: {
1688                                 dst.CacheTypes.L3 = readTokValue<decltype(dst.CacheTypes.L3)>(*tokCacheTypes);
1689                             } break;
1690                             case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__LLC: {
1691                                 dst.CacheTypes.LLC = readTokValue<decltype(dst.CacheTypes.LLC)>(*tokCacheTypes);
1692                             } break;
1693                             case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__E_DRAM: {
1694                                 dst.CacheTypes.eDRAM = readTokValue<decltype(dst.CacheTypes.eDRAM)>(*tokCacheTypes);
1695                             } break;
1696                             case TOK_FBD_GT_CACHE_TYPES__CACHE_TYPE_MASK: {
1697                                 dst.CacheTypes.CacheTypeMask = readTokValue<decltype(dst.CacheTypes.CacheTypeMask)>(*tokCacheTypes);
1698                             } break;
1699                             };
1700                             tokCacheTypes = tokCacheTypes + 1 + tokCacheTypes->valueDwordCount;
1701                         } else {
1702                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCacheTypes);
1703                             if (tokCacheTypes->flags.flag3IsMandatory) {
1704                                 return false;
1705                             }
1706                             tokCacheTypes = tokCacheTypes + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1707                         }
1708                     }
1709                     WCH_ASSERT(tokCacheTypes == tokCacheTypesEnd);
1710                 } break;
1711                 };
1712                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1713             }
1714         }
1715         WCH_ASSERT(tok == srcTokensEnd);
1716         return true;
1717     }
1718 };
1719 
1720 template <>
1721 struct Demarshaller<TOK_S_SKU_FEATURE_TABLE> {
1722     template <typename _SKU_FEATURE_TABLET>
1723     static bool demarshall(_SKU_FEATURE_TABLET &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
1724         const TokenHeader *tok = srcTokensBeg;
1725         while (tok < srcTokensEnd) {
1726             if (false == tok->flags.flag4IsVariableLength) {
1727                 switch (tok->id) {
1728                 default:
1729                     if (tok->flags.flag3IsMandatory) {
1730                         return false;
1731                     }
1732                     break;
1733                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_DESKTOP: {
1734                     dst.FtrDesktop = readTokValue<decltype(dst.FtrDesktop)>(*tok);
1735                 } break;
1736                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VERING: {
1737                     dst.FtrVERing = readTokValue<decltype(dst.FtrVERing)>(*tok);
1738                 } break;
1739                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VCS2: {
1740                     dst.FtrVcs2 = readTokValue<decltype(dst.FtrVcs2)>(*tok);
1741                 } break;
1742                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_BIG_DIE: {
1743                     dst.FtrGtBigDie = readTokValue<decltype(dst.FtrGtBigDie)>(*tok);
1744                 } break;
1745                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_MEDIUM_DIE: {
1746                     dst.FtrGtMediumDie = readTokValue<decltype(dst.FtrGtMediumDie)>(*tok);
1747                 } break;
1748                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_SMALL_DIE: {
1749                     dst.FtrGtSmallDie = readTokValue<decltype(dst.FtrGtSmallDie)>(*tok);
1750                 } break;
1751                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1: {
1752                     dst.FtrGT1 = readTokValue<decltype(dst.FtrGT1)>(*tok);
1753                 } break;
1754                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1_5: {
1755                     dst.FtrGT1_5 = readTokValue<decltype(dst.FtrGT1_5)>(*tok);
1756                 } break;
1757                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2: {
1758                     dst.FtrGT2 = readTokValue<decltype(dst.FtrGT2)>(*tok);
1759                 } break;
1760                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2_5: {
1761                     dst.FtrGT2_5 = readTokValue<decltype(dst.FtrGT2_5)>(*tok);
1762                 } break;
1763                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT3: {
1764                     dst.FtrGT3 = readTokValue<decltype(dst.FtrGT3)>(*tok);
1765                 } break;
1766                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT4: {
1767                     dst.FtrGT4 = readTokValue<decltype(dst.FtrGT4)>(*tok);
1768                 } break;
1769                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_ULT: {
1770                     dst.FtrULT = readTokValue<decltype(dst.FtrULT)>(*tok);
1771                 } break;
1772                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_IVBM0M1PLATFORM: {
1773                     dst.FtrIVBM0M1Platform = readTokValue<decltype(dst.FtrIVBM0M1Platform)>(*tok);
1774                 } break;
1775                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CHANNEL_SWIZZLING_XORENABLED: {
1776                     dst.FtrChannelSwizzlingXOREnabled = readTokValue<decltype(dst.FtrChannelSwizzlingXOREnabled)>(*tok);
1777                 } break;
1778                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTA: {
1779                     dst.FtrGTA = readTokValue<decltype(dst.FtrGTA)>(*tok);
1780                 } break;
1781                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTC: {
1782                     dst.FtrGTC = readTokValue<decltype(dst.FtrGTC)>(*tok);
1783                 } break;
1784                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTX: {
1785                     dst.FtrGTX = readTokValue<decltype(dst.FtrGTX)>(*tok);
1786                 } break;
1787                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR5SLICE: {
1788                     dst.Ftr5Slice = readTokValue<decltype(dst.Ftr5Slice)>(*tok);
1789                 } break;
1790                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_LCIA: {
1791                     dst.FtrLCIA = readTokValue<decltype(dst.FtrLCIA)>(*tok);
1792                 } break;
1793                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_RESOURCE_STREAMER: {
1794                     dst.FtrResourceStreamer = readTokValue<decltype(dst.FtrResourceStreamer)>(*tok);
1795                 } break;
1796                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSRING: {
1797                     dst.FtrCCSRing = readTokValue<decltype(dst.FtrCCSRing)>(*tok);
1798                 } break;
1799                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSNODE: {
1800                     dst.FtrCCSNode = readTokValue<decltype(dst.FtrCCSNode)>(*tok);
1801                 } break;
1802                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSMULTI_INSTANCE: {
1803                     dst.FtrCCSMultiInstance = readTokValue<decltype(dst.FtrCCSMultiInstance)>(*tok);
1804                 } break;
1805                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_DISPLAY_DISABLED: {
1806                     dst.FtrDisplayDisabled = readTokValue<decltype(dst.FtrDisplayDisabled)>(*tok);
1807                 } break;
1808                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_SGTPVSKUSTRAP_PRESENT: {
1809                     dst.FtrSGTPVSKUStrapPresent = readTokValue<decltype(dst.FtrSGTPVSKUStrapPresent)>(*tok);
1810                 } break;
1811                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21584__FTR_POOLED_EU_ENABLED: {
1812                     dst.FtrPooledEuEnabled = readTokValue<decltype(dst.FtrPooledEuEnabled)>(*tok);
1813                 } break;
1814                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_BATCH_PREEMPT: {
1815                     dst.FtrGpGpuMidBatchPreempt = readTokValue<decltype(dst.FtrGpGpuMidBatchPreempt)>(*tok);
1816                 } break;
1817                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_THREAD_GROUP_LEVEL_PREEMPT: {
1818                     dst.FtrGpGpuThreadGroupLevelPreempt = readTokValue<decltype(dst.FtrGpGpuThreadGroupLevelPreempt)>(*tok);
1819                 } break;
1820                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_THREAD_LEVEL_PREEMPT: {
1821                     dst.FtrGpGpuMidThreadLevelPreempt = readTokValue<decltype(dst.FtrGpGpuMidThreadLevelPreempt)>(*tok);
1822                 } break;
1823                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_MID_BATCH_PREEMPT: {
1824                     dst.Ftr3dMidBatchPreempt = readTokValue<decltype(dst.Ftr3dMidBatchPreempt)>(*tok);
1825                 } break;
1826                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_OBJECT_LEVEL_PREEMPT: {
1827                     dst.Ftr3dObjectLevelPreempt = readTokValue<decltype(dst.Ftr3dObjectLevelPreempt)>(*tok);
1828                 } break;
1829                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: {
1830                     dst.FtrPerCtxtPreemptionGranularityControl = readTokValue<decltype(dst.FtrPerCtxtPreemptionGranularityControl)>(*tok);
1831                 } break;
1832                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT: {
1833                     dst.FtrPPGTT = readTokValue<decltype(dst.FtrPPGTT)>(*tok);
1834                 } break;
1835                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IA32E_GFX_PTES: {
1836                     dst.FtrIA32eGfxPTEs = readTokValue<decltype(dst.FtrIA32eGfxPTEs)>(*tok);
1837                 } break;
1838                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MEM_TYPE_MOCS_DEFER_PAT: {
1839                     dst.FtrMemTypeMocsDeferPAT = readTokValue<decltype(dst.FtrMemTypeMocsDeferPAT)>(*tok);
1840                 } break;
1841                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PML4SUPPORT: {
1842                     dst.FtrPml4Support = readTokValue<decltype(dst.FtrPml4Support)>(*tok);
1843                 } break;
1844                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_SVM: {
1845                     dst.FtrSVM = readTokValue<decltype(dst.FtrSVM)>(*tok);
1846                 } break;
1847                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_MAPPED_RESOURCE: {
1848                     dst.FtrTileMappedResource = readTokValue<decltype(dst.FtrTileMappedResource)>(*tok);
1849                 } break;
1850                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TRANSLATION_TABLE: {
1851                     dst.FtrTranslationTable = readTokValue<decltype(dst.FtrTranslationTable)>(*tok);
1852                 } break;
1853                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_USER_MODE_TRANSLATION_TABLE: {
1854                     dst.FtrUserModeTranslationTable = readTokValue<decltype(dst.FtrUserModeTranslationTable)>(*tok);
1855                 } break;
1856                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_NULL_PAGES: {
1857                     dst.FtrNullPages = readTokValue<decltype(dst.FtrNullPages)>(*tok);
1858                 } break;
1859                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_L3IACOHERENCY: {
1860                     dst.FtrL3IACoherency = readTokValue<decltype(dst.FtrL3IACoherency)>(*tok);
1861                 } break;
1862                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_EDRAM: {
1863                     dst.FtrEDram = readTokValue<decltype(dst.FtrEDram)>(*tok);
1864                 } break;
1865                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LLCBYPASS: {
1866                     dst.FtrLLCBypass = readTokValue<decltype(dst.FtrLLCBypass)>(*tok);
1867                 } break;
1868                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CRYSTALWELL: {
1869                     dst.FtrCrystalwell = readTokValue<decltype(dst.FtrCrystalwell)>(*tok);
1870                 } break;
1871                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CENTRAL_CACHE_POLICY: {
1872                     dst.FtrCentralCachePolicy = readTokValue<decltype(dst.FtrCentralCachePolicy)>(*tok);
1873                 } break;
1874                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IO_MMU_PAGE_FAULTING: {
1875                     dst.FtrIoMmuPageFaulting = readTokValue<decltype(dst.FtrIoMmuPageFaulting)>(*tok);
1876                 } break;
1877                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2GPU_MMU: {
1878                     dst.FtrWddm2GpuMmu = readTokValue<decltype(dst.FtrWddm2GpuMmu)>(*tok);
1879                 } break;
1880                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2SVM: {
1881                     dst.FtrWddm2Svm = readTokValue<decltype(dst.FtrWddm2Svm)>(*tok);
1882                 } break;
1883                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_STANDARD_MIP_TAIL_FORMAT: {
1884                     dst.FtrStandardMipTailFormat = readTokValue<decltype(dst.FtrStandardMipTailFormat)>(*tok);
1885                 } break;
1886                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2_1_64KB_PAGES: {
1887                     dst.FtrWddm2_1_64kbPages = readTokValue<decltype(dst.FtrWddm2_1_64kbPages)>(*tok);
1888                 } break;
1889                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GTT_CACHE_INVALIDATION: {
1890                     dst.FtrGttCacheInvalidation = readTokValue<decltype(dst.FtrGttCacheInvalidation)>(*tok);
1891                 } break;
1892                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_E2ECOMPRESSION: {
1893                     dst.FtrE2ECompression = readTokValue<decltype(dst.FtrE2ECompression)>(*tok);
1894                 } break;
1895                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LINEAR_CCS: {
1896                     dst.FtrLinearCCS = readTokValue<decltype(dst.FtrLinearCCS)>(*tok);
1897                 } break;
1898                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY: {
1899                     dst.FtrLocalMemory = readTokValue<decltype(dst.FtrLocalMemory)>(*tok);
1900                 } break;
1901                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT64KBWALK_OPTIMIZATION: {
1902                     dst.FtrPpgtt64KBWalkOptimization = readTokValue<decltype(dst.FtrPpgtt64KBWalkOptimization)>(*tok);
1903                 } break;
1904                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_Y: {
1905                     dst.FtrTileY = readTokValue<decltype(dst.FtrTileY)>(*tok);
1906                 } break;
1907                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FLAT_PHYS_CCS: {
1908                     dst.FtrFlatPhysCCS = readTokValue<decltype(dst.FtrFlatPhysCCS)>(*tok);
1909                 } break;
1910                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MULTI_TILE_ARCH: {
1911                     dst.FtrMultiTileArch = readTokValue<decltype(dst.FtrMultiTileArch)>(*tok);
1912                 } break;
1913                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY_ALLOWS4KB: {
1914                     dst.FtrLocalMemoryAllows4KB = readTokValue<decltype(dst.FtrLocalMemoryAllows4KB)>(*tok);
1915                 } break;
1916                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DISPLAY_XTILING: {
1917                     dst.FtrDisplayXTiling = readTokValue<decltype(dst.FtrDisplayXTiling)>(*tok);
1918                 } break;
1919                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CAMERA_CAPTURE_CACHING: {
1920                     dst.FtrCameraCaptureCaching = readTokValue<decltype(dst.FtrCameraCaptureCaching)>(*tok);
1921                 } break;
1922                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_KMD_DAF: {
1923                     dst.FtrKmdDaf = readTokValue<decltype(dst.FtrKmdDaf)>(*tok);
1924                 } break;
1925                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FRAME_BUFFER_LLC: {
1926                     dst.FtrFrameBufferLLC = readTokValue<decltype(dst.FtrFrameBufferLLC)>(*tok);
1927                 } break;
1928                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DRIVER_FLR: {
1929                     dst.FtrDriverFLR = readTokValue<decltype(dst.FtrDriverFLR)>(*tok);
1930                 } break;
1931                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_LDR2D: {
1932                     dst.FtrAstcLdr2D = readTokValue<decltype(dst.FtrAstcLdr2D)>(*tok);
1933                 } break;
1934                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_HDR2D: {
1935                     dst.FtrAstcHdr2D = readTokValue<decltype(dst.FtrAstcHdr2D)>(*tok);
1936                 } break;
1937                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC3D: {
1938                     dst.FtrAstc3D = readTokValue<decltype(dst.FtrAstc3D)>(*tok);
1939                 } break;
1940                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC: {
1941                     dst.FtrFbc = readTokValue<decltype(dst.FtrFbc)>(*tok);
1942                 } break;
1943                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC2ADDRESS_TRANSLATION: {
1944                     dst.FtrFbc2AddressTranslation = readTokValue<decltype(dst.FtrFbc2AddressTranslation)>(*tok);
1945                 } break;
1946                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_BLITTER_TRACKING: {
1947                     dst.FtrFbcBlitterTracking = readTokValue<decltype(dst.FtrFbcBlitterTracking)>(*tok);
1948                 } break;
1949                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_CPU_TRACKING: {
1950                     dst.FtrFbcCpuTracking = readTokValue<decltype(dst.FtrFbcCpuTracking)>(*tok);
1951                 } break;
1952                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_VEBOX: {
1953                     dst.FtrVEBOX = readTokValue<decltype(dst.FtrVEBOX)>(*tok);
1954                 } break;
1955                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_REND_COMP: {
1956                     dst.FtrRendComp = readTokValue<decltype(dst.FtrRendComp)>(*tok);
1957                 } break;
1958                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_DISPLAY_YTILING: {
1959                     dst.FtrDisplayYTiling = readTokValue<decltype(dst.FtrDisplayYTiling)>(*tok);
1960                 } break;
1961                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_S3D: {
1962                     dst.FtrS3D = readTokValue<decltype(dst.FtrS3D)>(*tok);
1963                 } break;
1964                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_DISPLAY_ENGINE_S3D: {
1965                     dst.FtrDisplayEngineS3d = readTokValue<decltype(dst.FtrDisplayEngineS3d)>(*tok);
1966                 } break;
1967                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SINGLE_VEBOX_SLICE: {
1968                     dst.FtrSingleVeboxSlice = readTokValue<decltype(dst.FtrSingleVeboxSlice)>(*tok);
1969                 } break;
1970                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SIMULATION_MODE: {
1971                     dst.FtrSimulationMode = readTokValue<decltype(dst.FtrSimulationMode)>(*tok);
1972                 } break;
1973                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS88095__FTR_ENABLE_GU_C: {
1974                     dst.FtrEnableGuC = readTokValue<decltype(dst.FtrEnableGuC)>(*tok);
1975                 } break;
1976                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS89755__FTR_VGT: {
1977                     dst.FtrVgt = readTokValue<decltype(dst.FtrVgt)>(*tok);
1978                 } break;
1979                 case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS91822__FTR_ASSIGNED_GPU_TILE: {
1980                     dst.FtrAssignedGpuTile = readTokValue<decltype(dst.FtrAssignedGpuTile)>(*tok);
1981                 } break;
1982                 };
1983                 tok = tok + 1 + tok->valueDwordCount;
1984             } else {
1985                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
1986                 switch (tok->id) {
1987                 default:
1988                     if (tok->flags.flag3IsMandatory) {
1989                         return false;
1990                     }
1991                     break;
1992                 case TOK_S_SKU_FEATURE_TABLE:
1993                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
1994                         return false;
1995                     }
1996                     break;
1997                 };
1998                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
1999             }
2000         }
2001         WCH_ASSERT(tok == srcTokensEnd);
2002         return true;
2003     }
2004 };
2005 
2006 template <>
2007 struct Demarshaller<TOK_S_WA_TABLE> {
2008     template <typename _WA_TABLET>
2009     static bool demarshall(_WA_TABLET &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
2010         const TokenHeader *tok = srcTokensBeg;
2011         while (tok < srcTokensEnd) {
2012             if (false == tok->flags.flag4IsVariableLength) {
2013                 switch (tok->id) {
2014                 default:
2015                     if (tok->flags.flag3IsMandatory) {
2016                         return false;
2017                     }
2018                     break;
2019                 case TOK_FBD_WA_TABLE__WA_DO_NOT_USE_MIREPORT_PERF_COUNT: {
2020                     dst.WaDoNotUseMIReportPerfCount = readTokValue<decltype(dst.WaDoNotUseMIReportPerfCount)>(*tok);
2021                 } break;
2022                 case TOK_FBD_WA_TABLE__WA_ALIGN_INDEX_BUFFER: {
2023                     dst.WaAlignIndexBuffer = readTokValue<decltype(dst.WaAlignIndexBuffer)>(*tok);
2024                 } break;
2025                 case TOK_FBD_WA_TABLE__WA_SEND_MIFLUSHBEFORE_VFE: {
2026                     dst.WaSendMIFLUSHBeforeVFE = readTokValue<decltype(dst.WaSendMIFLUSHBeforeVFE)>(*tok);
2027                 } break;
2028                 case TOK_FBD_WA_TABLE__WA_DISABLE_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: {
2029                     dst.WaDisablePerCtxtPreemptionGranularityControl = readTokValue<decltype(dst.WaDisablePerCtxtPreemptionGranularityControl)>(*tok);
2030                 } break;
2031                 case TOK_FBD_WA_TABLE__WA_ENABLE_PREEMPTION_GRANULARITY_CONTROL_BY_UMD: {
2032                     dst.WaEnablePreemptionGranularityControlByUMD = readTokValue<decltype(dst.WaEnablePreemptionGranularityControlByUMD)>(*tok);
2033                 } break;
2034                 case TOK_FBD_WA_TABLE__WA_DISABLE_LSQCROPERFFOR_OCL: {
2035                     dst.WaDisableLSQCROPERFforOCL = readTokValue<decltype(dst.WaDisableLSQCROPERFforOCL)>(*tok);
2036                 } break;
2037                 case TOK_FBD_WA_TABLE__WA_VALIGN2FOR96BPP_FORMATS: {
2038                     dst.WaValign2For96bppFormats = readTokValue<decltype(dst.WaValign2For96bppFormats)>(*tok);
2039                 } break;
2040                 case TOK_FBD_WA_TABLE__WA_VALIGN2FOR_R8G8B8UINTFORMAT: {
2041                     dst.WaValign2ForR8G8B8UINTFormat = readTokValue<decltype(dst.WaValign2ForR8G8B8UINTFormat)>(*tok);
2042                 } break;
2043                 case TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_USE_GLOBAL_CONTEXT_ID: {
2044                     dst.WaReportPerfCountUseGlobalContextID = readTokValue<decltype(dst.WaReportPerfCountUseGlobalContextID)>(*tok);
2045                 } break;
2046                 case TOK_FBD_WA_TABLE__WA_FORCE_PC_BB_FULL_CFG_RESTORE: {
2047                     dst.WaForcePcBbFullCfgRestore = readTokValue<decltype(dst.WaForcePcBbFullCfgRestore)>(*tok);
2048                 } break;
2049                 case TOK_FBD_WA_TABLE__WA_CSRUNCACHABLE: {
2050                     dst.WaCSRUncachable = readTokValue<decltype(dst.WaCSRUncachable)>(*tok);
2051                 } break;
2052                 case TOK_FBD_WA_TABLE__WA_DISABLE_FUSED_THREAD_SCHEDULING: {
2053                     dst.WaDisableFusedThreadScheduling = readTokValue<decltype(dst.WaDisableFusedThreadScheduling)>(*tok);
2054                 } break;
2055                 case TOK_FBD_WA_TABLE__WA_MODIFY_VFESTATE_AFTER_GPGPUPREEMPTION: {
2056                     dst.WaModifyVFEStateAfterGPGPUPreemption = readTokValue<decltype(dst.WaModifyVFEStateAfterGPGPUPreemption)>(*tok);
2057                 } break;
2058                 case TOK_FBD_WA_TABLE__WA_CURSOR16K: {
2059                     dst.WaCursor16K = readTokValue<decltype(dst.WaCursor16K)>(*tok);
2060                 } break;
2061                 case TOK_FBD_WA_TABLE__WA8K_ALIGNFOR_ASYNC_FLIP: {
2062                     dst.Wa8kAlignforAsyncFlip = readTokValue<decltype(dst.Wa8kAlignforAsyncFlip)>(*tok);
2063                 } break;
2064                 case TOK_FBD_WA_TABLE__WA29BIT_DISPLAY_ADDR_LIMIT: {
2065                     dst.Wa29BitDisplayAddrLimit = readTokValue<decltype(dst.Wa29BitDisplayAddrLimit)>(*tok);
2066                 } break;
2067                 case TOK_FBD_WA_TABLE__WA_ALIGN_CONTEXT_IMAGE: {
2068                     dst.WaAlignContextImage = readTokValue<decltype(dst.WaAlignContextImage)>(*tok);
2069                 } break;
2070                 case TOK_FBD_WA_TABLE__WA_FORCE_GLOBAL_GTT: {
2071                     dst.WaForceGlobalGTT = readTokValue<decltype(dst.WaForceGlobalGTT)>(*tok);
2072                 } break;
2073                 case TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_FORCE_GLOBAL_GTT: {
2074                     dst.WaReportPerfCountForceGlobalGTT = readTokValue<decltype(dst.WaReportPerfCountForceGlobalGTT)>(*tok);
2075                 } break;
2076                 case TOK_FBD_WA_TABLE__WA_OA_ADDRESS_TRANSLATION: {
2077                     dst.WaOaAddressTranslation = readTokValue<decltype(dst.WaOaAddressTranslation)>(*tok);
2078                 } break;
2079                 case TOK_FBD_WA_TABLE__WA2ROW_VERTICAL_ALIGNMENT: {
2080                     dst.Wa2RowVerticalAlignment = readTokValue<decltype(dst.Wa2RowVerticalAlignment)>(*tok);
2081                 } break;
2082                 case TOK_FBD_WA_TABLE__WA_PPGTT_ALIAS_GLOBAL_GTT_SPACE: {
2083                     dst.WaPpgttAliasGlobalGttSpace = readTokValue<decltype(dst.WaPpgttAliasGlobalGttSpace)>(*tok);
2084                 } break;
2085                 case TOK_FBD_WA_TABLE__WA_CLEAR_FENCE_REGISTERS_AT_DRIVER_INIT: {
2086                     dst.WaClearFenceRegistersAtDriverInit = readTokValue<decltype(dst.WaClearFenceRegistersAtDriverInit)>(*tok);
2087                 } break;
2088                 case TOK_FBD_WA_TABLE__WA_RESTRICT_PITCH128KB: {
2089                     dst.WaRestrictPitch128KB = readTokValue<decltype(dst.WaRestrictPitch128KB)>(*tok);
2090                 } break;
2091                 case TOK_FBD_WA_TABLE__WA_AVOID_LLC: {
2092                     dst.WaAvoidLLC = readTokValue<decltype(dst.WaAvoidLLC)>(*tok);
2093                 } break;
2094                 case TOK_FBD_WA_TABLE__WA_AVOID_L3: {
2095                     dst.WaAvoidL3 = readTokValue<decltype(dst.WaAvoidL3)>(*tok);
2096                 } break;
2097                 case TOK_FBD_WA_TABLE__WA16TILE_FENCES_ONLY: {
2098                     dst.Wa16TileFencesOnly = readTokValue<decltype(dst.Wa16TileFencesOnly)>(*tok);
2099                 } break;
2100                 case TOK_FBD_WA_TABLE__WA16MBOABUFFER_ALIGNMENT: {
2101                     dst.Wa16MBOABufferAlignment = readTokValue<decltype(dst.Wa16MBOABufferAlignment)>(*tok);
2102                 } break;
2103                 case TOK_FBD_WA_TABLE__WA_TRANSLATION_TABLE_UNAVAILABLE: {
2104                     dst.WaTranslationTableUnavailable = readTokValue<decltype(dst.WaTranslationTableUnavailable)>(*tok);
2105                 } break;
2106                 case TOK_FBD_WA_TABLE__WA_NO_MINIMIZED_TRIVIAL_SURFACE_PADDING: {
2107                     dst.WaNoMinimizedTrivialSurfacePadding = readTokValue<decltype(dst.WaNoMinimizedTrivialSurfacePadding)>(*tok);
2108                 } break;
2109                 case TOK_FBD_WA_TABLE__WA_NO_BUFFER_SAMPLER_PADDING: {
2110                     dst.WaNoBufferSamplerPadding = readTokValue<decltype(dst.WaNoBufferSamplerPadding)>(*tok);
2111                 } break;
2112                 case TOK_FBD_WA_TABLE__WA_SURFACE_STATE_PLANAR_YOFFSET_ALIGN_BY2: {
2113                     dst.WaSurfaceStatePlanarYOffsetAlignBy2 = readTokValue<decltype(dst.WaSurfaceStatePlanarYOffsetAlignBy2)>(*tok);
2114                 } break;
2115                 case TOK_FBD_WA_TABLE__WA_GTT_CACHING_OFF_BY_DEFAULT: {
2116                     dst.WaGttCachingOffByDefault = readTokValue<decltype(dst.WaGttCachingOffByDefault)>(*tok);
2117                 } break;
2118                 case TOK_FBD_WA_TABLE__WA_TOUCH_ALL_SVM_MEMORY: {
2119                     dst.WaTouchAllSvmMemory = readTokValue<decltype(dst.WaTouchAllSvmMemory)>(*tok);
2120                 } break;
2121                 case TOK_FBD_WA_TABLE__WA_IOBADDRESS_MUST_BE_VALID_IN_HW_CONTEXT: {
2122                     dst.WaIOBAddressMustBeValidInHwContext = readTokValue<decltype(dst.WaIOBAddressMustBeValidInHwContext)>(*tok);
2123                 } break;
2124                 case TOK_FBD_WA_TABLE__WA_FLUSH_TLB_AFTER_CPU_GGTT_WRITES: {
2125                     dst.WaFlushTlbAfterCpuGgttWrites = readTokValue<decltype(dst.WaFlushTlbAfterCpuGgttWrites)>(*tok);
2126                 } break;
2127                 case TOK_FBD_WA_TABLE__WA_MSAA8X_TILE_YDEPTH_PITCH_ALIGNMENT: {
2128                     dst.WaMsaa8xTileYDepthPitchAlignment = readTokValue<decltype(dst.WaMsaa8xTileYDepthPitchAlignment)>(*tok);
2129                 } break;
2130                 case TOK_FBD_WA_TABLE__WA_DISABLE_NULL_PAGE_AS_DUMMY: {
2131                     dst.WaDisableNullPageAsDummy = readTokValue<decltype(dst.WaDisableNullPageAsDummy)>(*tok);
2132                 } break;
2133                 case TOK_FBD_WA_TABLE__WA_USE_VALIGN16ON_TILE_XYBPP816: {
2134                     dst.WaUseVAlign16OnTileXYBpp816 = readTokValue<decltype(dst.WaUseVAlign16OnTileXYBpp816)>(*tok);
2135                 } break;
2136                 case TOK_FBD_WA_TABLE__WA_GTT_PAT0: {
2137                     dst.WaGttPat0 = readTokValue<decltype(dst.WaGttPat0)>(*tok);
2138                 } break;
2139                 case TOK_FBD_WA_TABLE__WA_GTT_PAT0WB: {
2140                     dst.WaGttPat0WB = readTokValue<decltype(dst.WaGttPat0WB)>(*tok);
2141                 } break;
2142                 case TOK_FBD_WA_TABLE__WA_MEM_TYPE_IS_MAX_OF_PAT_AND_MOCS: {
2143                     dst.WaMemTypeIsMaxOfPatAndMocs = readTokValue<decltype(dst.WaMemTypeIsMaxOfPatAndMocs)>(*tok);
2144                 } break;
2145                 case TOK_FBD_WA_TABLE__WA_GTT_PAT0GTT_WB_OVER_OS_IOMMU_ELLC_ONLY: {
2146                     dst.WaGttPat0GttWbOverOsIommuEllcOnly = readTokValue<decltype(dst.WaGttPat0GttWbOverOsIommuEllcOnly)>(*tok);
2147                 } break;
2148                 case TOK_FBD_WA_TABLE__WA_ADD_DUMMY_PAGE_FOR_DISPLAY_PREFETCH: {
2149                     dst.WaAddDummyPageForDisplayPrefetch = readTokValue<decltype(dst.WaAddDummyPageForDisplayPrefetch)>(*tok);
2150                 } break;
2151                 case TOK_FBD_WA_TABLE__WA_DEFAULT_TILE4: {
2152                     dst.WaDefaultTile4 = readTokValue<decltype(dst.WaDefaultTile4)>(*tok);
2153                 } break;
2154                 case TOK_FBD_WA_TABLE__WA_LLCCACHING_UNSUPPORTED: {
2155                     dst.WaLLCCachingUnsupported = readTokValue<decltype(dst.WaLLCCachingUnsupported)>(*tok);
2156                 } break;
2157                 case TOK_FBD_WA_TABLE__WA_DOUBLE_FAST_CLEAR_WIDTH_ALIGNMENT: {
2158                     dst.WaDoubleFastClearWidthAlignment = readTokValue<decltype(dst.WaDoubleFastClearWidthAlignment)>(*tok);
2159                 } break;
2160                 case TOK_FBD_WA_TABLE__WA_COMPRESSED_RESOURCE_REQUIRES_CONST_VA21: {
2161                     dst.WaCompressedResourceRequiresConstVA21 = readTokValue<decltype(dst.WaCompressedResourceRequiresConstVA21)>(*tok);
2162                 } break;
2163                 case TOK_FBD_WA_TABLE__WA_DISREGARD_PLATFORM_CHECKS: {
2164                     dst.WaDisregardPlatformChecks = readTokValue<decltype(dst.WaDisregardPlatformChecks)>(*tok);
2165                 } break;
2166                 case TOK_FBD_WA_TABLE__WA_LOSSLESS_COMPRESSION_SURFACE_STRIDE: {
2167                     dst.WaLosslessCompressionSurfaceStride = readTokValue<decltype(dst.WaLosslessCompressionSurfaceStride)>(*tok);
2168                 } break;
2169                 case TOK_FBD_WA_TABLE__WA_FBC_LINEAR_SURFACE_STRIDE: {
2170                     dst.WaFbcLinearSurfaceStride = readTokValue<decltype(dst.WaFbcLinearSurfaceStride)>(*tok);
2171                 } break;
2172                 case TOK_FBD_WA_TABLE__WA4K_ALIGN_UVOFFSET_NV12LINEAR_SURFACE: {
2173                     dst.Wa4kAlignUVOffsetNV12LinearSurface = readTokValue<decltype(dst.Wa4kAlignUVOffsetNV12LinearSurface)>(*tok);
2174                 } break;
2175                 case TOK_FBD_WA_TABLE__WA_ASTC_CORRUPTION_FOR_ODD_COMPRESSED_BLOCK_SIZE_X: {
2176                     dst.WaAstcCorruptionForOddCompressedBlockSizeX = readTokValue<decltype(dst.WaAstcCorruptionForOddCompressedBlockSizeX)>(*tok);
2177                 } break;
2178                 case TOK_FBD_WA_TABLE__WA_AUX_TABLE16KGRANULAR: {
2179                     dst.WaAuxTable16KGranular = readTokValue<decltype(dst.WaAuxTable16KGranular)>(*tok);
2180                 } break;
2181                 case TOK_FBD_WA_TABLE__WA_ENCRYPTED_EDRAM_ONLY_PARTIALS: {
2182                     dst.WaEncryptedEdramOnlyPartials = readTokValue<decltype(dst.WaEncryptedEdramOnlyPartials)>(*tok);
2183                 } break;
2184                 case TOK_FBD_WA_TABLE__WA_DISABLE_EDRAM_FOR_DISPLAY_RT: {
2185                     dst.WaDisableEdramForDisplayRT = readTokValue<decltype(dst.WaDisableEdramForDisplayRT)>(*tok);
2186                 } break;
2187                 case TOK_FBD_WA_TABLE__WA_LIMIT128BMEDIA_COMPR: {
2188                     dst.WaLimit128BMediaCompr = readTokValue<decltype(dst.WaLimit128BMediaCompr)>(*tok);
2189                 } break;
2190                 case TOK_FBD_WA_TABLE__WA_UNTYPED_BUFFER_COMPRESSION: {
2191                     dst.WaUntypedBufferCompression = readTokValue<decltype(dst.WaUntypedBufferCompression)>(*tok);
2192                 } break;
2193                 case TOK_FBD_WA_TABLE__WA_SAMPLER_CACHE_FLUSH_BETWEEN_REDESCRIBED_SURFACE_READS: {
2194                     dst.WaSamplerCacheFlushBetweenRedescribedSurfaceReads = readTokValue<decltype(dst.WaSamplerCacheFlushBetweenRedescribedSurfaceReads)>(*tok);
2195                 } break;
2196                 case TOK_FBD_WA_TABLE__WA_ALIGN_YUVRESOURCE_TO_LCU: {
2197                     dst.WaAlignYUVResourceToLCU = readTokValue<decltype(dst.WaAlignYUVResourceToLCU)>(*tok);
2198                 } break;
2199                 case TOK_FBD_WA_TABLE__WA32BPP_TILE_Y2DCOLOR_NO_HALIGN4: {
2200                     dst.Wa32bppTileY2DColorNoHAlign4 = readTokValue<decltype(dst.Wa32bppTileY2DColorNoHAlign4)>(*tok);
2201                 } break;
2202                 };
2203                 tok = tok + 1 + tok->valueDwordCount;
2204             } else {
2205                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
2206                 switch (tok->id) {
2207                 default:
2208                     if (tok->flags.flag3IsMandatory) {
2209                         return false;
2210                     }
2211                     break;
2212                 case TOK_S_WA_TABLE:
2213                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
2214                         return false;
2215                     }
2216                     break;
2217                 };
2218                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2219             }
2220         }
2221         WCH_ASSERT(tok == srcTokensEnd);
2222         return true;
2223     }
2224 };
2225 
2226 template <>
2227 struct Demarshaller<TOK_S_PLATFORM_STR> {
2228     template <typename PLATFORM_STRT>
2229     static bool demarshall(PLATFORM_STRT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
2230         const TokenHeader *tok = srcTokensBeg;
2231         while (tok < srcTokensEnd) {
2232             if (false == tok->flags.flag4IsVariableLength) {
2233                 switch (tok->id) {
2234                 default:
2235                     if (tok->flags.flag3IsMandatory) {
2236                         return false;
2237                     }
2238                     break;
2239                 case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
2240                     dst.eProductFamily = readTokValue<decltype(dst.eProductFamily)>(*tok);
2241                 } break;
2242                 case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
2243                     dst.ePCHProductFamily = readTokValue<decltype(dst.ePCHProductFamily)>(*tok);
2244                 } break;
2245                 case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
2246                     dst.eDisplayCoreFamily = readTokValue<decltype(dst.eDisplayCoreFamily)>(*tok);
2247                 } break;
2248                 case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
2249                     dst.eRenderCoreFamily = readTokValue<decltype(dst.eRenderCoreFamily)>(*tok);
2250                 } break;
2251                 case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
2252                     dst.ePlatformType = readTokValue<decltype(dst.ePlatformType)>(*tok);
2253                 } break;
2254                 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
2255                     dst.usDeviceID = readTokValue<decltype(dst.usDeviceID)>(*tok);
2256                 } break;
2257                 case TOK_FBW_PLATFORM_STR__US_REV_ID: {
2258                     dst.usRevId = readTokValue<decltype(dst.usRevId)>(*tok);
2259                 } break;
2260                 case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
2261                     dst.usDeviceID_PCH = readTokValue<decltype(dst.usDeviceID_PCH)>(*tok);
2262                 } break;
2263                 case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
2264                     dst.usRevId_PCH = readTokValue<decltype(dst.usRevId_PCH)>(*tok);
2265                 } break;
2266                 case TOK_FE_PLATFORM_STR__E_GTTYPE: {
2267                     dst.eGTType = readTokValue<decltype(dst.eGTType)>(*tok);
2268                 } break;
2269                 };
2270                 tok = tok + 1 + tok->valueDwordCount;
2271             } else {
2272                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
2273                 switch (tok->id) {
2274                 default:
2275                     if (tok->flags.flag3IsMandatory) {
2276                         return false;
2277                     }
2278                     break;
2279                 case TOK_S_PLATFORM_STR:
2280                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
2281                         return false;
2282                     }
2283                     break;
2284                 };
2285                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2286             }
2287         }
2288         WCH_ASSERT(tok == srcTokensEnd);
2289         return true;
2290     }
2291 };
2292 
2293 template <>
2294 struct Demarshaller<TOK_S_KMD_CAPS_INFO> {
2295     template <typename __KMD_CAPS_INFOT>
2296     static bool demarshall(__KMD_CAPS_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
2297         const TokenHeader *tok = srcTokensBeg;
2298         while (tok < srcTokensEnd) {
2299             if (false == tok->flags.flag4IsVariableLength) {
2300                 switch (tok->id) {
2301                 default:
2302                     if (tok->flags.flag3IsMandatory) {
2303                         return false;
2304                     }
2305                     break;
2306                 case TOK_FBD_KMD_CAPS_INFO__GAMMA_RGB256X3X16: {
2307                     dst.Gamma_Rgb256x3x16 = readTokValue<decltype(dst.Gamma_Rgb256x3x16)>(*tok);
2308                 } break;
2309                 case TOK_FBD_KMD_CAPS_INFO__GDIACCELERATION: {
2310                     dst.GDIAcceleration = readTokValue<decltype(dst.GDIAcceleration)>(*tok);
2311                 } break;
2312                 case TOK_FBD_KMD_CAPS_INFO__OS_MANAGED_HW_CONTEXT: {
2313                     dst.OsManagedHwContext = readTokValue<decltype(dst.OsManagedHwContext)>(*tok);
2314                 } break;
2315                 case TOK_FBD_KMD_CAPS_INFO__GRAPHICS_PREEMPTION_GRANULARITY: {
2316                     dst.GraphicsPreemptionGranularity = readTokValue<decltype(dst.GraphicsPreemptionGranularity)>(*tok);
2317                 } break;
2318                 case TOK_FBD_KMD_CAPS_INFO__COMPUTE_PREEMPTION_GRANULARITY: {
2319                     dst.ComputePreemptionGranularity = readTokValue<decltype(dst.ComputePreemptionGranularity)>(*tok);
2320                 } break;
2321                 case TOK_FBD_KMD_CAPS_INFO__INSTRUMENTATION_IS_ENABLED: {
2322                     dst.InstrumentationIsEnabled = readTokValue<decltype(dst.InstrumentationIsEnabled)>(*tok);
2323                 } break;
2324                 case TOK_FBD_KMD_CAPS_INFO__DRIVER_STORE_ENABLED: {
2325                     dst.DriverStoreEnabled = readTokValue<decltype(dst.DriverStoreEnabled)>(*tok);
2326                 } break;
2327                 };
2328                 tok = tok + 1 + tok->valueDwordCount;
2329             } else {
2330                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
2331                 switch (tok->id) {
2332                 default:
2333                     if (tok->flags.flag3IsMandatory) {
2334                         return false;
2335                     }
2336                     break;
2337                 case TOK_S_KMD_CAPS_INFO:
2338                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
2339                         return false;
2340                     }
2341                     break;
2342                 };
2343                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2344             }
2345         }
2346         WCH_ASSERT(tok == srcTokensEnd);
2347         return true;
2348     }
2349 };
2350 
2351 template <>
2352 struct Demarshaller<TOK_S_KMD_OVERLAY_OVERRIDE> {
2353     template <typename __KMD_OVERLAY_OVERRIDET>
2354     static bool demarshall(__KMD_OVERLAY_OVERRIDET &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
2355         const TokenHeader *tok = srcTokensBeg;
2356         while (tok < srcTokensEnd) {
2357             if (false == tok->flags.flag4IsVariableLength) {
2358                 switch (tok->id) {
2359                 default:
2360                     if (tok->flags.flag3IsMandatory) {
2361                         return false;
2362                     }
2363                     break;
2364                 case TOK_FBD_KMD_OVERLAY_OVERRIDE__OVERRIDE_OVERLAY_CAPS: {
2365                     dst.OverrideOverlayCaps = readTokValue<decltype(dst.OverrideOverlayCaps)>(*tok);
2366                 } break;
2367                 case TOK_FBD_KMD_OVERLAY_OVERRIDE__RGBOVERLAY: {
2368                     dst.RGBOverlay = readTokValue<decltype(dst.RGBOverlay)>(*tok);
2369                 } break;
2370                 case TOK_FBD_KMD_OVERLAY_OVERRIDE__YUY2OVERLAY: {
2371                     dst.YUY2Overlay = readTokValue<decltype(dst.YUY2Overlay)>(*tok);
2372                 } break;
2373                 };
2374                 tok = tok + 1 + tok->valueDwordCount;
2375             } else {
2376                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
2377                 switch (tok->id) {
2378                 default:
2379                     if (tok->flags.flag3IsMandatory) {
2380                         return false;
2381                     }
2382                     break;
2383                 case TOK_S_KMD_OVERLAY_OVERRIDE:
2384                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
2385                         return false;
2386                     }
2387                     break;
2388                 };
2389                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2390             }
2391         }
2392         WCH_ASSERT(tok == srcTokensEnd);
2393         return true;
2394     }
2395 };
2396 
2397 template <>
2398 struct Demarshaller<TOK_S_KMD_OVERLAY_CAPS_INFO> {
2399     template <typename __KMD_OVERLAY_CAPS_INFOT>
2400     static bool demarshall(__KMD_OVERLAY_CAPS_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
2401         const TokenHeader *tok = srcTokensBeg;
2402         while (tok < srcTokensEnd) {
2403             if (false == tok->flags.flag4IsVariableLength) {
2404                 switch (tok->id) {
2405                 default:
2406                     if (tok->flags.flag3IsMandatory) {
2407                         return false;
2408                     }
2409                     break;
2410                 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS_VALUE: {
2411                     dst.CapsValue = readTokValue<decltype(dst.CapsValue)>(*tok);
2412                 } break;
2413                 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_WIDTH: {
2414                     dst.MaxOverlayDisplayWidth = readTokValue<decltype(dst.MaxOverlayDisplayWidth)>(*tok);
2415                 } break;
2416                 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_HEIGHT: {
2417                     dst.MaxOverlayDisplayHeight = readTokValue<decltype(dst.MaxOverlayDisplayHeight)>(*tok);
2418                 } break;
2419                 case TOK_FBC_KMD_OVERLAY_CAPS_INFO__HWSCALER_EXISTS: {
2420                     dst.HWScalerExists = readTokValue<decltype(dst.HWScalerExists)>(*tok);
2421                 } break;
2422                 case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_HWSCALER_STRIDE: {
2423                     dst.MaxHWScalerStride = readTokValue<decltype(dst.MaxHWScalerStride)>(*tok);
2424                 } break;
2425                 };
2426                 tok = tok + 1 + tok->valueDwordCount;
2427             } else {
2428                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
2429                 switch (tok->id) {
2430                 default:
2431                     if (tok->flags.flag3IsMandatory) {
2432                         return false;
2433                     }
2434                     break;
2435                 case TOK_S_KMD_OVERLAY_CAPS_INFO:
2436                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
2437                         return false;
2438                     }
2439                     break;
2440                 case TOK_FS_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS: {
2441                     const TokenHeader *tokCaps = varLen->getValue<TokenHeader>();
2442                     const TokenHeader *tokCapsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
2443                     while (tokCaps < tokCapsEnd) {
2444                         if (false == tokCaps->flags.flag4IsVariableLength) {
2445                             switch (tokCaps->id) {
2446                             default:
2447                                 if (tokCaps->flags.flag3IsMandatory) {
2448                                     return false;
2449                                 }
2450                                 break;
2451                             case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__FULL_RANGE_RGB: {
2452                                 dst.Caps.FullRangeRGB = readTokValue<decltype(dst.Caps.FullRangeRGB)>(*tokCaps);
2453                             } break;
2454                             case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__LIMITED_RANGE_RGB: {
2455                                 dst.Caps.LimitedRangeRGB = readTokValue<decltype(dst.Caps.LimitedRangeRGB)>(*tokCaps);
2456                             } break;
2457                             case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601: {
2458                                 dst.Caps.YCbCr_BT601 = readTokValue<decltype(dst.Caps.YCbCr_BT601)>(*tokCaps);
2459                             } break;
2460                             case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709: {
2461                                 dst.Caps.YCbCr_BT709 = readTokValue<decltype(dst.Caps.YCbCr_BT709)>(*tokCaps);
2462                             } break;
2463                             case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601_XV_YCC: {
2464                                 dst.Caps.YCbCr_BT601_xvYCC = readTokValue<decltype(dst.Caps.YCbCr_BT601_xvYCC)>(*tokCaps);
2465                             } break;
2466                             case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709_XV_YCC: {
2467                                 dst.Caps.YCbCr_BT709_xvYCC = readTokValue<decltype(dst.Caps.YCbCr_BT709_xvYCC)>(*tokCaps);
2468                             } break;
2469                             case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_X: {
2470                                 dst.Caps.StretchX = readTokValue<decltype(dst.Caps.StretchX)>(*tokCaps);
2471                             } break;
2472                             case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_Y: {
2473                                 dst.Caps.StretchY = readTokValue<decltype(dst.Caps.StretchY)>(*tokCaps);
2474                             } break;
2475                             };
2476                             tokCaps = tokCaps + 1 + tokCaps->valueDwordCount;
2477                         } else {
2478                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCaps);
2479                             if (tokCaps->flags.flag3IsMandatory) {
2480                                 return false;
2481                             }
2482                             tokCaps = tokCaps + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2483                         }
2484                     }
2485                     WCH_ASSERT(tokCaps == tokCapsEnd);
2486                 } break;
2487                 case TOK_FS_KMD_OVERLAY_CAPS_INFO__OVOVERRIDE: {
2488                     const TokenHeader *tokOVOverride = varLen->getValue<TokenHeader>();
2489                     const TokenHeader *tokOVOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
2490                     while (tokOVOverride < tokOVOverrideEnd) {
2491                         if (false == tokOVOverride->flags.flag4IsVariableLength) {
2492                             switch (tokOVOverride->id) {
2493                             default:
2494                                 if (tokOVOverride->flags.flag3IsMandatory) {
2495                                     return false;
2496                                 }
2497                                 break;
2498                             case TOK_FBD_KMD_OVERLAY_OVERRIDE__OVERRIDE_OVERLAY_CAPS: {
2499                                 dst.OVOverride.OverrideOverlayCaps = readTokValue<decltype(dst.OVOverride.OverrideOverlayCaps)>(*tokOVOverride);
2500                             } break;
2501                             case TOK_FBD_KMD_OVERLAY_OVERRIDE__RGBOVERLAY: {
2502                                 dst.OVOverride.RGBOverlay = readTokValue<decltype(dst.OVOverride.RGBOverlay)>(*tokOVOverride);
2503                             } break;
2504                             case TOK_FBD_KMD_OVERLAY_OVERRIDE__YUY2OVERLAY: {
2505                                 dst.OVOverride.YUY2Overlay = readTokValue<decltype(dst.OVOverride.YUY2Overlay)>(*tokOVOverride);
2506                             } break;
2507                             };
2508                             tokOVOverride = tokOVOverride + 1 + tokOVOverride->valueDwordCount;
2509                         } else {
2510                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOVOverride);
2511                             if (tokOVOverride->flags.flag3IsMandatory) {
2512                                 return false;
2513                             }
2514                             tokOVOverride = tokOVOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2515                         }
2516                     }
2517                     WCH_ASSERT(tokOVOverride == tokOVOverrideEnd);
2518                 } break;
2519                 };
2520                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2521             }
2522         }
2523         WCH_ASSERT(tok == srcTokensEnd);
2524         return true;
2525     }
2526 };
2527 
2528 template <>
2529 struct Demarshaller<TOK_S_FRAME_RATE> {
2530     template <typename FRAME_RATET>
2531     static bool demarshall(FRAME_RATET &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
2532         const TokenHeader *tok = srcTokensBeg;
2533         while (tok < srcTokensEnd) {
2534             if (false == tok->flags.flag4IsVariableLength) {
2535                 switch (tok->id) {
2536                 default:
2537                     if (tok->flags.flag3IsMandatory) {
2538                         return false;
2539                     }
2540                     break;
2541                 case TOK_FBD_FRAME_RATE__UI_NUMERATOR: {
2542                     dst.uiNumerator = readTokValue<decltype(dst.uiNumerator)>(*tok);
2543                 } break;
2544                 case TOK_FBD_FRAME_RATE__UI_DENOMINATOR: {
2545                     dst.uiDenominator = readTokValue<decltype(dst.uiDenominator)>(*tok);
2546                 } break;
2547                 };
2548                 tok = tok + 1 + tok->valueDwordCount;
2549             } else {
2550                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
2551                 switch (tok->id) {
2552                 default:
2553                     if (tok->flags.flag3IsMandatory) {
2554                         return false;
2555                     }
2556                     break;
2557                 case TOK_S_FRAME_RATE:
2558                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
2559                         return false;
2560                     }
2561                     break;
2562                 };
2563                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2564             }
2565         }
2566         WCH_ASSERT(tok == srcTokensEnd);
2567         return true;
2568     }
2569 };
2570 
2571 template <>
2572 struct Demarshaller<TOK_S_KM_DEFERRED_WAIT_INFO> {
2573     template <typename _KM_DEFERRED_WAIT_INFOT>
2574     static bool demarshall(_KM_DEFERRED_WAIT_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
2575         const TokenHeader *tok = srcTokensBeg;
2576         while (tok < srcTokensEnd) {
2577             if (false == tok->flags.flag4IsVariableLength) {
2578                 switch (tok->id) {
2579                 default:
2580                     if (tok->flags.flag3IsMandatory) {
2581                         return false;
2582                     }
2583                     break;
2584                 case TOK_FBD_KM_DEFERRED_WAIT_INFO__FEATURE_SUPPORTED: {
2585                     dst.FeatureSupported = readTokValue<decltype(dst.FeatureSupported)>(*tok);
2586                 } break;
2587                 case TOK_FBD_KM_DEFERRED_WAIT_INFO__ACTIVE_DISPLAY: {
2588                     dst.ActiveDisplay = readTokValue<decltype(dst.ActiveDisplay)>(*tok);
2589                 } break;
2590                 };
2591                 tok = tok + 1 + tok->valueDwordCount;
2592             } else {
2593                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
2594                 switch (tok->id) {
2595                 default:
2596                     if (tok->flags.flag3IsMandatory) {
2597                         return false;
2598                     }
2599                     break;
2600                 case TOK_S_KM_DEFERRED_WAIT_INFO:
2601                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
2602                         return false;
2603                     }
2604                     break;
2605                 };
2606                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2607             }
2608         }
2609         WCH_ASSERT(tok == srcTokensEnd);
2610         return true;
2611     }
2612 };
2613 
2614 template <>
2615 struct Demarshaller<TOK_S_GMM_GFX_PARTITIONING> {
2616     template <typename __GMM_GFX_PARTITIONINGT>
2617     static bool demarshall(__GMM_GFX_PARTITIONINGT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
2618         const TokenHeader *tok = srcTokensBeg;
2619         while (tok < srcTokensEnd) {
2620             if (false == tok->flags.flag4IsVariableLength) {
2621                 if (tok->flags.flag3IsMandatory) {
2622                     return false;
2623                 }
2624                 tok = tok + 1 + tok->valueDwordCount;
2625             } else {
2626                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
2627                 switch (tok->id) {
2628                 default:
2629                     if (tok->flags.flag3IsMandatory) {
2630                         return false;
2631                     }
2632                     break;
2633                 case TOK_S_GMM_GFX_PARTITIONING:
2634                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
2635                         return false;
2636                     }
2637                     break;
2638                 case TOK_FS_GMM_GFX_PARTITIONING__STANDARD: {
2639                     const TokenHeader *tokStandard = varLen->getValue<TokenHeader>();
2640                     const TokenHeader *tokStandardEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
2641                     while (tokStandard < tokStandardEnd) {
2642                         if (false == tokStandard->flags.flag4IsVariableLength) {
2643                             switch (tokStandard->id) {
2644                             default:
2645                                 if (tokStandard->flags.flag3IsMandatory) {
2646                                     return false;
2647                                 }
2648                                 break;
2649                             case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: {
2650                                 dst.Standard.Base = readTokValue<decltype(dst.Standard.Base)>(*tokStandard);
2651                             } break;
2652                             case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: {
2653                                 dst.Standard.Limit = readTokValue<decltype(dst.Standard.Limit)>(*tokStandard);
2654                             } break;
2655                             };
2656                             tokStandard = tokStandard + 1 + tokStandard->valueDwordCount;
2657                         } else {
2658                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokStandard);
2659                             if (tokStandard->flags.flag3IsMandatory) {
2660                                 return false;
2661                             }
2662                             tokStandard = tokStandard + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2663                         }
2664                     }
2665                     WCH_ASSERT(tokStandard == tokStandardEnd);
2666                 } break;
2667                 case TOK_FS_GMM_GFX_PARTITIONING__STANDARD64KB: {
2668                     const TokenHeader *tokStandard64KB = varLen->getValue<TokenHeader>();
2669                     const TokenHeader *tokStandard64KBEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
2670                     while (tokStandard64KB < tokStandard64KBEnd) {
2671                         if (false == tokStandard64KB->flags.flag4IsVariableLength) {
2672                             switch (tokStandard64KB->id) {
2673                             default:
2674                                 if (tokStandard64KB->flags.flag3IsMandatory) {
2675                                     return false;
2676                                 }
2677                                 break;
2678                             case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: {
2679                                 dst.Standard64KB.Base = readTokValue<decltype(dst.Standard64KB.Base)>(*tokStandard64KB);
2680                             } break;
2681                             case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: {
2682                                 dst.Standard64KB.Limit = readTokValue<decltype(dst.Standard64KB.Limit)>(*tokStandard64KB);
2683                             } break;
2684                             };
2685                             tokStandard64KB = tokStandard64KB + 1 + tokStandard64KB->valueDwordCount;
2686                         } else {
2687                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokStandard64KB);
2688                             if (tokStandard64KB->flags.flag3IsMandatory) {
2689                                 return false;
2690                             }
2691                             tokStandard64KB = tokStandard64KB + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2692                         }
2693                     }
2694                     WCH_ASSERT(tokStandard64KB == tokStandard64KBEnd);
2695                 } break;
2696                 case TOK_FS_GMM_GFX_PARTITIONING__SVM: {
2697                     const TokenHeader *tokSVM = varLen->getValue<TokenHeader>();
2698                     const TokenHeader *tokSVMEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
2699                     while (tokSVM < tokSVMEnd) {
2700                         if (false == tokSVM->flags.flag4IsVariableLength) {
2701                             switch (tokSVM->id) {
2702                             default:
2703                                 if (tokSVM->flags.flag3IsMandatory) {
2704                                     return false;
2705                                 }
2706                                 break;
2707                             case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: {
2708                                 dst.SVM.Base = readTokValue<decltype(dst.SVM.Base)>(*tokSVM);
2709                             } break;
2710                             case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: {
2711                                 dst.SVM.Limit = readTokValue<decltype(dst.SVM.Limit)>(*tokSVM);
2712                             } break;
2713                             };
2714                             tokSVM = tokSVM + 1 + tokSVM->valueDwordCount;
2715                         } else {
2716                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSVM);
2717                             if (tokSVM->flags.flag3IsMandatory) {
2718                                 return false;
2719                             }
2720                             tokSVM = tokSVM + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2721                         }
2722                     }
2723                     WCH_ASSERT(tokSVM == tokSVMEnd);
2724                 } break;
2725                 case TOK_FS_GMM_GFX_PARTITIONING__HEAP32: {
2726                     uint32_t arrayElementIdHeap32 = varLen->arrayElementId;
2727                     const TokenHeader *tokHeap32 = varLen->getValue<TokenHeader>();
2728                     const TokenHeader *tokHeap32End = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
2729                     while (tokHeap32 < tokHeap32End) {
2730                         if (false == tokHeap32->flags.flag4IsVariableLength) {
2731                             switch (tokHeap32->id) {
2732                             default:
2733                                 if (tokHeap32->flags.flag3IsMandatory) {
2734                                     return false;
2735                                 }
2736                                 break;
2737                             case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: {
2738                                 dst.Heap32[arrayElementIdHeap32].Base = readTokValue<decltype(dst.Heap32[arrayElementIdHeap32].Base)>(*tokHeap32);
2739                             } break;
2740                             case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: {
2741                                 dst.Heap32[arrayElementIdHeap32].Limit = readTokValue<decltype(dst.Heap32[arrayElementIdHeap32].Limit)>(*tokHeap32);
2742                             } break;
2743                             };
2744                             tokHeap32 = tokHeap32 + 1 + tokHeap32->valueDwordCount;
2745                         } else {
2746                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokHeap32);
2747                             if (tokHeap32->flags.flag3IsMandatory) {
2748                                 return false;
2749                             }
2750                             tokHeap32 = tokHeap32 + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2751                         }
2752                     }
2753                     WCH_ASSERT(tokHeap32 == tokHeap32End);
2754                 } break;
2755                 };
2756                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2757             }
2758         }
2759         WCH_ASSERT(tok == srcTokensEnd);
2760         return true;
2761     }
2762 };
2763 
2764 template <>
2765 struct Demarshaller<TOK_S_ADAPTER_BDF> {
2766     template <typename _ADAPTER_BDF_T>
2767     static bool demarshall(_ADAPTER_BDF_T &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
2768         const TokenHeader *tok = srcTokensBeg;
2769         while (tok < srcTokensEnd) {
2770             if (false == tok->flags.flag4IsVariableLength) {
2771                 switch (tok->id) {
2772                 default:
2773                     if (tok->flags.flag3IsMandatory) {
2774                         return false;
2775                     }
2776                     break;
2777                 case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__BUS: {
2778                     dst.Bus = readTokValue<decltype(dst.Bus)>(*tok);
2779                 } break;
2780                 case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__DEVICE: {
2781                     dst.Device = readTokValue<decltype(dst.Device)>(*tok);
2782                 } break;
2783                 case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__FUNCTION: {
2784                     dst.Function = readTokValue<decltype(dst.Function)>(*tok);
2785                 } break;
2786                 case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__DATA: {
2787                     dst.Data = readTokValue<decltype(dst.Data)>(*tok);
2788                 } break;
2789                 };
2790                 tok = tok + 1 + tok->valueDwordCount;
2791             } else {
2792                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
2793                 switch (tok->id) {
2794                 default:
2795                     if (tok->flags.flag3IsMandatory) {
2796                         return false;
2797                     }
2798                     break;
2799                 case TOK_S_ADAPTER_BDF:
2800                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
2801                         return false;
2802                     }
2803                     break;
2804                 };
2805                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2806             }
2807         }
2808         WCH_ASSERT(tok == srcTokensEnd);
2809         return true;
2810     }
2811 };
2812 
2813 template <>
2814 struct Demarshaller<TOK_S_ADAPTER_INFO> {
2815     template <typename _ADAPTER_INFOT>
2816     static bool demarshall(_ADAPTER_INFOT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
2817         const TokenHeader *tok = srcTokensBeg;
2818         while (tok < srcTokensEnd) {
2819             if (false == tok->flags.flag4IsVariableLength) {
2820                 switch (tok->id) {
2821                 default:
2822                     if (tok->flags.flag3IsMandatory) {
2823                         return false;
2824                     }
2825                     break;
2826                 case TOK_FBD_ADAPTER_INFO__KMD_VERSION_INFO: {
2827                     dst.KmdVersionInfo = readTokValue<decltype(dst.KmdVersionInfo)>(*tok);
2828                 } break;
2829                 case TOK_FBC_ADAPTER_INFO__DEVICE_REGISTRY_PATH: {
2830                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tok).getValue<char>();
2831                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tok).getValueSizeInBytes();
2832                     if (srcSize < sizeof(dst.DeviceRegistryPath)) {
2833                         return false;
2834                     }
2835                     WCH_SAFE_COPY(dst.DeviceRegistryPath, sizeof(dst.DeviceRegistryPath), srcData, sizeof(dst.DeviceRegistryPath));
2836                 } break;
2837                 case TOK_FBD_ADAPTER_INFO__GFX_TIME_STAMP_FREQ: {
2838                     dst.GfxTimeStampFreq = readTokValue<decltype(dst.GfxTimeStampFreq)>(*tok);
2839                 } break;
2840                 case TOK_FBD_ADAPTER_INFO__GFX_CORE_FREQUENCY: {
2841                     dst.GfxCoreFrequency = readTokValue<decltype(dst.GfxCoreFrequency)>(*tok);
2842                 } break;
2843                 case TOK_FBD_ADAPTER_INFO__FSBFREQUENCY: {
2844                     dst.FSBFrequency = readTokValue<decltype(dst.FSBFrequency)>(*tok);
2845                 } break;
2846                 case TOK_FBD_ADAPTER_INFO__MIN_RENDER_FREQ: {
2847                     dst.MinRenderFreq = readTokValue<decltype(dst.MinRenderFreq)>(*tok);
2848                 } break;
2849                 case TOK_FBD_ADAPTER_INFO__MAX_RENDER_FREQ: {
2850                     dst.MaxRenderFreq = readTokValue<decltype(dst.MaxRenderFreq)>(*tok);
2851                 } break;
2852                 case TOK_FBD_ADAPTER_INFO__PACKAGE_TDP: {
2853                     dst.PackageTdp = readTokValue<decltype(dst.PackageTdp)>(*tok);
2854                 } break;
2855                 case TOK_FBD_ADAPTER_INFO__MAX_FILL_RATE: {
2856                     dst.MaxFillRate = readTokValue<decltype(dst.MaxFillRate)>(*tok);
2857                 } break;
2858                 case TOK_FBD_ADAPTER_INFO__NUMBER_OF_EUS: {
2859                     dst.NumberOfEUs = readTokValue<decltype(dst.NumberOfEUs)>(*tok);
2860                 } break;
2861                 case TOK_FBD_ADAPTER_INFO__DW_RELEASE_TARGET: {
2862                     dst.dwReleaseTarget = readTokValue<decltype(dst.dwReleaseTarget)>(*tok);
2863                 } break;
2864                 case TOK_FBD_ADAPTER_INFO__SIZE_OF_DMA_BUFFER: {
2865                     dst.SizeOfDmaBuffer = readTokValue<decltype(dst.SizeOfDmaBuffer)>(*tok);
2866                 } break;
2867                 case TOK_FBD_ADAPTER_INFO__PATCH_LOCATION_LIST_SIZE: {
2868                     dst.PatchLocationListSize = readTokValue<decltype(dst.PatchLocationListSize)>(*tok);
2869                 } break;
2870                 case TOK_FBD_ADAPTER_INFO__ALLOCATION_LIST_SIZE: {
2871                     dst.AllocationListSize = readTokValue<decltype(dst.AllocationListSize)>(*tok);
2872                 } break;
2873                 case TOK_FBD_ADAPTER_INFO__SMALL_PATCH_LOCATION_LIST_SIZE: {
2874                     dst.SmallPatchLocationListSize = readTokValue<decltype(dst.SmallPatchLocationListSize)>(*tok);
2875                 } break;
2876                 case TOK_FBD_ADAPTER_INFO__DEFAULT_CMD_BUFFER_SIZE: {
2877                     dst.DefaultCmdBufferSize = readTokValue<decltype(dst.DefaultCmdBufferSize)>(*tok);
2878                 } break;
2879                 case TOK_FBQ_ADAPTER_INFO__GFX_MEMORY_SIZE: {
2880                     dst.GfxMemorySize = readTokValue<decltype(dst.GfxMemorySize)>(*tok);
2881                 } break;
2882                 case TOK_FBD_ADAPTER_INFO__SYSTEM_MEMORY_SIZE: {
2883                     dst.SystemMemorySize = readTokValue<decltype(dst.SystemMemorySize)>(*tok);
2884                 } break;
2885                 case TOK_FBD_ADAPTER_INFO__CACHE_LINE_SIZE: {
2886                     dst.CacheLineSize = readTokValue<decltype(dst.CacheLineSize)>(*tok);
2887                 } break;
2888                 case TOK_FE_ADAPTER_INFO__PROCESSOR_FAMILY: {
2889                     dst.ProcessorFamily = readTokValue<decltype(dst.ProcessorFamily)>(*tok);
2890                 } break;
2891                 case TOK_FBC_ADAPTER_INFO__IS_HTSUPPORTED: {
2892                     dst.IsHTSupported = readTokValue<decltype(dst.IsHTSupported)>(*tok);
2893                 } break;
2894                 case TOK_FBC_ADAPTER_INFO__IS_MUTI_CORE_CPU: {
2895                     dst.IsMutiCoreCpu = readTokValue<decltype(dst.IsMutiCoreCpu)>(*tok);
2896                 } break;
2897                 case TOK_FBC_ADAPTER_INFO__IS_VTDSUPPORTED: {
2898                     dst.IsVTDSupported = readTokValue<decltype(dst.IsVTDSupported)>(*tok);
2899                 } break;
2900                 case TOK_FBD_ADAPTER_INFO__REGISTRY_PATH_LENGTH: {
2901                     dst.RegistryPathLength = readTokValue<decltype(dst.RegistryPathLength)>(*tok);
2902                 } break;
2903                 case TOK_FBQ_ADAPTER_INFO__DEDICATED_VIDEO_MEMORY: {
2904                     dst.DedicatedVideoMemory = readTokValue<decltype(dst.DedicatedVideoMemory)>(*tok);
2905                 } break;
2906                 case TOK_FBQ_ADAPTER_INFO__SYSTEM_SHARED_MEMORY: {
2907                     dst.SystemSharedMemory = readTokValue<decltype(dst.SystemSharedMemory)>(*tok);
2908                 } break;
2909                 case TOK_FBQ_ADAPTER_INFO__SYSTEM_VIDEO_MEMORY: {
2910                     dst.SystemVideoMemory = readTokValue<decltype(dst.SystemVideoMemory)>(*tok);
2911                 } break;
2912                 };
2913                 tok = tok + 1 + tok->valueDwordCount;
2914             } else {
2915                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
2916                 switch (tok->id) {
2917                 default:
2918                     if (tok->flags.flag3IsMandatory) {
2919                         return false;
2920                     }
2921                     break;
2922                 case TOK_S_ADAPTER_INFO:
2923                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
2924                         return false;
2925                     }
2926                     break;
2927                 case TOK_FS_ADAPTER_INFO__GFX_PLATFORM: {
2928                     const TokenHeader *tokGfxPlatform = varLen->getValue<TokenHeader>();
2929                     const TokenHeader *tokGfxPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
2930                     while (tokGfxPlatform < tokGfxPlatformEnd) {
2931                         if (false == tokGfxPlatform->flags.flag4IsVariableLength) {
2932                             switch (tokGfxPlatform->id) {
2933                             default:
2934                                 if (tokGfxPlatform->flags.flag3IsMandatory) {
2935                                     return false;
2936                                 }
2937                                 break;
2938                             case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
2939                                 dst.GfxPlatform.eProductFamily = readTokValue<decltype(dst.GfxPlatform.eProductFamily)>(*tokGfxPlatform);
2940                             } break;
2941                             case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
2942                                 dst.GfxPlatform.ePCHProductFamily = readTokValue<decltype(dst.GfxPlatform.ePCHProductFamily)>(*tokGfxPlatform);
2943                             } break;
2944                             case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
2945                                 dst.GfxPlatform.eDisplayCoreFamily = readTokValue<decltype(dst.GfxPlatform.eDisplayCoreFamily)>(*tokGfxPlatform);
2946                             } break;
2947                             case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
2948                                 dst.GfxPlatform.eRenderCoreFamily = readTokValue<decltype(dst.GfxPlatform.eRenderCoreFamily)>(*tokGfxPlatform);
2949                             } break;
2950                             case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
2951                                 dst.GfxPlatform.ePlatformType = readTokValue<decltype(dst.GfxPlatform.ePlatformType)>(*tokGfxPlatform);
2952                             } break;
2953                             case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
2954                                 dst.GfxPlatform.usDeviceID = readTokValue<decltype(dst.GfxPlatform.usDeviceID)>(*tokGfxPlatform);
2955                             } break;
2956                             case TOK_FBW_PLATFORM_STR__US_REV_ID: {
2957                                 dst.GfxPlatform.usRevId = readTokValue<decltype(dst.GfxPlatform.usRevId)>(*tokGfxPlatform);
2958                             } break;
2959                             case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
2960                                 dst.GfxPlatform.usDeviceID_PCH = readTokValue<decltype(dst.GfxPlatform.usDeviceID_PCH)>(*tokGfxPlatform);
2961                             } break;
2962                             case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
2963                                 dst.GfxPlatform.usRevId_PCH = readTokValue<decltype(dst.GfxPlatform.usRevId_PCH)>(*tokGfxPlatform);
2964                             } break;
2965                             case TOK_FE_PLATFORM_STR__E_GTTYPE: {
2966                                 dst.GfxPlatform.eGTType = readTokValue<decltype(dst.GfxPlatform.eGTType)>(*tokGfxPlatform);
2967                             } break;
2968                             };
2969                             tokGfxPlatform = tokGfxPlatform + 1 + tokGfxPlatform->valueDwordCount;
2970                         } else {
2971                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGfxPlatform);
2972                             if (tokGfxPlatform->flags.flag3IsMandatory) {
2973                                 return false;
2974                             }
2975                             tokGfxPlatform = tokGfxPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
2976                         }
2977                     }
2978                     WCH_ASSERT(tokGfxPlatform == tokGfxPlatformEnd);
2979                 } break;
2980                 case TOK_FS_ADAPTER_INFO__SKU_TABLE: {
2981                     const TokenHeader *tokSkuTable = varLen->getValue<TokenHeader>();
2982                     const TokenHeader *tokSkuTableEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
2983                     while (tokSkuTable < tokSkuTableEnd) {
2984                         if (false == tokSkuTable->flags.flag4IsVariableLength) {
2985                             switch (tokSkuTable->id) {
2986                             default:
2987                                 if (tokSkuTable->flags.flag3IsMandatory) {
2988                                     return false;
2989                                 }
2990                                 break;
2991                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_DESKTOP: {
2992                                 dst.SkuTable.FtrDesktop = readTokValue<decltype(dst.SkuTable.FtrDesktop)>(*tokSkuTable);
2993                             } break;
2994                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VERING: {
2995                                 dst.SkuTable.FtrVERing = readTokValue<decltype(dst.SkuTable.FtrVERing)>(*tokSkuTable);
2996                             } break;
2997                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_VCS2: {
2998                                 dst.SkuTable.FtrVcs2 = readTokValue<decltype(dst.SkuTable.FtrVcs2)>(*tokSkuTable);
2999                             } break;
3000                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_BIG_DIE: {
3001                                 dst.SkuTable.FtrGtBigDie = readTokValue<decltype(dst.SkuTable.FtrGtBigDie)>(*tokSkuTable);
3002                             } break;
3003                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_MEDIUM_DIE: {
3004                                 dst.SkuTable.FtrGtMediumDie = readTokValue<decltype(dst.SkuTable.FtrGtMediumDie)>(*tokSkuTable);
3005                             } break;
3006                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT_SMALL_DIE: {
3007                                 dst.SkuTable.FtrGtSmallDie = readTokValue<decltype(dst.SkuTable.FtrGtSmallDie)>(*tokSkuTable);
3008                             } break;
3009                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1: {
3010                                 dst.SkuTable.FtrGT1 = readTokValue<decltype(dst.SkuTable.FtrGT1)>(*tokSkuTable);
3011                             } break;
3012                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT1_5: {
3013                                 dst.SkuTable.FtrGT1_5 = readTokValue<decltype(dst.SkuTable.FtrGT1_5)>(*tokSkuTable);
3014                             } break;
3015                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2: {
3016                                 dst.SkuTable.FtrGT2 = readTokValue<decltype(dst.SkuTable.FtrGT2)>(*tokSkuTable);
3017                             } break;
3018                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT2_5: {
3019                                 dst.SkuTable.FtrGT2_5 = readTokValue<decltype(dst.SkuTable.FtrGT2_5)>(*tokSkuTable);
3020                             } break;
3021                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT3: {
3022                                 dst.SkuTable.FtrGT3 = readTokValue<decltype(dst.SkuTable.FtrGT3)>(*tokSkuTable);
3023                             } break;
3024                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GT4: {
3025                                 dst.SkuTable.FtrGT4 = readTokValue<decltype(dst.SkuTable.FtrGT4)>(*tokSkuTable);
3026                             } break;
3027                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_ULT: {
3028                                 dst.SkuTable.FtrULT = readTokValue<decltype(dst.SkuTable.FtrULT)>(*tokSkuTable);
3029                             } break;
3030                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_IVBM0M1PLATFORM: {
3031                                 dst.SkuTable.FtrIVBM0M1Platform = readTokValue<decltype(dst.SkuTable.FtrIVBM0M1Platform)>(*tokSkuTable);
3032                             } break;
3033                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CHANNEL_SWIZZLING_XORENABLED: {
3034                                 dst.SkuTable.FtrChannelSwizzlingXOREnabled = readTokValue<decltype(dst.SkuTable.FtrChannelSwizzlingXOREnabled)>(*tokSkuTable);
3035                             } break;
3036                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTA: {
3037                                 dst.SkuTable.FtrGTA = readTokValue<decltype(dst.SkuTable.FtrGTA)>(*tokSkuTable);
3038                             } break;
3039                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTC: {
3040                                 dst.SkuTable.FtrGTC = readTokValue<decltype(dst.SkuTable.FtrGTC)>(*tokSkuTable);
3041                             } break;
3042                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_GTX: {
3043                                 dst.SkuTable.FtrGTX = readTokValue<decltype(dst.SkuTable.FtrGTX)>(*tokSkuTable);
3044                             } break;
3045                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR5SLICE: {
3046                                 dst.SkuTable.Ftr5Slice = readTokValue<decltype(dst.SkuTable.Ftr5Slice)>(*tokSkuTable);
3047                             } break;
3048                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_LCIA: {
3049                                 dst.SkuTable.FtrLCIA = readTokValue<decltype(dst.SkuTable.FtrLCIA)>(*tokSkuTable);
3050                             } break;
3051                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_RESOURCE_STREAMER: {
3052                                 dst.SkuTable.FtrResourceStreamer = readTokValue<decltype(dst.SkuTable.FtrResourceStreamer)>(*tokSkuTable);
3053                             } break;
3054                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSRING: {
3055                                 dst.SkuTable.FtrCCSRing = readTokValue<decltype(dst.SkuTable.FtrCCSRing)>(*tokSkuTable);
3056                             } break;
3057                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSNODE: {
3058                                 dst.SkuTable.FtrCCSNode = readTokValue<decltype(dst.SkuTable.FtrCCSNode)>(*tokSkuTable);
3059                             } break;
3060                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS3245__FTR_CCSMULTI_INSTANCE: {
3061                                 dst.SkuTable.FtrCCSMultiInstance = readTokValue<decltype(dst.SkuTable.FtrCCSMultiInstance)>(*tokSkuTable);
3062                             } break;
3063                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_DISPLAY_DISABLED: {
3064                                 dst.SkuTable.FtrDisplayDisabled = readTokValue<decltype(dst.SkuTable.FtrDisplayDisabled)>(*tokSkuTable);
3065                             } break;
3066                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS11155__FTR_SGTPVSKUSTRAP_PRESENT: {
3067                                 dst.SkuTable.FtrSGTPVSKUStrapPresent = readTokValue<decltype(dst.SkuTable.FtrSGTPVSKUStrapPresent)>(*tokSkuTable);
3068                             } break;
3069                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21584__FTR_POOLED_EU_ENABLED: {
3070                                 dst.SkuTable.FtrPooledEuEnabled = readTokValue<decltype(dst.SkuTable.FtrPooledEuEnabled)>(*tokSkuTable);
3071                             } break;
3072                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_BATCH_PREEMPT: {
3073                                 dst.SkuTable.FtrGpGpuMidBatchPreempt = readTokValue<decltype(dst.SkuTable.FtrGpGpuMidBatchPreempt)>(*tokSkuTable);
3074                             } break;
3075                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_THREAD_GROUP_LEVEL_PREEMPT: {
3076                                 dst.SkuTable.FtrGpGpuThreadGroupLevelPreempt = readTokValue<decltype(dst.SkuTable.FtrGpGpuThreadGroupLevelPreempt)>(*tokSkuTable);
3077                             } break;
3078                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GP_GPU_MID_THREAD_LEVEL_PREEMPT: {
3079                                 dst.SkuTable.FtrGpGpuMidThreadLevelPreempt = readTokValue<decltype(dst.SkuTable.FtrGpGpuMidThreadLevelPreempt)>(*tokSkuTable);
3080                             } break;
3081                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_MID_BATCH_PREEMPT: {
3082                                 dst.SkuTable.Ftr3dMidBatchPreempt = readTokValue<decltype(dst.SkuTable.Ftr3dMidBatchPreempt)>(*tokSkuTable);
3083                             } break;
3084                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR3D_OBJECT_LEVEL_PREEMPT: {
3085                                 dst.SkuTable.Ftr3dObjectLevelPreempt = readTokValue<decltype(dst.SkuTable.Ftr3dObjectLevelPreempt)>(*tokSkuTable);
3086                             } break;
3087                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: {
3088                                 dst.SkuTable.FtrPerCtxtPreemptionGranularityControl = readTokValue<decltype(dst.SkuTable.FtrPerCtxtPreemptionGranularityControl)>(*tokSkuTable);
3089                             } break;
3090                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT: {
3091                                 dst.SkuTable.FtrPPGTT = readTokValue<decltype(dst.SkuTable.FtrPPGTT)>(*tokSkuTable);
3092                             } break;
3093                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IA32E_GFX_PTES: {
3094                                 dst.SkuTable.FtrIA32eGfxPTEs = readTokValue<decltype(dst.SkuTable.FtrIA32eGfxPTEs)>(*tokSkuTable);
3095                             } break;
3096                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MEM_TYPE_MOCS_DEFER_PAT: {
3097                                 dst.SkuTable.FtrMemTypeMocsDeferPAT = readTokValue<decltype(dst.SkuTable.FtrMemTypeMocsDeferPAT)>(*tokSkuTable);
3098                             } break;
3099                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PML4SUPPORT: {
3100                                 dst.SkuTable.FtrPml4Support = readTokValue<decltype(dst.SkuTable.FtrPml4Support)>(*tokSkuTable);
3101                             } break;
3102                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_SVM: {
3103                                 dst.SkuTable.FtrSVM = readTokValue<decltype(dst.SkuTable.FtrSVM)>(*tokSkuTable);
3104                             } break;
3105                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_MAPPED_RESOURCE: {
3106                                 dst.SkuTable.FtrTileMappedResource = readTokValue<decltype(dst.SkuTable.FtrTileMappedResource)>(*tokSkuTable);
3107                             } break;
3108                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TRANSLATION_TABLE: {
3109                                 dst.SkuTable.FtrTranslationTable = readTokValue<decltype(dst.SkuTable.FtrTranslationTable)>(*tokSkuTable);
3110                             } break;
3111                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_USER_MODE_TRANSLATION_TABLE: {
3112                                 dst.SkuTable.FtrUserModeTranslationTable = readTokValue<decltype(dst.SkuTable.FtrUserModeTranslationTable)>(*tokSkuTable);
3113                             } break;
3114                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_NULL_PAGES: {
3115                                 dst.SkuTable.FtrNullPages = readTokValue<decltype(dst.SkuTable.FtrNullPages)>(*tokSkuTable);
3116                             } break;
3117                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_L3IACOHERENCY: {
3118                                 dst.SkuTable.FtrL3IACoherency = readTokValue<decltype(dst.SkuTable.FtrL3IACoherency)>(*tokSkuTable);
3119                             } break;
3120                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_EDRAM: {
3121                                 dst.SkuTable.FtrEDram = readTokValue<decltype(dst.SkuTable.FtrEDram)>(*tokSkuTable);
3122                             } break;
3123                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LLCBYPASS: {
3124                                 dst.SkuTable.FtrLLCBypass = readTokValue<decltype(dst.SkuTable.FtrLLCBypass)>(*tokSkuTable);
3125                             } break;
3126                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CRYSTALWELL: {
3127                                 dst.SkuTable.FtrCrystalwell = readTokValue<decltype(dst.SkuTable.FtrCrystalwell)>(*tokSkuTable);
3128                             } break;
3129                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CENTRAL_CACHE_POLICY: {
3130                                 dst.SkuTable.FtrCentralCachePolicy = readTokValue<decltype(dst.SkuTable.FtrCentralCachePolicy)>(*tokSkuTable);
3131                             } break;
3132                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_IO_MMU_PAGE_FAULTING: {
3133                                 dst.SkuTable.FtrIoMmuPageFaulting = readTokValue<decltype(dst.SkuTable.FtrIoMmuPageFaulting)>(*tokSkuTable);
3134                             } break;
3135                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2GPU_MMU: {
3136                                 dst.SkuTable.FtrWddm2GpuMmu = readTokValue<decltype(dst.SkuTable.FtrWddm2GpuMmu)>(*tokSkuTable);
3137                             } break;
3138                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2SVM: {
3139                                 dst.SkuTable.FtrWddm2Svm = readTokValue<decltype(dst.SkuTable.FtrWddm2Svm)>(*tokSkuTable);
3140                             } break;
3141                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_STANDARD_MIP_TAIL_FORMAT: {
3142                                 dst.SkuTable.FtrStandardMipTailFormat = readTokValue<decltype(dst.SkuTable.FtrStandardMipTailFormat)>(*tokSkuTable);
3143                             } break;
3144                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_WDDM2_1_64KB_PAGES: {
3145                                 dst.SkuTable.FtrWddm2_1_64kbPages = readTokValue<decltype(dst.SkuTable.FtrWddm2_1_64kbPages)>(*tokSkuTable);
3146                             } break;
3147                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_GTT_CACHE_INVALIDATION: {
3148                                 dst.SkuTable.FtrGttCacheInvalidation = readTokValue<decltype(dst.SkuTable.FtrGttCacheInvalidation)>(*tokSkuTable);
3149                             } break;
3150                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_E2ECOMPRESSION: {
3151                                 dst.SkuTable.FtrE2ECompression = readTokValue<decltype(dst.SkuTable.FtrE2ECompression)>(*tokSkuTable);
3152                             } break;
3153                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LINEAR_CCS: {
3154                                 dst.SkuTable.FtrLinearCCS = readTokValue<decltype(dst.SkuTable.FtrLinearCCS)>(*tokSkuTable);
3155                             } break;
3156                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY: {
3157                                 dst.SkuTable.FtrLocalMemory = readTokValue<decltype(dst.SkuTable.FtrLocalMemory)>(*tokSkuTable);
3158                             } break;
3159                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_PPGTT64KBWALK_OPTIMIZATION: {
3160                                 dst.SkuTable.FtrPpgtt64KBWalkOptimization = readTokValue<decltype(dst.SkuTable.FtrPpgtt64KBWalkOptimization)>(*tokSkuTable);
3161                             } break;
3162                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_TILE_Y: {
3163                                 dst.SkuTable.FtrTileY = readTokValue<decltype(dst.SkuTable.FtrTileY)>(*tokSkuTable);
3164                             } break;
3165                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FLAT_PHYS_CCS: {
3166                                 dst.SkuTable.FtrFlatPhysCCS = readTokValue<decltype(dst.SkuTable.FtrFlatPhysCCS)>(*tokSkuTable);
3167                             } break;
3168                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_MULTI_TILE_ARCH: {
3169                                 dst.SkuTable.FtrMultiTileArch = readTokValue<decltype(dst.SkuTable.FtrMultiTileArch)>(*tokSkuTable);
3170                             } break;
3171                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_LOCAL_MEMORY_ALLOWS4KB: {
3172                                 dst.SkuTable.FtrLocalMemoryAllows4KB = readTokValue<decltype(dst.SkuTable.FtrLocalMemoryAllows4KB)>(*tokSkuTable);
3173                             } break;
3174                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DISPLAY_XTILING: {
3175                                 dst.SkuTable.FtrDisplayXTiling = readTokValue<decltype(dst.SkuTable.FtrDisplayXTiling)>(*tokSkuTable);
3176                             } break;
3177                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_CAMERA_CAPTURE_CACHING: {
3178                                 dst.SkuTable.FtrCameraCaptureCaching = readTokValue<decltype(dst.SkuTable.FtrCameraCaptureCaching)>(*tokSkuTable);
3179                             } break;
3180                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_KMD_DAF: {
3181                                 dst.SkuTable.FtrKmdDaf = readTokValue<decltype(dst.SkuTable.FtrKmdDaf)>(*tokSkuTable);
3182                             } break;
3183                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_FRAME_BUFFER_LLC: {
3184                                 dst.SkuTable.FtrFrameBufferLLC = readTokValue<decltype(dst.SkuTable.FtrFrameBufferLLC)>(*tokSkuTable);
3185                             } break;
3186                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS21990__FTR_DRIVER_FLR: {
3187                                 dst.SkuTable.FtrDriverFLR = readTokValue<decltype(dst.SkuTable.FtrDriverFLR)>(*tokSkuTable);
3188                             } break;
3189                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_LDR2D: {
3190                                 dst.SkuTable.FtrAstcLdr2D = readTokValue<decltype(dst.SkuTable.FtrAstcLdr2D)>(*tokSkuTable);
3191                             } break;
3192                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC_HDR2D: {
3193                                 dst.SkuTable.FtrAstcHdr2D = readTokValue<decltype(dst.SkuTable.FtrAstcHdr2D)>(*tokSkuTable);
3194                             } break;
3195                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS37751__FTR_ASTC3D: {
3196                                 dst.SkuTable.FtrAstc3D = readTokValue<decltype(dst.SkuTable.FtrAstc3D)>(*tokSkuTable);
3197                             } break;
3198                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC: {
3199                                 dst.SkuTable.FtrFbc = readTokValue<decltype(dst.SkuTable.FtrFbc)>(*tokSkuTable);
3200                             } break;
3201                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC2ADDRESS_TRANSLATION: {
3202                                 dst.SkuTable.FtrFbc2AddressTranslation = readTokValue<decltype(dst.SkuTable.FtrFbc2AddressTranslation)>(*tokSkuTable);
3203                             } break;
3204                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_BLITTER_TRACKING: {
3205                                 dst.SkuTable.FtrFbcBlitterTracking = readTokValue<decltype(dst.SkuTable.FtrFbcBlitterTracking)>(*tokSkuTable);
3206                             } break;
3207                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_FBC_CPU_TRACKING: {
3208                                 dst.SkuTable.FtrFbcCpuTracking = readTokValue<decltype(dst.SkuTable.FtrFbcCpuTracking)>(*tokSkuTable);
3209                             } break;
3210                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS42853__FTR_VEBOX: {
3211                                 dst.SkuTable.FtrVEBOX = readTokValue<decltype(dst.SkuTable.FtrVEBOX)>(*tokSkuTable);
3212                             } break;
3213                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_REND_COMP: {
3214                                 dst.SkuTable.FtrRendComp = readTokValue<decltype(dst.SkuTable.FtrRendComp)>(*tokSkuTable);
3215                             } break;
3216                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS54736__FTR_DISPLAY_YTILING: {
3217                                 dst.SkuTable.FtrDisplayYTiling = readTokValue<decltype(dst.SkuTable.FtrDisplayYTiling)>(*tokSkuTable);
3218                             } break;
3219                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_S3D: {
3220                                 dst.SkuTable.FtrS3D = readTokValue<decltype(dst.SkuTable.FtrS3D)>(*tokSkuTable);
3221                             } break;
3222                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_DISPLAY_ENGINE_S3D: {
3223                                 dst.SkuTable.FtrDisplayEngineS3d = readTokValue<decltype(dst.SkuTable.FtrDisplayEngineS3d)>(*tokSkuTable);
3224                             } break;
3225                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SINGLE_VEBOX_SLICE: {
3226                                 dst.SkuTable.FtrSingleVeboxSlice = readTokValue<decltype(dst.SkuTable.FtrSingleVeboxSlice)>(*tokSkuTable);
3227                             } break;
3228                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS66219__FTR_SIMULATION_MODE: {
3229                                 dst.SkuTable.FtrSimulationMode = readTokValue<decltype(dst.SkuTable.FtrSimulationMode)>(*tokSkuTable);
3230                             } break;
3231                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS88095__FTR_ENABLE_GU_C: {
3232                                 dst.SkuTable.FtrEnableGuC = readTokValue<decltype(dst.SkuTable.FtrEnableGuC)>(*tokSkuTable);
3233                             } break;
3234                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS89755__FTR_VGT: {
3235                                 dst.SkuTable.FtrVgt = readTokValue<decltype(dst.SkuTable.FtrVgt)>(*tokSkuTable);
3236                             } break;
3237                             case TOK_FBD_SKU_FEATURE_TABLE__ANONYMOUS91822__FTR_ASSIGNED_GPU_TILE: {
3238                                 dst.SkuTable.FtrAssignedGpuTile = readTokValue<decltype(dst.SkuTable.FtrAssignedGpuTile)>(*tokSkuTable);
3239                             } break;
3240                             };
3241                             tokSkuTable = tokSkuTable + 1 + tokSkuTable->valueDwordCount;
3242                         } else {
3243                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSkuTable);
3244                             if (tokSkuTable->flags.flag3IsMandatory) {
3245                                 return false;
3246                             }
3247                             tokSkuTable = tokSkuTable + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
3248                         }
3249                     }
3250                     WCH_ASSERT(tokSkuTable == tokSkuTableEnd);
3251                 } break;
3252                 case TOK_FS_ADAPTER_INFO__WA_TABLE: {
3253                     const TokenHeader *tokWaTable = varLen->getValue<TokenHeader>();
3254                     const TokenHeader *tokWaTableEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
3255                     while (tokWaTable < tokWaTableEnd) {
3256                         if (false == tokWaTable->flags.flag4IsVariableLength) {
3257                             switch (tokWaTable->id) {
3258                             default:
3259                                 if (tokWaTable->flags.flag3IsMandatory) {
3260                                     return false;
3261                                 }
3262                                 break;
3263                             case TOK_FBD_WA_TABLE__WA_DO_NOT_USE_MIREPORT_PERF_COUNT: {
3264                                 dst.WaTable.WaDoNotUseMIReportPerfCount = readTokValue<decltype(dst.WaTable.WaDoNotUseMIReportPerfCount)>(*tokWaTable);
3265                             } break;
3266                             case TOK_FBD_WA_TABLE__WA_ALIGN_INDEX_BUFFER: {
3267                                 dst.WaTable.WaAlignIndexBuffer = readTokValue<decltype(dst.WaTable.WaAlignIndexBuffer)>(*tokWaTable);
3268                             } break;
3269                             case TOK_FBD_WA_TABLE__WA_SEND_MIFLUSHBEFORE_VFE: {
3270                                 dst.WaTable.WaSendMIFLUSHBeforeVFE = readTokValue<decltype(dst.WaTable.WaSendMIFLUSHBeforeVFE)>(*tokWaTable);
3271                             } break;
3272                             case TOK_FBD_WA_TABLE__WA_DISABLE_PER_CTXT_PREEMPTION_GRANULARITY_CONTROL: {
3273                                 dst.WaTable.WaDisablePerCtxtPreemptionGranularityControl = readTokValue<decltype(dst.WaTable.WaDisablePerCtxtPreemptionGranularityControl)>(*tokWaTable);
3274                             } break;
3275                             case TOK_FBD_WA_TABLE__WA_ENABLE_PREEMPTION_GRANULARITY_CONTROL_BY_UMD: {
3276                                 dst.WaTable.WaEnablePreemptionGranularityControlByUMD = readTokValue<decltype(dst.WaTable.WaEnablePreemptionGranularityControlByUMD)>(*tokWaTable);
3277                             } break;
3278                             case TOK_FBD_WA_TABLE__WA_DISABLE_LSQCROPERFFOR_OCL: {
3279                                 dst.WaTable.WaDisableLSQCROPERFforOCL = readTokValue<decltype(dst.WaTable.WaDisableLSQCROPERFforOCL)>(*tokWaTable);
3280                             } break;
3281                             case TOK_FBD_WA_TABLE__WA_VALIGN2FOR96BPP_FORMATS: {
3282                                 dst.WaTable.WaValign2For96bppFormats = readTokValue<decltype(dst.WaTable.WaValign2For96bppFormats)>(*tokWaTable);
3283                             } break;
3284                             case TOK_FBD_WA_TABLE__WA_VALIGN2FOR_R8G8B8UINTFORMAT: {
3285                                 dst.WaTable.WaValign2ForR8G8B8UINTFormat = readTokValue<decltype(dst.WaTable.WaValign2ForR8G8B8UINTFormat)>(*tokWaTable);
3286                             } break;
3287                             case TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_USE_GLOBAL_CONTEXT_ID: {
3288                                 dst.WaTable.WaReportPerfCountUseGlobalContextID = readTokValue<decltype(dst.WaTable.WaReportPerfCountUseGlobalContextID)>(*tokWaTable);
3289                             } break;
3290                             case TOK_FBD_WA_TABLE__WA_FORCE_PC_BB_FULL_CFG_RESTORE: {
3291                                 dst.WaTable.WaForcePcBbFullCfgRestore = readTokValue<decltype(dst.WaTable.WaForcePcBbFullCfgRestore)>(*tokWaTable);
3292                             } break;
3293                             case TOK_FBD_WA_TABLE__WA_CSRUNCACHABLE: {
3294                                 dst.WaTable.WaCSRUncachable = readTokValue<decltype(dst.WaTable.WaCSRUncachable)>(*tokWaTable);
3295                             } break;
3296                             case TOK_FBD_WA_TABLE__WA_DISABLE_FUSED_THREAD_SCHEDULING: {
3297                                 dst.WaTable.WaDisableFusedThreadScheduling = readTokValue<decltype(dst.WaTable.WaDisableFusedThreadScheduling)>(*tokWaTable);
3298                             } break;
3299                             case TOK_FBD_WA_TABLE__WA_MODIFY_VFESTATE_AFTER_GPGPUPREEMPTION: {
3300                                 dst.WaTable.WaModifyVFEStateAfterGPGPUPreemption = readTokValue<decltype(dst.WaTable.WaModifyVFEStateAfterGPGPUPreemption)>(*tokWaTable);
3301                             } break;
3302                             case TOK_FBD_WA_TABLE__WA_CURSOR16K: {
3303                                 dst.WaTable.WaCursor16K = readTokValue<decltype(dst.WaTable.WaCursor16K)>(*tokWaTable);
3304                             } break;
3305                             case TOK_FBD_WA_TABLE__WA8K_ALIGNFOR_ASYNC_FLIP: {
3306                                 dst.WaTable.Wa8kAlignforAsyncFlip = readTokValue<decltype(dst.WaTable.Wa8kAlignforAsyncFlip)>(*tokWaTable);
3307                             } break;
3308                             case TOK_FBD_WA_TABLE__WA29BIT_DISPLAY_ADDR_LIMIT: {
3309                                 dst.WaTable.Wa29BitDisplayAddrLimit = readTokValue<decltype(dst.WaTable.Wa29BitDisplayAddrLimit)>(*tokWaTable);
3310                             } break;
3311                             case TOK_FBD_WA_TABLE__WA_ALIGN_CONTEXT_IMAGE: {
3312                                 dst.WaTable.WaAlignContextImage = readTokValue<decltype(dst.WaTable.WaAlignContextImage)>(*tokWaTable);
3313                             } break;
3314                             case TOK_FBD_WA_TABLE__WA_FORCE_GLOBAL_GTT: {
3315                                 dst.WaTable.WaForceGlobalGTT = readTokValue<decltype(dst.WaTable.WaForceGlobalGTT)>(*tokWaTable);
3316                             } break;
3317                             case TOK_FBD_WA_TABLE__WA_REPORT_PERF_COUNT_FORCE_GLOBAL_GTT: {
3318                                 dst.WaTable.WaReportPerfCountForceGlobalGTT = readTokValue<decltype(dst.WaTable.WaReportPerfCountForceGlobalGTT)>(*tokWaTable);
3319                             } break;
3320                             case TOK_FBD_WA_TABLE__WA_OA_ADDRESS_TRANSLATION: {
3321                                 dst.WaTable.WaOaAddressTranslation = readTokValue<decltype(dst.WaTable.WaOaAddressTranslation)>(*tokWaTable);
3322                             } break;
3323                             case TOK_FBD_WA_TABLE__WA2ROW_VERTICAL_ALIGNMENT: {
3324                                 dst.WaTable.Wa2RowVerticalAlignment = readTokValue<decltype(dst.WaTable.Wa2RowVerticalAlignment)>(*tokWaTable);
3325                             } break;
3326                             case TOK_FBD_WA_TABLE__WA_PPGTT_ALIAS_GLOBAL_GTT_SPACE: {
3327                                 dst.WaTable.WaPpgttAliasGlobalGttSpace = readTokValue<decltype(dst.WaTable.WaPpgttAliasGlobalGttSpace)>(*tokWaTable);
3328                             } break;
3329                             case TOK_FBD_WA_TABLE__WA_CLEAR_FENCE_REGISTERS_AT_DRIVER_INIT: {
3330                                 dst.WaTable.WaClearFenceRegistersAtDriverInit = readTokValue<decltype(dst.WaTable.WaClearFenceRegistersAtDriverInit)>(*tokWaTable);
3331                             } break;
3332                             case TOK_FBD_WA_TABLE__WA_RESTRICT_PITCH128KB: {
3333                                 dst.WaTable.WaRestrictPitch128KB = readTokValue<decltype(dst.WaTable.WaRestrictPitch128KB)>(*tokWaTable);
3334                             } break;
3335                             case TOK_FBD_WA_TABLE__WA_AVOID_LLC: {
3336                                 dst.WaTable.WaAvoidLLC = readTokValue<decltype(dst.WaTable.WaAvoidLLC)>(*tokWaTable);
3337                             } break;
3338                             case TOK_FBD_WA_TABLE__WA_AVOID_L3: {
3339                                 dst.WaTable.WaAvoidL3 = readTokValue<decltype(dst.WaTable.WaAvoidL3)>(*tokWaTable);
3340                             } break;
3341                             case TOK_FBD_WA_TABLE__WA16TILE_FENCES_ONLY: {
3342                                 dst.WaTable.Wa16TileFencesOnly = readTokValue<decltype(dst.WaTable.Wa16TileFencesOnly)>(*tokWaTable);
3343                             } break;
3344                             case TOK_FBD_WA_TABLE__WA16MBOABUFFER_ALIGNMENT: {
3345                                 dst.WaTable.Wa16MBOABufferAlignment = readTokValue<decltype(dst.WaTable.Wa16MBOABufferAlignment)>(*tokWaTable);
3346                             } break;
3347                             case TOK_FBD_WA_TABLE__WA_TRANSLATION_TABLE_UNAVAILABLE: {
3348                                 dst.WaTable.WaTranslationTableUnavailable = readTokValue<decltype(dst.WaTable.WaTranslationTableUnavailable)>(*tokWaTable);
3349                             } break;
3350                             case TOK_FBD_WA_TABLE__WA_NO_MINIMIZED_TRIVIAL_SURFACE_PADDING: {
3351                                 dst.WaTable.WaNoMinimizedTrivialSurfacePadding = readTokValue<decltype(dst.WaTable.WaNoMinimizedTrivialSurfacePadding)>(*tokWaTable);
3352                             } break;
3353                             case TOK_FBD_WA_TABLE__WA_NO_BUFFER_SAMPLER_PADDING: {
3354                                 dst.WaTable.WaNoBufferSamplerPadding = readTokValue<decltype(dst.WaTable.WaNoBufferSamplerPadding)>(*tokWaTable);
3355                             } break;
3356                             case TOK_FBD_WA_TABLE__WA_SURFACE_STATE_PLANAR_YOFFSET_ALIGN_BY2: {
3357                                 dst.WaTable.WaSurfaceStatePlanarYOffsetAlignBy2 = readTokValue<decltype(dst.WaTable.WaSurfaceStatePlanarYOffsetAlignBy2)>(*tokWaTable);
3358                             } break;
3359                             case TOK_FBD_WA_TABLE__WA_GTT_CACHING_OFF_BY_DEFAULT: {
3360                                 dst.WaTable.WaGttCachingOffByDefault = readTokValue<decltype(dst.WaTable.WaGttCachingOffByDefault)>(*tokWaTable);
3361                             } break;
3362                             case TOK_FBD_WA_TABLE__WA_TOUCH_ALL_SVM_MEMORY: {
3363                                 dst.WaTable.WaTouchAllSvmMemory = readTokValue<decltype(dst.WaTable.WaTouchAllSvmMemory)>(*tokWaTable);
3364                             } break;
3365                             case TOK_FBD_WA_TABLE__WA_IOBADDRESS_MUST_BE_VALID_IN_HW_CONTEXT: {
3366                                 dst.WaTable.WaIOBAddressMustBeValidInHwContext = readTokValue<decltype(dst.WaTable.WaIOBAddressMustBeValidInHwContext)>(*tokWaTable);
3367                             } break;
3368                             case TOK_FBD_WA_TABLE__WA_FLUSH_TLB_AFTER_CPU_GGTT_WRITES: {
3369                                 dst.WaTable.WaFlushTlbAfterCpuGgttWrites = readTokValue<decltype(dst.WaTable.WaFlushTlbAfterCpuGgttWrites)>(*tokWaTable);
3370                             } break;
3371                             case TOK_FBD_WA_TABLE__WA_MSAA8X_TILE_YDEPTH_PITCH_ALIGNMENT: {
3372                                 dst.WaTable.WaMsaa8xTileYDepthPitchAlignment = readTokValue<decltype(dst.WaTable.WaMsaa8xTileYDepthPitchAlignment)>(*tokWaTable);
3373                             } break;
3374                             case TOK_FBD_WA_TABLE__WA_DISABLE_NULL_PAGE_AS_DUMMY: {
3375                                 dst.WaTable.WaDisableNullPageAsDummy = readTokValue<decltype(dst.WaTable.WaDisableNullPageAsDummy)>(*tokWaTable);
3376                             } break;
3377                             case TOK_FBD_WA_TABLE__WA_USE_VALIGN16ON_TILE_XYBPP816: {
3378                                 dst.WaTable.WaUseVAlign16OnTileXYBpp816 = readTokValue<decltype(dst.WaTable.WaUseVAlign16OnTileXYBpp816)>(*tokWaTable);
3379                             } break;
3380                             case TOK_FBD_WA_TABLE__WA_GTT_PAT0: {
3381                                 dst.WaTable.WaGttPat0 = readTokValue<decltype(dst.WaTable.WaGttPat0)>(*tokWaTable);
3382                             } break;
3383                             case TOK_FBD_WA_TABLE__WA_GTT_PAT0WB: {
3384                                 dst.WaTable.WaGttPat0WB = readTokValue<decltype(dst.WaTable.WaGttPat0WB)>(*tokWaTable);
3385                             } break;
3386                             case TOK_FBD_WA_TABLE__WA_MEM_TYPE_IS_MAX_OF_PAT_AND_MOCS: {
3387                                 dst.WaTable.WaMemTypeIsMaxOfPatAndMocs = readTokValue<decltype(dst.WaTable.WaMemTypeIsMaxOfPatAndMocs)>(*tokWaTable);
3388                             } break;
3389                             case TOK_FBD_WA_TABLE__WA_GTT_PAT0GTT_WB_OVER_OS_IOMMU_ELLC_ONLY: {
3390                                 dst.WaTable.WaGttPat0GttWbOverOsIommuEllcOnly = readTokValue<decltype(dst.WaTable.WaGttPat0GttWbOverOsIommuEllcOnly)>(*tokWaTable);
3391                             } break;
3392                             case TOK_FBD_WA_TABLE__WA_ADD_DUMMY_PAGE_FOR_DISPLAY_PREFETCH: {
3393                                 dst.WaTable.WaAddDummyPageForDisplayPrefetch = readTokValue<decltype(dst.WaTable.WaAddDummyPageForDisplayPrefetch)>(*tokWaTable);
3394                             } break;
3395                             case TOK_FBD_WA_TABLE__WA_DEFAULT_TILE4: {
3396                                 dst.WaTable.WaDefaultTile4 = readTokValue<decltype(dst.WaTable.WaDefaultTile4)>(*tokWaTable);
3397                             } break;
3398                             case TOK_FBD_WA_TABLE__WA_LLCCACHING_UNSUPPORTED: {
3399                                 dst.WaTable.WaLLCCachingUnsupported = readTokValue<decltype(dst.WaTable.WaLLCCachingUnsupported)>(*tokWaTable);
3400                             } break;
3401                             case TOK_FBD_WA_TABLE__WA_DOUBLE_FAST_CLEAR_WIDTH_ALIGNMENT: {
3402                                 dst.WaTable.WaDoubleFastClearWidthAlignment = readTokValue<decltype(dst.WaTable.WaDoubleFastClearWidthAlignment)>(*tokWaTable);
3403                             } break;
3404                             case TOK_FBD_WA_TABLE__WA_COMPRESSED_RESOURCE_REQUIRES_CONST_VA21: {
3405                                 dst.WaTable.WaCompressedResourceRequiresConstVA21 = readTokValue<decltype(dst.WaTable.WaCompressedResourceRequiresConstVA21)>(*tokWaTable);
3406                             } break;
3407                             case TOK_FBD_WA_TABLE__WA_DISREGARD_PLATFORM_CHECKS: {
3408                                 dst.WaTable.WaDisregardPlatformChecks = readTokValue<decltype(dst.WaTable.WaDisregardPlatformChecks)>(*tokWaTable);
3409                             } break;
3410                             case TOK_FBD_WA_TABLE__WA_LOSSLESS_COMPRESSION_SURFACE_STRIDE: {
3411                                 dst.WaTable.WaLosslessCompressionSurfaceStride = readTokValue<decltype(dst.WaTable.WaLosslessCompressionSurfaceStride)>(*tokWaTable);
3412                             } break;
3413                             case TOK_FBD_WA_TABLE__WA_FBC_LINEAR_SURFACE_STRIDE: {
3414                                 dst.WaTable.WaFbcLinearSurfaceStride = readTokValue<decltype(dst.WaTable.WaFbcLinearSurfaceStride)>(*tokWaTable);
3415                             } break;
3416                             case TOK_FBD_WA_TABLE__WA4K_ALIGN_UVOFFSET_NV12LINEAR_SURFACE: {
3417                                 dst.WaTable.Wa4kAlignUVOffsetNV12LinearSurface = readTokValue<decltype(dst.WaTable.Wa4kAlignUVOffsetNV12LinearSurface)>(*tokWaTable);
3418                             } break;
3419                             case TOK_FBD_WA_TABLE__WA_ASTC_CORRUPTION_FOR_ODD_COMPRESSED_BLOCK_SIZE_X: {
3420                                 dst.WaTable.WaAstcCorruptionForOddCompressedBlockSizeX = readTokValue<decltype(dst.WaTable.WaAstcCorruptionForOddCompressedBlockSizeX)>(*tokWaTable);
3421                             } break;
3422                             case TOK_FBD_WA_TABLE__WA_AUX_TABLE16KGRANULAR: {
3423                                 dst.WaTable.WaAuxTable16KGranular = readTokValue<decltype(dst.WaTable.WaAuxTable16KGranular)>(*tokWaTable);
3424                             } break;
3425                             case TOK_FBD_WA_TABLE__WA_ENCRYPTED_EDRAM_ONLY_PARTIALS: {
3426                                 dst.WaTable.WaEncryptedEdramOnlyPartials = readTokValue<decltype(dst.WaTable.WaEncryptedEdramOnlyPartials)>(*tokWaTable);
3427                             } break;
3428                             case TOK_FBD_WA_TABLE__WA_DISABLE_EDRAM_FOR_DISPLAY_RT: {
3429                                 dst.WaTable.WaDisableEdramForDisplayRT = readTokValue<decltype(dst.WaTable.WaDisableEdramForDisplayRT)>(*tokWaTable);
3430                             } break;
3431                             case TOK_FBD_WA_TABLE__WA_LIMIT128BMEDIA_COMPR: {
3432                                 dst.WaTable.WaLimit128BMediaCompr = readTokValue<decltype(dst.WaTable.WaLimit128BMediaCompr)>(*tokWaTable);
3433                             } break;
3434                             case TOK_FBD_WA_TABLE__WA_UNTYPED_BUFFER_COMPRESSION: {
3435                                 dst.WaTable.WaUntypedBufferCompression = readTokValue<decltype(dst.WaTable.WaUntypedBufferCompression)>(*tokWaTable);
3436                             } break;
3437                             case TOK_FBD_WA_TABLE__WA_SAMPLER_CACHE_FLUSH_BETWEEN_REDESCRIBED_SURFACE_READS: {
3438                                 dst.WaTable.WaSamplerCacheFlushBetweenRedescribedSurfaceReads = readTokValue<decltype(dst.WaTable.WaSamplerCacheFlushBetweenRedescribedSurfaceReads)>(*tokWaTable);
3439                             } break;
3440                             case TOK_FBD_WA_TABLE__WA_ALIGN_YUVRESOURCE_TO_LCU: {
3441                                 dst.WaTable.WaAlignYUVResourceToLCU = readTokValue<decltype(dst.WaTable.WaAlignYUVResourceToLCU)>(*tokWaTable);
3442                             } break;
3443                             case TOK_FBD_WA_TABLE__WA32BPP_TILE_Y2DCOLOR_NO_HALIGN4: {
3444                                 dst.WaTable.Wa32bppTileY2DColorNoHAlign4 = readTokValue<decltype(dst.WaTable.Wa32bppTileY2DColorNoHAlign4)>(*tokWaTable);
3445                             } break;
3446                             };
3447                             tokWaTable = tokWaTable + 1 + tokWaTable->valueDwordCount;
3448                         } else {
3449                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWaTable);
3450                             if (tokWaTable->flags.flag3IsMandatory) {
3451                                 return false;
3452                             }
3453                             tokWaTable = tokWaTable + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
3454                         }
3455                     }
3456                     WCH_ASSERT(tokWaTable == tokWaTableEnd);
3457                 } break;
3458                 case TOK_FS_ADAPTER_INFO__OUTPUT_FRAME_RATE: {
3459                     const TokenHeader *tokOutputFrameRate = varLen->getValue<TokenHeader>();
3460                     const TokenHeader *tokOutputFrameRateEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
3461                     while (tokOutputFrameRate < tokOutputFrameRateEnd) {
3462                         if (false == tokOutputFrameRate->flags.flag4IsVariableLength) {
3463                             switch (tokOutputFrameRate->id) {
3464                             default:
3465                                 if (tokOutputFrameRate->flags.flag3IsMandatory) {
3466                                     return false;
3467                                 }
3468                                 break;
3469                             case TOK_FBD_FRAME_RATE__UI_NUMERATOR: {
3470                                 dst.OutputFrameRate.uiNumerator = readTokValue<decltype(dst.OutputFrameRate.uiNumerator)>(*tokOutputFrameRate);
3471                             } break;
3472                             case TOK_FBD_FRAME_RATE__UI_DENOMINATOR: {
3473                                 dst.OutputFrameRate.uiDenominator = readTokValue<decltype(dst.OutputFrameRate.uiDenominator)>(*tokOutputFrameRate);
3474                             } break;
3475                             };
3476                             tokOutputFrameRate = tokOutputFrameRate + 1 + tokOutputFrameRate->valueDwordCount;
3477                         } else {
3478                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOutputFrameRate);
3479                             if (tokOutputFrameRate->flags.flag3IsMandatory) {
3480                                 return false;
3481                             }
3482                             tokOutputFrameRate = tokOutputFrameRate + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
3483                         }
3484                     }
3485                     WCH_ASSERT(tokOutputFrameRate == tokOutputFrameRateEnd);
3486                 } break;
3487                 case TOK_FS_ADAPTER_INFO__INPUT_FRAME_RATE: {
3488                     const TokenHeader *tokInputFrameRate = varLen->getValue<TokenHeader>();
3489                     const TokenHeader *tokInputFrameRateEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
3490                     while (tokInputFrameRate < tokInputFrameRateEnd) {
3491                         if (false == tokInputFrameRate->flags.flag4IsVariableLength) {
3492                             switch (tokInputFrameRate->id) {
3493                             default:
3494                                 if (tokInputFrameRate->flags.flag3IsMandatory) {
3495                                     return false;
3496                                 }
3497                                 break;
3498                             case TOK_FBD_FRAME_RATE__UI_NUMERATOR: {
3499                                 dst.InputFrameRate.uiNumerator = readTokValue<decltype(dst.InputFrameRate.uiNumerator)>(*tokInputFrameRate);
3500                             } break;
3501                             case TOK_FBD_FRAME_RATE__UI_DENOMINATOR: {
3502                                 dst.InputFrameRate.uiDenominator = readTokValue<decltype(dst.InputFrameRate.uiDenominator)>(*tokInputFrameRate);
3503                             } break;
3504                             };
3505                             tokInputFrameRate = tokInputFrameRate + 1 + tokInputFrameRate->valueDwordCount;
3506                         } else {
3507                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInputFrameRate);
3508                             if (tokInputFrameRate->flags.flag3IsMandatory) {
3509                                 return false;
3510                             }
3511                             tokInputFrameRate = tokInputFrameRate + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
3512                         }
3513                     }
3514                     WCH_ASSERT(tokInputFrameRate == tokInputFrameRateEnd);
3515                 } break;
3516                 case TOK_FS_ADAPTER_INFO__CAPS: {
3517                     const TokenHeader *tokCaps = varLen->getValue<TokenHeader>();
3518                     const TokenHeader *tokCapsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
3519                     while (tokCaps < tokCapsEnd) {
3520                         if (false == tokCaps->flags.flag4IsVariableLength) {
3521                             switch (tokCaps->id) {
3522                             default:
3523                                 if (tokCaps->flags.flag3IsMandatory) {
3524                                     return false;
3525                                 }
3526                                 break;
3527                             case TOK_FBD_KMD_CAPS_INFO__GAMMA_RGB256X3X16: {
3528                                 dst.Caps.Gamma_Rgb256x3x16 = readTokValue<decltype(dst.Caps.Gamma_Rgb256x3x16)>(*tokCaps);
3529                             } break;
3530                             case TOK_FBD_KMD_CAPS_INFO__GDIACCELERATION: {
3531                                 dst.Caps.GDIAcceleration = readTokValue<decltype(dst.Caps.GDIAcceleration)>(*tokCaps);
3532                             } break;
3533                             case TOK_FBD_KMD_CAPS_INFO__OS_MANAGED_HW_CONTEXT: {
3534                                 dst.Caps.OsManagedHwContext = readTokValue<decltype(dst.Caps.OsManagedHwContext)>(*tokCaps);
3535                             } break;
3536                             case TOK_FBD_KMD_CAPS_INFO__GRAPHICS_PREEMPTION_GRANULARITY: {
3537                                 dst.Caps.GraphicsPreemptionGranularity = readTokValue<decltype(dst.Caps.GraphicsPreemptionGranularity)>(*tokCaps);
3538                             } break;
3539                             case TOK_FBD_KMD_CAPS_INFO__COMPUTE_PREEMPTION_GRANULARITY: {
3540                                 dst.Caps.ComputePreemptionGranularity = readTokValue<decltype(dst.Caps.ComputePreemptionGranularity)>(*tokCaps);
3541                             } break;
3542                             case TOK_FBD_KMD_CAPS_INFO__INSTRUMENTATION_IS_ENABLED: {
3543                                 dst.Caps.InstrumentationIsEnabled = readTokValue<decltype(dst.Caps.InstrumentationIsEnabled)>(*tokCaps);
3544                             } break;
3545                             case TOK_FBD_KMD_CAPS_INFO__DRIVER_STORE_ENABLED: {
3546                                 dst.Caps.DriverStoreEnabled = readTokValue<decltype(dst.Caps.DriverStoreEnabled)>(*tokCaps);
3547                             } break;
3548                             };
3549                             tokCaps = tokCaps + 1 + tokCaps->valueDwordCount;
3550                         } else {
3551                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCaps);
3552                             if (tokCaps->flags.flag3IsMandatory) {
3553                                 return false;
3554                             }
3555                             tokCaps = tokCaps + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
3556                         }
3557                     }
3558                     WCH_ASSERT(tokCaps == tokCapsEnd);
3559                 } break;
3560                 case TOK_FS_ADAPTER_INFO__OVERLAY_CAPS: {
3561                     const TokenHeader *tokOverlayCaps = varLen->getValue<TokenHeader>();
3562                     const TokenHeader *tokOverlayCapsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
3563                     while (tokOverlayCaps < tokOverlayCapsEnd) {
3564                         if (false == tokOverlayCaps->flags.flag4IsVariableLength) {
3565                             switch (tokOverlayCaps->id) {
3566                             default:
3567                                 if (tokOverlayCaps->flags.flag3IsMandatory) {
3568                                     return false;
3569                                 }
3570                                 break;
3571                             case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS_VALUE: {
3572                                 dst.OverlayCaps.CapsValue = readTokValue<decltype(dst.OverlayCaps.CapsValue)>(*tokOverlayCaps);
3573                             } break;
3574                             case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_WIDTH: {
3575                                 dst.OverlayCaps.MaxOverlayDisplayWidth = readTokValue<decltype(dst.OverlayCaps.MaxOverlayDisplayWidth)>(*tokOverlayCaps);
3576                             } break;
3577                             case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_OVERLAY_DISPLAY_HEIGHT: {
3578                                 dst.OverlayCaps.MaxOverlayDisplayHeight = readTokValue<decltype(dst.OverlayCaps.MaxOverlayDisplayHeight)>(*tokOverlayCaps);
3579                             } break;
3580                             case TOK_FBC_KMD_OVERLAY_CAPS_INFO__HWSCALER_EXISTS: {
3581                                 dst.OverlayCaps.HWScalerExists = readTokValue<decltype(dst.OverlayCaps.HWScalerExists)>(*tokOverlayCaps);
3582                             } break;
3583                             case TOK_FBD_KMD_OVERLAY_CAPS_INFO__MAX_HWSCALER_STRIDE: {
3584                                 dst.OverlayCaps.MaxHWScalerStride = readTokValue<decltype(dst.OverlayCaps.MaxHWScalerStride)>(*tokOverlayCaps);
3585                             } break;
3586                             };
3587                             tokOverlayCaps = tokOverlayCaps + 1 + tokOverlayCaps->valueDwordCount;
3588                         } else {
3589                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOverlayCaps);
3590                             switch (tokOverlayCaps->id) {
3591                             default:
3592                                 if (tokOverlayCaps->flags.flag3IsMandatory) {
3593                                     return false;
3594                                 }
3595                                 break;
3596                             case TOK_FS_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__CAPS: {
3597                                 const TokenHeader *tokCaps = varLen->getValue<TokenHeader>();
3598                                 const TokenHeader *tokCapsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
3599                                 while (tokCaps < tokCapsEnd) {
3600                                     if (false == tokCaps->flags.flag4IsVariableLength) {
3601                                         switch (tokCaps->id) {
3602                                         default:
3603                                             if (tokCaps->flags.flag3IsMandatory) {
3604                                                 return false;
3605                                             }
3606                                             break;
3607                                         case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__FULL_RANGE_RGB: {
3608                                             dst.OverlayCaps.Caps.FullRangeRGB = readTokValue<decltype(dst.OverlayCaps.Caps.FullRangeRGB)>(*tokCaps);
3609                                         } break;
3610                                         case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__LIMITED_RANGE_RGB: {
3611                                             dst.OverlayCaps.Caps.LimitedRangeRGB = readTokValue<decltype(dst.OverlayCaps.Caps.LimitedRangeRGB)>(*tokCaps);
3612                                         } break;
3613                                         case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601: {
3614                                             dst.OverlayCaps.Caps.YCbCr_BT601 = readTokValue<decltype(dst.OverlayCaps.Caps.YCbCr_BT601)>(*tokCaps);
3615                                         } break;
3616                                         case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709: {
3617                                             dst.OverlayCaps.Caps.YCbCr_BT709 = readTokValue<decltype(dst.OverlayCaps.Caps.YCbCr_BT709)>(*tokCaps);
3618                                         } break;
3619                                         case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT601_XV_YCC: {
3620                                             dst.OverlayCaps.Caps.YCbCr_BT601_xvYCC = readTokValue<decltype(dst.OverlayCaps.Caps.YCbCr_BT601_xvYCC)>(*tokCaps);
3621                                         } break;
3622                                         case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__YCB_CR_BT709_XV_YCC: {
3623                                             dst.OverlayCaps.Caps.YCbCr_BT709_xvYCC = readTokValue<decltype(dst.OverlayCaps.Caps.YCbCr_BT709_xvYCC)>(*tokCaps);
3624                                         } break;
3625                                         case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_X: {
3626                                             dst.OverlayCaps.Caps.StretchX = readTokValue<decltype(dst.OverlayCaps.Caps.StretchX)>(*tokCaps);
3627                                         } break;
3628                                         case TOK_FBD_KMD_OVERLAY_CAPS_INFO__ANONYMOUS5171__ANONYMOUS5191__STRETCH_Y: {
3629                                             dst.OverlayCaps.Caps.StretchY = readTokValue<decltype(dst.OverlayCaps.Caps.StretchY)>(*tokCaps);
3630                                         } break;
3631                                         };
3632                                         tokCaps = tokCaps + 1 + tokCaps->valueDwordCount;
3633                                     } else {
3634                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCaps);
3635                                         if (tokCaps->flags.flag3IsMandatory) {
3636                                             return false;
3637                                         }
3638                                         tokCaps = tokCaps + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
3639                                     }
3640                                 }
3641                                 WCH_ASSERT(tokCaps == tokCapsEnd);
3642                             } break;
3643                             case TOK_FS_KMD_OVERLAY_CAPS_INFO__OVOVERRIDE: {
3644                                 const TokenHeader *tokOVOverride = varLen->getValue<TokenHeader>();
3645                                 const TokenHeader *tokOVOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
3646                                 while (tokOVOverride < tokOVOverrideEnd) {
3647                                     if (false == tokOVOverride->flags.flag4IsVariableLength) {
3648                                         switch (tokOVOverride->id) {
3649                                         default:
3650                                             if (tokOVOverride->flags.flag3IsMandatory) {
3651                                                 return false;
3652                                             }
3653                                             break;
3654                                         case TOK_FBD_KMD_OVERLAY_OVERRIDE__OVERRIDE_OVERLAY_CAPS: {
3655                                             dst.OverlayCaps.OVOverride.OverrideOverlayCaps = readTokValue<decltype(dst.OverlayCaps.OVOverride.OverrideOverlayCaps)>(*tokOVOverride);
3656                                         } break;
3657                                         case TOK_FBD_KMD_OVERLAY_OVERRIDE__RGBOVERLAY: {
3658                                             dst.OverlayCaps.OVOverride.RGBOverlay = readTokValue<decltype(dst.OverlayCaps.OVOverride.RGBOverlay)>(*tokOVOverride);
3659                                         } break;
3660                                         case TOK_FBD_KMD_OVERLAY_OVERRIDE__YUY2OVERLAY: {
3661                                             dst.OverlayCaps.OVOverride.YUY2Overlay = readTokValue<decltype(dst.OverlayCaps.OVOverride.YUY2Overlay)>(*tokOVOverride);
3662                                         } break;
3663                                         };
3664                                         tokOVOverride = tokOVOverride + 1 + tokOVOverride->valueDwordCount;
3665                                     } else {
3666                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOVOverride);
3667                                         if (tokOVOverride->flags.flag3IsMandatory) {
3668                                             return false;
3669                                         }
3670                                         tokOVOverride = tokOVOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
3671                                     }
3672                                 }
3673                                 WCH_ASSERT(tokOVOverride == tokOVOverrideEnd);
3674                             } break;
3675                             };
3676                             tokOverlayCaps = tokOverlayCaps + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
3677                         }
3678                     }
3679                     WCH_ASSERT(tokOverlayCaps == tokOverlayCapsEnd);
3680                 } break;
3681                 case TOK_FS_ADAPTER_INFO__SYSTEM_INFO: {
3682                     const TokenHeader *tokSystemInfo = varLen->getValue<TokenHeader>();
3683                     const TokenHeader *tokSystemInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
3684                     while (tokSystemInfo < tokSystemInfoEnd) {
3685                         if (false == tokSystemInfo->flags.flag4IsVariableLength) {
3686                             switch (tokSystemInfo->id) {
3687                             default:
3688                                 if (tokSystemInfo->flags.flag3IsMandatory) {
3689                                     return false;
3690                                 }
3691                                 break;
3692                             case TOK_FBD_GT_SYSTEM_INFO__EUCOUNT: {
3693                                 dst.SystemInfo.EUCount = readTokValue<decltype(dst.SystemInfo.EUCount)>(*tokSystemInfo);
3694                             } break;
3695                             case TOK_FBD_GT_SYSTEM_INFO__THREAD_COUNT: {
3696                                 dst.SystemInfo.ThreadCount = readTokValue<decltype(dst.SystemInfo.ThreadCount)>(*tokSystemInfo);
3697                             } break;
3698                             case TOK_FBD_GT_SYSTEM_INFO__SLICE_COUNT: {
3699                                 dst.SystemInfo.SliceCount = readTokValue<decltype(dst.SystemInfo.SliceCount)>(*tokSystemInfo);
3700                             } break;
3701                             case TOK_FBD_GT_SYSTEM_INFO__SUB_SLICE_COUNT: {
3702                                 dst.SystemInfo.SubSliceCount = readTokValue<decltype(dst.SystemInfo.SubSliceCount)>(*tokSystemInfo);
3703                             } break;
3704                             case TOK_FBD_GT_SYSTEM_INFO__DUAL_SUB_SLICE_COUNT: {
3705                                 dst.SystemInfo.DualSubSliceCount = readTokValue<decltype(dst.SystemInfo.DualSubSliceCount)>(*tokSystemInfo);
3706                             } break;
3707                             case TOK_FBQ_GT_SYSTEM_INFO__L3CACHE_SIZE_IN_KB: {
3708                                 dst.SystemInfo.L3CacheSizeInKb = readTokValue<decltype(dst.SystemInfo.L3CacheSizeInKb)>(*tokSystemInfo);
3709                             } break;
3710                             case TOK_FBQ_GT_SYSTEM_INFO__LLCCACHE_SIZE_IN_KB: {
3711                                 dst.SystemInfo.LLCCacheSizeInKb = readTokValue<decltype(dst.SystemInfo.LLCCacheSizeInKb)>(*tokSystemInfo);
3712                             } break;
3713                             case TOK_FBQ_GT_SYSTEM_INFO__EDRAM_SIZE_IN_KB: {
3714                                 dst.SystemInfo.EdramSizeInKb = readTokValue<decltype(dst.SystemInfo.EdramSizeInKb)>(*tokSystemInfo);
3715                             } break;
3716                             case TOK_FBD_GT_SYSTEM_INFO__L3BANK_COUNT: {
3717                                 dst.SystemInfo.L3BankCount = readTokValue<decltype(dst.SystemInfo.L3BankCount)>(*tokSystemInfo);
3718                             } break;
3719                             case TOK_FBD_GT_SYSTEM_INFO__MAX_FILL_RATE: {
3720                                 dst.SystemInfo.MaxFillRate = readTokValue<decltype(dst.SystemInfo.MaxFillRate)>(*tokSystemInfo);
3721                             } break;
3722                             case TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MAX: {
3723                                 dst.SystemInfo.EuCountPerPoolMax = readTokValue<decltype(dst.SystemInfo.EuCountPerPoolMax)>(*tokSystemInfo);
3724                             } break;
3725                             case TOK_FBD_GT_SYSTEM_INFO__EU_COUNT_PER_POOL_MIN: {
3726                                 dst.SystemInfo.EuCountPerPoolMin = readTokValue<decltype(dst.SystemInfo.EuCountPerPoolMin)>(*tokSystemInfo);
3727                             } break;
3728                             case TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS: {
3729                                 dst.SystemInfo.TotalVsThreads = readTokValue<decltype(dst.SystemInfo.TotalVsThreads)>(*tokSystemInfo);
3730                             } break;
3731                             case TOK_FBD_GT_SYSTEM_INFO__TOTAL_HS_THREADS: {
3732                                 dst.SystemInfo.TotalHsThreads = readTokValue<decltype(dst.SystemInfo.TotalHsThreads)>(*tokSystemInfo);
3733                             } break;
3734                             case TOK_FBD_GT_SYSTEM_INFO__TOTAL_DS_THREADS: {
3735                                 dst.SystemInfo.TotalDsThreads = readTokValue<decltype(dst.SystemInfo.TotalDsThreads)>(*tokSystemInfo);
3736                             } break;
3737                             case TOK_FBD_GT_SYSTEM_INFO__TOTAL_GS_THREADS: {
3738                                 dst.SystemInfo.TotalGsThreads = readTokValue<decltype(dst.SystemInfo.TotalGsThreads)>(*tokSystemInfo);
3739                             } break;
3740                             case TOK_FBD_GT_SYSTEM_INFO__TOTAL_PS_THREADS_WINDOWER_RANGE: {
3741                                 dst.SystemInfo.TotalPsThreadsWindowerRange = readTokValue<decltype(dst.SystemInfo.TotalPsThreadsWindowerRange)>(*tokSystemInfo);
3742                             } break;
3743                             case TOK_FBD_GT_SYSTEM_INFO__TOTAL_VS_THREADS_POCS: {
3744                                 dst.SystemInfo.TotalVsThreads_Pocs = readTokValue<decltype(dst.SystemInfo.TotalVsThreads_Pocs)>(*tokSystemInfo);
3745                             } break;
3746                             case TOK_FBD_GT_SYSTEM_INFO__CSR_SIZE_IN_MB: {
3747                                 dst.SystemInfo.CsrSizeInMb = readTokValue<decltype(dst.SystemInfo.CsrSizeInMb)>(*tokSystemInfo);
3748                             } break;
3749                             case TOK_FBD_GT_SYSTEM_INFO__MAX_EU_PER_SUB_SLICE: {
3750                                 dst.SystemInfo.MaxEuPerSubSlice = readTokValue<decltype(dst.SystemInfo.MaxEuPerSubSlice)>(*tokSystemInfo);
3751                             } break;
3752                             case TOK_FBD_GT_SYSTEM_INFO__MAX_SLICES_SUPPORTED: {
3753                                 dst.SystemInfo.MaxSlicesSupported = readTokValue<decltype(dst.SystemInfo.MaxSlicesSupported)>(*tokSystemInfo);
3754                             } break;
3755                             case TOK_FBD_GT_SYSTEM_INFO__MAX_SUB_SLICES_SUPPORTED: {
3756                                 dst.SystemInfo.MaxSubSlicesSupported = readTokValue<decltype(dst.SystemInfo.MaxSubSlicesSupported)>(*tokSystemInfo);
3757                             } break;
3758                             case TOK_FBD_GT_SYSTEM_INFO__MAX_DUAL_SUB_SLICES_SUPPORTED: {
3759                                 dst.SystemInfo.MaxDualSubSlicesSupported = readTokValue<decltype(dst.SystemInfo.MaxDualSubSlicesSupported)>(*tokSystemInfo);
3760                             } break;
3761                             case TOK_FBB_GT_SYSTEM_INFO__IS_L3HASH_MODE_ENABLED: {
3762                                 dst.SystemInfo.IsL3HashModeEnabled = readTokValue<decltype(dst.SystemInfo.IsL3HashModeEnabled)>(*tokSystemInfo);
3763                             } break;
3764                             case TOK_FBB_GT_SYSTEM_INFO__IS_DYNAMICALLY_POPULATED: {
3765                                 dst.SystemInfo.IsDynamicallyPopulated = readTokValue<decltype(dst.SystemInfo.IsDynamicallyPopulated)>(*tokSystemInfo);
3766                             } break;
3767                             case TOK_FBD_GT_SYSTEM_INFO__RESERVED_CCSWAYS: {
3768                                 dst.SystemInfo.ReservedCCSWays = readTokValue<decltype(dst.SystemInfo.ReservedCCSWays)>(*tokSystemInfo);
3769                             } break;
3770                             case TOK_FBD_GT_SYSTEM_INFO__NUM_THREADS_PER_EU: {
3771                                 dst.SystemInfo.NumThreadsPerEu = readTokValue<decltype(dst.SystemInfo.NumThreadsPerEu)>(*tokSystemInfo);
3772                             } break;
3773                             case TOK_FBD_GT_SYSTEM_INFO__MAX_VECS: {
3774                                 dst.SystemInfo.MaxVECS = readTokValue<decltype(dst.SystemInfo.MaxVECS)>(*tokSystemInfo);
3775                             } break;
3776                             };
3777                             tokSystemInfo = tokSystemInfo + 1 + tokSystemInfo->valueDwordCount;
3778                         } else {
3779                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSystemInfo);
3780                             switch (tokSystemInfo->id) {
3781                             default:
3782                                 if (tokSystemInfo->flags.flag3IsMandatory) {
3783                                     return false;
3784                                 }
3785                                 break;
3786                             case TOK_FS_GT_SYSTEM_INFO__SLICE_INFO: {
3787                                 uint32_t arrayElementIdSliceInfo = varLen->arrayElementId;
3788                                 const TokenHeader *tokSliceInfo = varLen->getValue<TokenHeader>();
3789                                 const TokenHeader *tokSliceInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
3790                                 static constexpr auto maxDstSlicesInfo = sizeof(dst.SystemInfo.SliceInfo) / sizeof(dst.SystemInfo.SliceInfo[0]);
3791                                 if (arrayElementIdSliceInfo >= maxDstSlicesInfo) {
3792                                     tokSliceInfo = tokSliceInfoEnd;
3793                                 }
3794                                 while (tokSliceInfo < tokSliceInfoEnd) {
3795                                     if (false == tokSliceInfo->flags.flag4IsVariableLength) {
3796                                         switch (tokSliceInfo->id) {
3797                                         default:
3798                                             if (tokSliceInfo->flags.flag3IsMandatory) {
3799                                                 return false;
3800                                             }
3801                                             break;
3802                                         case TOK_FBB_GT_SLICE_INFO__ENABLED: {
3803                                             dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].Enabled = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].Enabled)>(*tokSliceInfo);
3804                                         } break;
3805                                         case TOK_FBD_GT_SLICE_INFO__SUB_SLICE_ENABLED_COUNT: {
3806                                             dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceEnabledCount = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceEnabledCount)>(*tokSliceInfo);
3807                                         } break;
3808                                         case TOK_FBD_GT_SLICE_INFO__DUAL_SUB_SLICE_ENABLED_COUNT: {
3809                                             dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DualSubSliceEnabledCount = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DualSubSliceEnabledCount)>(*tokSliceInfo);
3810                                         } break;
3811                                         };
3812                                         tokSliceInfo = tokSliceInfo + 1 + tokSliceInfo->valueDwordCount;
3813                                     } else {
3814                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSliceInfo);
3815                                         switch (tokSliceInfo->id) {
3816                                         default:
3817                                             if (tokSliceInfo->flags.flag3IsMandatory) {
3818                                                 return false;
3819                                             }
3820                                             break;
3821                                         case TOK_FS_GT_SLICE_INFO__SUB_SLICE_INFO: {
3822                                             uint32_t arrayElementIdSubSliceInfo = varLen->arrayElementId;
3823                                             const TokenHeader *tokSubSliceInfo = varLen->getValue<TokenHeader>();
3824                                             const TokenHeader *tokSubSliceInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
3825                                             while (tokSubSliceInfo < tokSubSliceInfoEnd) {
3826                                                 if (false == tokSubSliceInfo->flags.flag4IsVariableLength) {
3827                                                     switch (tokSubSliceInfo->id) {
3828                                                     default:
3829                                                         if (tokSubSliceInfo->flags.flag3IsMandatory) {
3830                                                             return false;
3831                                                         }
3832                                                         break;
3833                                                     case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: {
3834                                                         dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].Enabled = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].Enabled)>(*tokSubSliceInfo);
3835                                                     } break;
3836                                                     case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: {
3837                                                         dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledCount = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledCount)>(*tokSubSliceInfo);
3838                                                     } break;
3839                                                     case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: {
3840                                                         dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledMask = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].SubSliceInfo[arrayElementIdSubSliceInfo].EuEnabledMask)>(*tokSubSliceInfo);
3841                                                     } break;
3842                                                     };
3843                                                     tokSubSliceInfo = tokSubSliceInfo + 1 + tokSubSliceInfo->valueDwordCount;
3844                                                 } else {
3845                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSubSliceInfo);
3846                                                     if (tokSubSliceInfo->flags.flag3IsMandatory) {
3847                                                         return false;
3848                                                     }
3849                                                     tokSubSliceInfo = tokSubSliceInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
3850                                                 }
3851                                             }
3852                                             WCH_ASSERT(tokSubSliceInfo == tokSubSliceInfoEnd);
3853                                         } break;
3854                                         case TOK_FS_GT_SLICE_INFO__DSSINFO: {
3855                                             uint32_t arrayElementIdDSSInfo = varLen->arrayElementId;
3856                                             const TokenHeader *tokDSSInfo = varLen->getValue<TokenHeader>();
3857                                             const TokenHeader *tokDSSInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
3858                                             while (tokDSSInfo < tokDSSInfoEnd) {
3859                                                 if (false == tokDSSInfo->flags.flag4IsVariableLength) {
3860                                                     switch (tokDSSInfo->id) {
3861                                                     default:
3862                                                         if (tokDSSInfo->flags.flag3IsMandatory) {
3863                                                             return false;
3864                                                         }
3865                                                         break;
3866                                                     case TOK_FBB_GT_DUALSUBSLICE_INFO__ENABLED: {
3867                                                         dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].Enabled = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].Enabled)>(*tokDSSInfo);
3868                                                     } break;
3869                                                     };
3870                                                     tokDSSInfo = tokDSSInfo + 1 + tokDSSInfo->valueDwordCount;
3871                                                 } else {
3872                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokDSSInfo);
3873                                                     switch (tokDSSInfo->id) {
3874                                                     default:
3875                                                         if (tokDSSInfo->flags.flag3IsMandatory) {
3876                                                             return false;
3877                                                         }
3878                                                         break;
3879                                                     case TOK_FS_GT_DUALSUBSLICE_INFO__SUB_SLICE: {
3880                                                         uint32_t arrayElementIdSubSlice = varLen->arrayElementId;
3881                                                         const TokenHeader *tokSubSlice = varLen->getValue<TokenHeader>();
3882                                                         const TokenHeader *tokSubSliceEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
3883                                                         while (tokSubSlice < tokSubSliceEnd) {
3884                                                             if (false == tokSubSlice->flags.flag4IsVariableLength) {
3885                                                                 switch (tokSubSlice->id) {
3886                                                                 default:
3887                                                                     if (tokSubSlice->flags.flag3IsMandatory) {
3888                                                                         return false;
3889                                                                     }
3890                                                                     break;
3891                                                                 case TOK_FBB_GT_SUBSLICE_INFO__ENABLED: {
3892                                                                     dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].Enabled = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].Enabled)>(*tokSubSlice);
3893                                                                 } break;
3894                                                                 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_COUNT: {
3895                                                                     dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledCount = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledCount)>(*tokSubSlice);
3896                                                                 } break;
3897                                                                 case TOK_FBD_GT_SUBSLICE_INFO__EU_ENABLED_MASK: {
3898                                                                     dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledMask = readTokValue<decltype(dst.SystemInfo.SliceInfo[arrayElementIdSliceInfo].DSSInfo[arrayElementIdDSSInfo].SubSlice[arrayElementIdSubSlice].EuEnabledMask)>(*tokSubSlice);
3899                                                                 } break;
3900                                                                 };
3901                                                                 tokSubSlice = tokSubSlice + 1 + tokSubSlice->valueDwordCount;
3902                                                             } else {
3903                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSubSlice);
3904                                                                 if (tokSubSlice->flags.flag3IsMandatory) {
3905                                                                     return false;
3906                                                                 }
3907                                                                 tokSubSlice = tokSubSlice + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
3908                                                             }
3909                                                         }
3910                                                         WCH_ASSERT(tokSubSlice == tokSubSliceEnd);
3911                                                     } break;
3912                                                     };
3913                                                     tokDSSInfo = tokDSSInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
3914                                                 }
3915                                             }
3916                                             WCH_ASSERT(tokDSSInfo == tokDSSInfoEnd);
3917                                         } break;
3918                                         };
3919                                         tokSliceInfo = tokSliceInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
3920                                     }
3921                                 }
3922                                 WCH_ASSERT(tokSliceInfo == tokSliceInfoEnd);
3923                             } break;
3924                             case TOK_FS_GT_SYSTEM_INFO__SQIDI_INFO: {
3925                                 const TokenHeader *tokSqidiInfo = varLen->getValue<TokenHeader>();
3926                                 const TokenHeader *tokSqidiInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
3927                                 while (tokSqidiInfo < tokSqidiInfoEnd) {
3928                                     if (false == tokSqidiInfo->flags.flag4IsVariableLength) {
3929                                         switch (tokSqidiInfo->id) {
3930                                         default:
3931                                             if (tokSqidiInfo->flags.flag3IsMandatory) {
3932                                                 return false;
3933                                             }
3934                                             break;
3935                                         case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_SQIDI: {
3936                                             dst.SystemInfo.SqidiInfo.NumberofSQIDI = readTokValue<decltype(dst.SystemInfo.SqidiInfo.NumberofSQIDI)>(*tokSqidiInfo);
3937                                         } break;
3938                                         case TOK_FBD_GT_SQIDI_INFO__NUMBEROF_DOORBELL_PER_SQIDI: {
3939                                             dst.SystemInfo.SqidiInfo.NumberofDoorbellPerSQIDI = readTokValue<decltype(dst.SystemInfo.SqidiInfo.NumberofDoorbellPerSQIDI)>(*tokSqidiInfo);
3940                                         } break;
3941                                         };
3942                                         tokSqidiInfo = tokSqidiInfo + 1 + tokSqidiInfo->valueDwordCount;
3943                                     } else {
3944                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSqidiInfo);
3945                                         if (tokSqidiInfo->flags.flag3IsMandatory) {
3946                                             return false;
3947                                         }
3948                                         tokSqidiInfo = tokSqidiInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
3949                                     }
3950                                 }
3951                                 WCH_ASSERT(tokSqidiInfo == tokSqidiInfoEnd);
3952                             } break;
3953                             case TOK_FS_GT_SYSTEM_INFO__CCSINFO: {
3954                                 const TokenHeader *tokCCSInfo = varLen->getValue<TokenHeader>();
3955                                 const TokenHeader *tokCCSInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
3956                                 while (tokCCSInfo < tokCCSInfoEnd) {
3957                                     if (false == tokCCSInfo->flags.flag4IsVariableLength) {
3958                                         switch (tokCCSInfo->id) {
3959                                         default:
3960                                             if (tokCCSInfo->flags.flag3IsMandatory) {
3961                                                 return false;
3962                                             }
3963                                             break;
3964                                         case TOK_FBD_GT_CCS_INFO__NUMBER_OF_CCSENABLED: {
3965                                             dst.SystemInfo.CCSInfo.NumberOfCCSEnabled = readTokValue<decltype(dst.SystemInfo.CCSInfo.NumberOfCCSEnabled)>(*tokCCSInfo);
3966                                         } break;
3967                                         case TOK_FBB_GT_CCS_INFO__IS_VALID: {
3968                                             dst.SystemInfo.CCSInfo.IsValid = readTokValue<decltype(dst.SystemInfo.CCSInfo.IsValid)>(*tokCCSInfo);
3969                                         } break;
3970                                         };
3971                                         tokCCSInfo = tokCCSInfo + 1 + tokCCSInfo->valueDwordCount;
3972                                     } else {
3973                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCCSInfo);
3974                                         switch (tokCCSInfo->id) {
3975                                         default:
3976                                             if (tokCCSInfo->flags.flag3IsMandatory) {
3977                                                 return false;
3978                                             }
3979                                             break;
3980                                         case TOK_FS_GT_CCS_INFO__INSTANCES: {
3981                                             const TokenHeader *tokInstances = varLen->getValue<TokenHeader>();
3982                                             const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
3983                                             while (tokInstances < tokInstancesEnd) {
3984                                                 if (false == tokInstances->flags.flag4IsVariableLength) {
3985                                                     switch (tokInstances->id) {
3986                                                     default:
3987                                                         if (tokInstances->flags.flag3IsMandatory) {
3988                                                             return false;
3989                                                         }
3990                                                         break;
3991                                                     case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSENABLE_MASK: {
3992                                                         dst.SystemInfo.CCSInfo.Instances.CCSEnableMask = readTokValue<decltype(dst.SystemInfo.CCSInfo.Instances.CCSEnableMask)>(*tokInstances);
3993                                                     } break;
3994                                                     };
3995                                                     tokInstances = tokInstances + 1 + tokInstances->valueDwordCount;
3996                                                 } else {
3997                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances);
3998                                                     switch (tokInstances->id) {
3999                                                     default:
4000                                                         if (tokInstances->flags.flag3IsMandatory) {
4001                                                             return false;
4002                                                         }
4003                                                         break;
4004                                                     case TOK_FS_GT_CCS_INFO__CCSINSTANCES__BITS: {
4005                                                         const TokenHeader *tokBits = varLen->getValue<TokenHeader>();
4006                                                         const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4007                                                         while (tokBits < tokBitsEnd) {
4008                                                             if (false == tokBits->flags.flag4IsVariableLength) {
4009                                                                 switch (tokBits->id) {
4010                                                                 default:
4011                                                                     if (tokBits->flags.flag3IsMandatory) {
4012                                                                         return false;
4013                                                                     }
4014                                                                     break;
4015                                                                 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS0ENABLED: {
4016                                                                     dst.SystemInfo.CCSInfo.Instances.Bits.CCS0Enabled = readTokValue<decltype(dst.SystemInfo.CCSInfo.Instances.Bits.CCS0Enabled)>(*tokBits);
4017                                                                 } break;
4018                                                                 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS1ENABLED: {
4019                                                                     dst.SystemInfo.CCSInfo.Instances.Bits.CCS1Enabled = readTokValue<decltype(dst.SystemInfo.CCSInfo.Instances.Bits.CCS1Enabled)>(*tokBits);
4020                                                                 } break;
4021                                                                 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS2ENABLED: {
4022                                                                     dst.SystemInfo.CCSInfo.Instances.Bits.CCS2Enabled = readTokValue<decltype(dst.SystemInfo.CCSInfo.Instances.Bits.CCS2Enabled)>(*tokBits);
4023                                                                 } break;
4024                                                                 case TOK_FBD_GT_CCS_INFO__CCSINSTANCES__CCSBIT_STRUCT__CCS3ENABLED: {
4025                                                                     dst.SystemInfo.CCSInfo.Instances.Bits.CCS3Enabled = readTokValue<decltype(dst.SystemInfo.CCSInfo.Instances.Bits.CCS3Enabled)>(*tokBits);
4026                                                                 } break;
4027                                                                 };
4028                                                                 tokBits = tokBits + 1 + tokBits->valueDwordCount;
4029                                                             } else {
4030                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits);
4031                                                                 if (tokBits->flags.flag3IsMandatory) {
4032                                                                     return false;
4033                                                                 }
4034                                                                 tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4035                                                             }
4036                                                         }
4037                                                         WCH_ASSERT(tokBits == tokBitsEnd);
4038                                                     } break;
4039                                                     };
4040                                                     tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4041                                                 }
4042                                             }
4043                                             WCH_ASSERT(tokInstances == tokInstancesEnd);
4044                                         } break;
4045                                         };
4046                                         tokCCSInfo = tokCCSInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4047                                     }
4048                                 }
4049                                 WCH_ASSERT(tokCCSInfo == tokCCSInfoEnd);
4050                             } break;
4051                             case TOK_FS_GT_SYSTEM_INFO__MULTI_TILE_ARCH_INFO: {
4052                                 const TokenHeader *tokMultiTileArchInfo = varLen->getValue<TokenHeader>();
4053                                 const TokenHeader *tokMultiTileArchInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4054                                 while (tokMultiTileArchInfo < tokMultiTileArchInfoEnd) {
4055                                     if (false == tokMultiTileArchInfo->flags.flag4IsVariableLength) {
4056                                         switch (tokMultiTileArchInfo->id) {
4057                                         default:
4058                                             if (tokMultiTileArchInfo->flags.flag3IsMandatory) {
4059                                                 return false;
4060                                             }
4061                                             break;
4062                                         case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__TILE_COUNT: {
4063                                             dst.SystemInfo.MultiTileArchInfo.TileCount = readTokValue<decltype(dst.SystemInfo.MultiTileArchInfo.TileCount)>(*tokMultiTileArchInfo);
4064                                         } break;
4065                                         case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE0: {
4066                                             dst.SystemInfo.MultiTileArchInfo.Tile0 = readTokValue<decltype(dst.SystemInfo.MultiTileArchInfo.Tile0)>(*tokMultiTileArchInfo);
4067                                         } break;
4068                                         case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE1: {
4069                                             dst.SystemInfo.MultiTileArchInfo.Tile1 = readTokValue<decltype(dst.SystemInfo.MultiTileArchInfo.Tile1)>(*tokMultiTileArchInfo);
4070                                         } break;
4071                                         case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE2: {
4072                                             dst.SystemInfo.MultiTileArchInfo.Tile2 = readTokValue<decltype(dst.SystemInfo.MultiTileArchInfo.Tile2)>(*tokMultiTileArchInfo);
4073                                         } break;
4074                                         case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__ANONYMOUS8876__TILE3: {
4075                                             dst.SystemInfo.MultiTileArchInfo.Tile3 = readTokValue<decltype(dst.SystemInfo.MultiTileArchInfo.Tile3)>(*tokMultiTileArchInfo);
4076                                         } break;
4077                                         case TOK_FBC_GT_MULTI_TILE_ARCH_INFO__ANONYMOUS8856__TILE_MASK: {
4078                                             dst.SystemInfo.MultiTileArchInfo.TileMask = readTokValue<decltype(dst.SystemInfo.MultiTileArchInfo.TileMask)>(*tokMultiTileArchInfo);
4079                                         } break;
4080                                         case TOK_FBB_GT_MULTI_TILE_ARCH_INFO__IS_VALID: {
4081                                             dst.SystemInfo.MultiTileArchInfo.IsValid = readTokValue<decltype(dst.SystemInfo.MultiTileArchInfo.IsValid)>(*tokMultiTileArchInfo);
4082                                         } break;
4083                                         };
4084                                         tokMultiTileArchInfo = tokMultiTileArchInfo + 1 + tokMultiTileArchInfo->valueDwordCount;
4085                                     } else {
4086                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMultiTileArchInfo);
4087                                         if (tokMultiTileArchInfo->flags.flag3IsMandatory) {
4088                                             return false;
4089                                         }
4090                                         tokMultiTileArchInfo = tokMultiTileArchInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4091                                     }
4092                                 }
4093                                 WCH_ASSERT(tokMultiTileArchInfo == tokMultiTileArchInfoEnd);
4094                             } break;
4095                             case TOK_FS_GT_SYSTEM_INFO__VDBOX_INFO: {
4096                                 const TokenHeader *tokVDBoxInfo = varLen->getValue<TokenHeader>();
4097                                 const TokenHeader *tokVDBoxInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4098                                 while (tokVDBoxInfo < tokVDBoxInfoEnd) {
4099                                     if (false == tokVDBoxInfo->flags.flag4IsVariableLength) {
4100                                         switch (tokVDBoxInfo->id) {
4101                                         default:
4102                                             if (tokVDBoxInfo->flags.flag3IsMandatory) {
4103                                                 return false;
4104                                             }
4105                                             break;
4106                                         case TOK_FBD_GT_VDBOX_INFO__NUMBER_OF_VDBOX_ENABLED: {
4107                                             dst.SystemInfo.VDBoxInfo.NumberOfVDBoxEnabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.NumberOfVDBoxEnabled)>(*tokVDBoxInfo);
4108                                         } break;
4109                                         case TOK_FBB_GT_VDBOX_INFO__IS_VALID: {
4110                                             dst.SystemInfo.VDBoxInfo.IsValid = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.IsValid)>(*tokVDBoxInfo);
4111                                         } break;
4112                                         };
4113                                         tokVDBoxInfo = tokVDBoxInfo + 1 + tokVDBoxInfo->valueDwordCount;
4114                                     } else {
4115                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokVDBoxInfo);
4116                                         switch (tokVDBoxInfo->id) {
4117                                         default:
4118                                             if (tokVDBoxInfo->flags.flag3IsMandatory) {
4119                                                 return false;
4120                                             }
4121                                             break;
4122                                         case TOK_FS_GT_VDBOX_INFO__INSTANCES: {
4123                                             const TokenHeader *tokInstances = varLen->getValue<TokenHeader>();
4124                                             const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4125                                             while (tokInstances < tokInstancesEnd) {
4126                                                 if (false == tokInstances->flags.flag4IsVariableLength) {
4127                                                     switch (tokInstances->id) {
4128                                                     default:
4129                                                         if (tokInstances->flags.flag3IsMandatory) {
4130                                                             return false;
4131                                                         }
4132                                                         break;
4133                                                     case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBOX_ENABLE_MASK: {
4134                                                         dst.SystemInfo.VDBoxInfo.Instances.VDBoxEnableMask = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.VDBoxEnableMask)>(*tokInstances);
4135                                                     } break;
4136                                                     };
4137                                                     tokInstances = tokInstances + 1 + tokInstances->valueDwordCount;
4138                                                 } else {
4139                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances);
4140                                                     switch (tokInstances->id) {
4141                                                     default:
4142                                                         if (tokInstances->flags.flag3IsMandatory) {
4143                                                             return false;
4144                                                         }
4145                                                         break;
4146                                                     case TOK_FS_GT_VDBOX_INFO__VDBOX_INSTANCES__BITS: {
4147                                                         const TokenHeader *tokBits = varLen->getValue<TokenHeader>();
4148                                                         const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4149                                                         while (tokBits < tokBitsEnd) {
4150                                                             if (false == tokBits->flags.flag4IsVariableLength) {
4151                                                                 switch (tokBits->id) {
4152                                                                 default:
4153                                                                     if (tokBits->flags.flag3IsMandatory) {
4154                                                                         return false;
4155                                                                     }
4156                                                                     break;
4157                                                                 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX0ENABLED: {
4158                                                                     dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox0Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox0Enabled)>(*tokBits);
4159                                                                 } break;
4160                                                                 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX1ENABLED: {
4161                                                                     dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox1Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox1Enabled)>(*tokBits);
4162                                                                 } break;
4163                                                                 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX2ENABLED: {
4164                                                                     dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox2Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox2Enabled)>(*tokBits);
4165                                                                 } break;
4166                                                                 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX3ENABLED: {
4167                                                                     dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox3Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox3Enabled)>(*tokBits);
4168                                                                 } break;
4169                                                                 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX4ENABLED: {
4170                                                                     dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox4Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox4Enabled)>(*tokBits);
4171                                                                 } break;
4172                                                                 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX5ENABLED: {
4173                                                                     dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox5Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox5Enabled)>(*tokBits);
4174                                                                 } break;
4175                                                                 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX6ENABLED: {
4176                                                                     dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox6Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox6Enabled)>(*tokBits);
4177                                                                 } break;
4178                                                                 case TOK_FBD_GT_VDBOX_INFO__VDBOX_INSTANCES__VDBIT_STRUCT__VDBOX7ENABLED: {
4179                                                                     dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox7Enabled = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.Instances.Bits.VDBox7Enabled)>(*tokBits);
4180                                                                 } break;
4181                                                                 };
4182                                                                 tokBits = tokBits + 1 + tokBits->valueDwordCount;
4183                                                             } else {
4184                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits);
4185                                                                 if (tokBits->flags.flag3IsMandatory) {
4186                                                                     return false;
4187                                                                 }
4188                                                                 tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4189                                                             }
4190                                                         }
4191                                                         WCH_ASSERT(tokBits == tokBitsEnd);
4192                                                     } break;
4193                                                     };
4194                                                     tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4195                                                 }
4196                                             }
4197                                             WCH_ASSERT(tokInstances == tokInstancesEnd);
4198                                         } break;
4199                                         case TOK_FS_GT_VDBOX_INFO__SFCSUPPORT: {
4200                                             const TokenHeader *tokSFCSupport = varLen->getValue<TokenHeader>();
4201                                             const TokenHeader *tokSFCSupportEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4202                                             while (tokSFCSupport < tokSFCSupportEnd) {
4203                                                 if (false == tokSFCSupport->flags.flag4IsVariableLength) {
4204                                                     switch (tokSFCSupport->id) {
4205                                                     default:
4206                                                         if (tokSFCSupport->flags.flag3IsMandatory) {
4207                                                             return false;
4208                                                         }
4209                                                         break;
4210                                                     case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__VALUE: {
4211                                                         dst.SystemInfo.VDBoxInfo.SFCSupport.Value = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.Value)>(*tokSFCSupport);
4212                                                     } break;
4213                                                     };
4214                                                     tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount;
4215                                                 } else {
4216                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSFCSupport);
4217                                                     switch (tokSFCSupport->id) {
4218                                                     default:
4219                                                         if (tokSFCSupport->flags.flag3IsMandatory) {
4220                                                             return false;
4221                                                         }
4222                                                         break;
4223                                                     case TOK_FS_GT_VDBOX_INFO__ANONYMOUS5662__SFC_SUPPORTED_BITS: {
4224                                                         const TokenHeader *tokSfcSupportedBits = varLen->getValue<TokenHeader>();
4225                                                         const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4226                                                         while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) {
4227                                                             if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) {
4228                                                                 switch (tokSfcSupportedBits->id) {
4229                                                                 default:
4230                                                                     if (tokSfcSupportedBits->flags.flag3IsMandatory) {
4231                                                                         return false;
4232                                                                     }
4233                                                                     break;
4234                                                                 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX0: {
4235                                                                     dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox0 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox0)>(*tokSfcSupportedBits);
4236                                                                 } break;
4237                                                                 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX1: {
4238                                                                     dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox1 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox1)>(*tokSfcSupportedBits);
4239                                                                 } break;
4240                                                                 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX2: {
4241                                                                     dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox2 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox2)>(*tokSfcSupportedBits);
4242                                                                 } break;
4243                                                                 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX3: {
4244                                                                     dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox3 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox3)>(*tokSfcSupportedBits);
4245                                                                 } break;
4246                                                                 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX4: {
4247                                                                     dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox4 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox4)>(*tokSfcSupportedBits);
4248                                                                 } break;
4249                                                                 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX5: {
4250                                                                     dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox5 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox5)>(*tokSfcSupportedBits);
4251                                                                 } break;
4252                                                                 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX6: {
4253                                                                     dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox6 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox6)>(*tokSfcSupportedBits);
4254                                                                 } break;
4255                                                                 case TOK_FBD_GT_VDBOX_INFO__ANONYMOUS5662__ANONYMOUS5682__VDBOX7: {
4256                                                                     dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox7 = readTokValue<decltype(dst.SystemInfo.VDBoxInfo.SFCSupport.SfcSupportedBits.VDBox7)>(*tokSfcSupportedBits);
4257                                                                 } break;
4258                                                                 };
4259                                                                 tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount;
4260                                                             } else {
4261                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSfcSupportedBits);
4262                                                                 if (tokSfcSupportedBits->flags.flag3IsMandatory) {
4263                                                                     return false;
4264                                                                 }
4265                                                                 tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4266                                                             }
4267                                                         }
4268                                                         WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd);
4269                                                     } break;
4270                                                     };
4271                                                     tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4272                                                 }
4273                                             }
4274                                             WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd);
4275                                         } break;
4276                                         };
4277                                         tokVDBoxInfo = tokVDBoxInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4278                                     }
4279                                 }
4280                                 WCH_ASSERT(tokVDBoxInfo == tokVDBoxInfoEnd);
4281                             } break;
4282                             case TOK_FS_GT_SYSTEM_INFO__VEBOX_INFO: {
4283                                 const TokenHeader *tokVEBoxInfo = varLen->getValue<TokenHeader>();
4284                                 const TokenHeader *tokVEBoxInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4285                                 while (tokVEBoxInfo < tokVEBoxInfoEnd) {
4286                                     if (false == tokVEBoxInfo->flags.flag4IsVariableLength) {
4287                                         switch (tokVEBoxInfo->id) {
4288                                         default:
4289                                             if (tokVEBoxInfo->flags.flag3IsMandatory) {
4290                                                 return false;
4291                                             }
4292                                             break;
4293                                         case TOK_FBD_GT_VEBOX_INFO__NUMBER_OF_VEBOX_ENABLED: {
4294                                             dst.SystemInfo.VEBoxInfo.NumberOfVEBoxEnabled = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.NumberOfVEBoxEnabled)>(*tokVEBoxInfo);
4295                                         } break;
4296                                         case TOK_FBB_GT_VEBOX_INFO__IS_VALID: {
4297                                             dst.SystemInfo.VEBoxInfo.IsValid = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.IsValid)>(*tokVEBoxInfo);
4298                                         } break;
4299                                         };
4300                                         tokVEBoxInfo = tokVEBoxInfo + 1 + tokVEBoxInfo->valueDwordCount;
4301                                     } else {
4302                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokVEBoxInfo);
4303                                         switch (tokVEBoxInfo->id) {
4304                                         default:
4305                                             if (tokVEBoxInfo->flags.flag3IsMandatory) {
4306                                                 return false;
4307                                             }
4308                                             break;
4309                                         case TOK_FS_GT_VEBOX_INFO__INSTANCES: {
4310                                             const TokenHeader *tokInstances = varLen->getValue<TokenHeader>();
4311                                             const TokenHeader *tokInstancesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4312                                             while (tokInstances < tokInstancesEnd) {
4313                                                 if (false == tokInstances->flags.flag4IsVariableLength) {
4314                                                     switch (tokInstances->id) {
4315                                                     default:
4316                                                         if (tokInstances->flags.flag3IsMandatory) {
4317                                                             return false;
4318                                                         }
4319                                                         break;
4320                                                     case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBOX_ENABLE_MASK: {
4321                                                         dst.SystemInfo.VEBoxInfo.Instances.VEBoxEnableMask = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.Instances.VEBoxEnableMask)>(*tokInstances);
4322                                                     } break;
4323                                                     };
4324                                                     tokInstances = tokInstances + 1 + tokInstances->valueDwordCount;
4325                                                 } else {
4326                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInstances);
4327                                                     switch (tokInstances->id) {
4328                                                     default:
4329                                                         if (tokInstances->flags.flag3IsMandatory) {
4330                                                             return false;
4331                                                         }
4332                                                         break;
4333                                                     case TOK_FS_GT_VEBOX_INFO__VEBOX_INSTANCES__BITS: {
4334                                                         const TokenHeader *tokBits = varLen->getValue<TokenHeader>();
4335                                                         const TokenHeader *tokBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4336                                                         while (tokBits < tokBitsEnd) {
4337                                                             if (false == tokBits->flags.flag4IsVariableLength) {
4338                                                                 switch (tokBits->id) {
4339                                                                 default:
4340                                                                     if (tokBits->flags.flag3IsMandatory) {
4341                                                                         return false;
4342                                                                     }
4343                                                                     break;
4344                                                                 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX0ENABLED: {
4345                                                                     dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox0Enabled)>(*tokBits);
4346                                                                 } break;
4347                                                                 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX1ENABLED: {
4348                                                                     dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox1Enabled = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox1Enabled)>(*tokBits);
4349                                                                 } break;
4350                                                                 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX2ENABLED: {
4351                                                                     dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox2Enabled = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox2Enabled)>(*tokBits);
4352                                                                 } break;
4353                                                                 case TOK_FBD_GT_VEBOX_INFO__VEBOX_INSTANCES__VEBIT_STRUCT__VEBOX3ENABLED: {
4354                                                                     dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox3Enabled = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.Instances.Bits.VEBox3Enabled)>(*tokBits);
4355                                                                 } break;
4356                                                                 };
4357                                                                 tokBits = tokBits + 1 + tokBits->valueDwordCount;
4358                                                             } else {
4359                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokBits);
4360                                                                 if (tokBits->flags.flag3IsMandatory) {
4361                                                                     return false;
4362                                                                 }
4363                                                                 tokBits = tokBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4364                                                             }
4365                                                         }
4366                                                         WCH_ASSERT(tokBits == tokBitsEnd);
4367                                                     } break;
4368                                                     };
4369                                                     tokInstances = tokInstances + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4370                                                 }
4371                                             }
4372                                             WCH_ASSERT(tokInstances == tokInstancesEnd);
4373                                         } break;
4374                                         case TOK_FS_GT_VEBOX_INFO__SFCSUPPORT: {
4375                                             const TokenHeader *tokSFCSupport = varLen->getValue<TokenHeader>();
4376                                             const TokenHeader *tokSFCSupportEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4377                                             while (tokSFCSupport < tokSFCSupportEnd) {
4378                                                 if (false == tokSFCSupport->flags.flag4IsVariableLength) {
4379                                                     switch (tokSFCSupport->id) {
4380                                                     default:
4381                                                         if (tokSFCSupport->flags.flag3IsMandatory) {
4382                                                             return false;
4383                                                         }
4384                                                         break;
4385                                                     case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__VALUE: {
4386                                                         dst.SystemInfo.VEBoxInfo.SFCSupport.Value = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.SFCSupport.Value)>(*tokSFCSupport);
4387                                                     } break;
4388                                                     };
4389                                                     tokSFCSupport = tokSFCSupport + 1 + tokSFCSupport->valueDwordCount;
4390                                                 } else {
4391                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSFCSupport);
4392                                                     switch (tokSFCSupport->id) {
4393                                                     default:
4394                                                         if (tokSFCSupport->flags.flag3IsMandatory) {
4395                                                             return false;
4396                                                         }
4397                                                         break;
4398                                                     case TOK_FS_GT_VEBOX_INFO__ANONYMOUS3862__SFC_SUPPORTED_BITS: {
4399                                                         const TokenHeader *tokSfcSupportedBits = varLen->getValue<TokenHeader>();
4400                                                         const TokenHeader *tokSfcSupportedBitsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4401                                                         while (tokSfcSupportedBits < tokSfcSupportedBitsEnd) {
4402                                                             if (false == tokSfcSupportedBits->flags.flag4IsVariableLength) {
4403                                                                 switch (tokSfcSupportedBits->id) {
4404                                                                 default:
4405                                                                     if (tokSfcSupportedBits->flags.flag3IsMandatory) {
4406                                                                         return false;
4407                                                                     }
4408                                                                     break;
4409                                                                 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX0: {
4410                                                                     dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox0 = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox0)>(*tokSfcSupportedBits);
4411                                                                 } break;
4412                                                                 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX1: {
4413                                                                     dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox1 = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox1)>(*tokSfcSupportedBits);
4414                                                                 } break;
4415                                                                 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX2: {
4416                                                                     dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox2 = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox2)>(*tokSfcSupportedBits);
4417                                                                 } break;
4418                                                                 case TOK_FBD_GT_VEBOX_INFO__ANONYMOUS3862__ANONYMOUS3882__VEBOX3: {
4419                                                                     dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox3 = readTokValue<decltype(dst.SystemInfo.VEBoxInfo.SFCSupport.SfcSupportedBits.VEBox3)>(*tokSfcSupportedBits);
4420                                                                 } break;
4421                                                                 };
4422                                                                 tokSfcSupportedBits = tokSfcSupportedBits + 1 + tokSfcSupportedBits->valueDwordCount;
4423                                                             } else {
4424                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSfcSupportedBits);
4425                                                                 if (tokSfcSupportedBits->flags.flag3IsMandatory) {
4426                                                                     return false;
4427                                                                 }
4428                                                                 tokSfcSupportedBits = tokSfcSupportedBits + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4429                                                             }
4430                                                         }
4431                                                         WCH_ASSERT(tokSfcSupportedBits == tokSfcSupportedBitsEnd);
4432                                                     } break;
4433                                                     };
4434                                                     tokSFCSupport = tokSFCSupport + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4435                                                 }
4436                                             }
4437                                             WCH_ASSERT(tokSFCSupport == tokSFCSupportEnd);
4438                                         } break;
4439                                         };
4440                                         tokVEBoxInfo = tokVEBoxInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4441                                     }
4442                                 }
4443                                 WCH_ASSERT(tokVEBoxInfo == tokVEBoxInfoEnd);
4444                             } break;
4445                             case TOK_FS_GT_SYSTEM_INFO__CACHE_TYPES: {
4446                                 const TokenHeader *tokCacheTypes = varLen->getValue<TokenHeader>();
4447                                 const TokenHeader *tokCacheTypesEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4448                                 while (tokCacheTypes < tokCacheTypesEnd) {
4449                                     if (false == tokCacheTypes->flags.flag4IsVariableLength) {
4450                                         switch (tokCacheTypes->id) {
4451                                         default:
4452                                             if (tokCacheTypes->flags.flag3IsMandatory) {
4453                                                 return false;
4454                                             }
4455                                             break;
4456                                         case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__L3: {
4457                                             dst.SystemInfo.CacheTypes.L3 = readTokValue<decltype(dst.SystemInfo.CacheTypes.L3)>(*tokCacheTypes);
4458                                         } break;
4459                                         case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__LLC: {
4460                                             dst.SystemInfo.CacheTypes.LLC = readTokValue<decltype(dst.SystemInfo.CacheTypes.LLC)>(*tokCacheTypes);
4461                                         } break;
4462                                         case TOK_FBD_GT_CACHE_TYPES__ANONYMOUS9544__E_DRAM: {
4463                                             dst.SystemInfo.CacheTypes.eDRAM = readTokValue<decltype(dst.SystemInfo.CacheTypes.eDRAM)>(*tokCacheTypes);
4464                                         } break;
4465                                         case TOK_FBD_GT_CACHE_TYPES__CACHE_TYPE_MASK: {
4466                                             dst.SystemInfo.CacheTypes.CacheTypeMask = readTokValue<decltype(dst.SystemInfo.CacheTypes.CacheTypeMask)>(*tokCacheTypes);
4467                                         } break;
4468                                         };
4469                                         tokCacheTypes = tokCacheTypes + 1 + tokCacheTypes->valueDwordCount;
4470                                     } else {
4471                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCacheTypes);
4472                                         if (tokCacheTypes->flags.flag3IsMandatory) {
4473                                             return false;
4474                                         }
4475                                         tokCacheTypes = tokCacheTypes + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4476                                     }
4477                                 }
4478                                 WCH_ASSERT(tokCacheTypes == tokCacheTypesEnd);
4479                             } break;
4480                             };
4481                             tokSystemInfo = tokSystemInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4482                         }
4483                     }
4484                     WCH_ASSERT(tokSystemInfo == tokSystemInfoEnd);
4485                 } break;
4486                 case TOK_FS_ADAPTER_INFO__DEFERRED_WAIT_INFO: {
4487                     const TokenHeader *tokDeferredWaitInfo = varLen->getValue<TokenHeader>();
4488                     const TokenHeader *tokDeferredWaitInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4489                     while (tokDeferredWaitInfo < tokDeferredWaitInfoEnd) {
4490                         if (false == tokDeferredWaitInfo->flags.flag4IsVariableLength) {
4491                             switch (tokDeferredWaitInfo->id) {
4492                             default:
4493                                 if (tokDeferredWaitInfo->flags.flag3IsMandatory) {
4494                                     return false;
4495                                 }
4496                                 break;
4497                             case TOK_FBD_KM_DEFERRED_WAIT_INFO__FEATURE_SUPPORTED: {
4498                                 dst.DeferredWaitInfo.FeatureSupported = readTokValue<decltype(dst.DeferredWaitInfo.FeatureSupported)>(*tokDeferredWaitInfo);
4499                             } break;
4500                             case TOK_FBD_KM_DEFERRED_WAIT_INFO__ACTIVE_DISPLAY: {
4501                                 dst.DeferredWaitInfo.ActiveDisplay = readTokValue<decltype(dst.DeferredWaitInfo.ActiveDisplay)>(*tokDeferredWaitInfo);
4502                             } break;
4503                             };
4504                             tokDeferredWaitInfo = tokDeferredWaitInfo + 1 + tokDeferredWaitInfo->valueDwordCount;
4505                         } else {
4506                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokDeferredWaitInfo);
4507                             if (tokDeferredWaitInfo->flags.flag3IsMandatory) {
4508                                 return false;
4509                             }
4510                             tokDeferredWaitInfo = tokDeferredWaitInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4511                         }
4512                     }
4513                     WCH_ASSERT(tokDeferredWaitInfo == tokDeferredWaitInfoEnd);
4514                 } break;
4515                 case TOK_FS_ADAPTER_INFO__GFX_PARTITION: {
4516                     const TokenHeader *tokGfxPartition = varLen->getValue<TokenHeader>();
4517                     const TokenHeader *tokGfxPartitionEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4518                     while (tokGfxPartition < tokGfxPartitionEnd) {
4519                         if (false == tokGfxPartition->flags.flag4IsVariableLength) {
4520                             if (tokGfxPartition->flags.flag3IsMandatory) {
4521                                 return false;
4522                             }
4523                             tokGfxPartition = tokGfxPartition + 1 + tokGfxPartition->valueDwordCount;
4524                         } else {
4525                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGfxPartition);
4526                             switch (tokGfxPartition->id) {
4527                             default:
4528                                 if (tokGfxPartition->flags.flag3IsMandatory) {
4529                                     return false;
4530                                 }
4531                                 break;
4532                             case TOK_FS_GMM_GFX_PARTITIONING__STANDARD: {
4533                                 const TokenHeader *tokStandard = varLen->getValue<TokenHeader>();
4534                                 const TokenHeader *tokStandardEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4535                                 while (tokStandard < tokStandardEnd) {
4536                                     if (false == tokStandard->flags.flag4IsVariableLength) {
4537                                         switch (tokStandard->id) {
4538                                         default:
4539                                             if (tokStandard->flags.flag3IsMandatory) {
4540                                                 return false;
4541                                             }
4542                                             break;
4543                                         case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: {
4544                                             dst.GfxPartition.Standard.Base = readTokValue<decltype(dst.GfxPartition.Standard.Base)>(*tokStandard);
4545                                         } break;
4546                                         case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: {
4547                                             dst.GfxPartition.Standard.Limit = readTokValue<decltype(dst.GfxPartition.Standard.Limit)>(*tokStandard);
4548                                         } break;
4549                                         };
4550                                         tokStandard = tokStandard + 1 + tokStandard->valueDwordCount;
4551                                     } else {
4552                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokStandard);
4553                                         if (tokStandard->flags.flag3IsMandatory) {
4554                                             return false;
4555                                         }
4556                                         tokStandard = tokStandard + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4557                                     }
4558                                 }
4559                                 WCH_ASSERT(tokStandard == tokStandardEnd);
4560                             } break;
4561                             case TOK_FS_GMM_GFX_PARTITIONING__STANDARD64KB: {
4562                                 const TokenHeader *tokStandard64KB = varLen->getValue<TokenHeader>();
4563                                 const TokenHeader *tokStandard64KBEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4564                                 while (tokStandard64KB < tokStandard64KBEnd) {
4565                                     if (false == tokStandard64KB->flags.flag4IsVariableLength) {
4566                                         switch (tokStandard64KB->id) {
4567                                         default:
4568                                             if (tokStandard64KB->flags.flag3IsMandatory) {
4569                                                 return false;
4570                                             }
4571                                             break;
4572                                         case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: {
4573                                             dst.GfxPartition.Standard64KB.Base = readTokValue<decltype(dst.GfxPartition.Standard64KB.Base)>(*tokStandard64KB);
4574                                         } break;
4575                                         case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: {
4576                                             dst.GfxPartition.Standard64KB.Limit = readTokValue<decltype(dst.GfxPartition.Standard64KB.Limit)>(*tokStandard64KB);
4577                                         } break;
4578                                         };
4579                                         tokStandard64KB = tokStandard64KB + 1 + tokStandard64KB->valueDwordCount;
4580                                     } else {
4581                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokStandard64KB);
4582                                         if (tokStandard64KB->flags.flag3IsMandatory) {
4583                                             return false;
4584                                         }
4585                                         tokStandard64KB = tokStandard64KB + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4586                                     }
4587                                 }
4588                                 WCH_ASSERT(tokStandard64KB == tokStandard64KBEnd);
4589                             } break;
4590                             case TOK_FS_GMM_GFX_PARTITIONING__SVM: {
4591                                 const TokenHeader *tokSVM = varLen->getValue<TokenHeader>();
4592                                 const TokenHeader *tokSVMEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4593                                 while (tokSVM < tokSVMEnd) {
4594                                     if (false == tokSVM->flags.flag4IsVariableLength) {
4595                                         switch (tokSVM->id) {
4596                                         default:
4597                                             if (tokSVM->flags.flag3IsMandatory) {
4598                                                 return false;
4599                                             }
4600                                             break;
4601                                         case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: {
4602                                             dst.GfxPartition.SVM.Base = readTokValue<decltype(dst.GfxPartition.SVM.Base)>(*tokSVM);
4603                                         } break;
4604                                         case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: {
4605                                             dst.GfxPartition.SVM.Limit = readTokValue<decltype(dst.GfxPartition.SVM.Limit)>(*tokSVM);
4606                                         } break;
4607                                         };
4608                                         tokSVM = tokSVM + 1 + tokSVM->valueDwordCount;
4609                                     } else {
4610                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSVM);
4611                                         if (tokSVM->flags.flag3IsMandatory) {
4612                                             return false;
4613                                         }
4614                                         tokSVM = tokSVM + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4615                                     }
4616                                 }
4617                                 WCH_ASSERT(tokSVM == tokSVMEnd);
4618                             } break;
4619                             case TOK_FS_GMM_GFX_PARTITIONING__HEAP32: {
4620                                 uint32_t arrayElementIdHeap32 = varLen->arrayElementId;
4621                                 const TokenHeader *tokHeap32 = varLen->getValue<TokenHeader>();
4622                                 const TokenHeader *tokHeap32End = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4623                                 while (tokHeap32 < tokHeap32End) {
4624                                     if (false == tokHeap32->flags.flag4IsVariableLength) {
4625                                         switch (tokHeap32->id) {
4626                                         default:
4627                                             if (tokHeap32->flags.flag3IsMandatory) {
4628                                                 return false;
4629                                             }
4630                                             break;
4631                                         case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__BASE: {
4632                                             dst.GfxPartition.Heap32[arrayElementIdHeap32].Base = readTokValue<decltype(dst.GfxPartition.Heap32[arrayElementIdHeap32].Base)>(*tokHeap32);
4633                                         } break;
4634                                         case TOK_FBQ_GMM_GFX_PARTITIONING__ANONYMOUS7117__LIMIT: {
4635                                             dst.GfxPartition.Heap32[arrayElementIdHeap32].Limit = readTokValue<decltype(dst.GfxPartition.Heap32[arrayElementIdHeap32].Limit)>(*tokHeap32);
4636                                         } break;
4637                                         };
4638                                         tokHeap32 = tokHeap32 + 1 + tokHeap32->valueDwordCount;
4639                                     } else {
4640                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokHeap32);
4641                                         if (tokHeap32->flags.flag3IsMandatory) {
4642                                             return false;
4643                                         }
4644                                         tokHeap32 = tokHeap32 + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4645                                     }
4646                                 }
4647                                 WCH_ASSERT(tokHeap32 == tokHeap32End);
4648                             } break;
4649                             };
4650                             tokGfxPartition = tokGfxPartition + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4651                         }
4652                     }
4653                     WCH_ASSERT(tokGfxPartition == tokGfxPartitionEnd);
4654                 } break;
4655                 case TOK_FS_ADAPTER_INFO__ST_ADAPTER_BDF: {
4656                     const TokenHeader *tokStAdapterBDF = varLen->getValue<TokenHeader>();
4657                     const TokenHeader *tokStAdapterBDFEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4658                     while (tokStAdapterBDF < tokStAdapterBDFEnd) {
4659                         if (false == tokStAdapterBDF->flags.flag4IsVariableLength) {
4660                             switch (tokStAdapterBDF->id) {
4661                             default:
4662                                 if (tokStAdapterBDF->flags.flag3IsMandatory) {
4663                                     return false;
4664                                 }
4665                                 break;
4666                             case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__BUS: {
4667                                 dst.stAdapterBDF.Bus = readTokValue<decltype(dst.stAdapterBDF.Bus)>(*tokStAdapterBDF);
4668                             } break;
4669                             case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__DEVICE: {
4670                                 dst.stAdapterBDF.Device = readTokValue<decltype(dst.stAdapterBDF.Device)>(*tokStAdapterBDF);
4671                             } break;
4672                             case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__ANONYMOUS8193__FUNCTION: {
4673                                 dst.stAdapterBDF.Function = readTokValue<decltype(dst.stAdapterBDF.Function)>(*tokStAdapterBDF);
4674                             } break;
4675                             case TOK_FBD_ADAPTER_BDF___ANONYMOUS8173__DATA: {
4676                                 dst.stAdapterBDF.Data = readTokValue<decltype(dst.stAdapterBDF.Data)>(*tokStAdapterBDF);
4677                             } break;
4678                             };
4679                             tokStAdapterBDF = tokStAdapterBDF + 1 + tokStAdapterBDF->valueDwordCount;
4680                         } else {
4681                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokStAdapterBDF);
4682                             if (tokStAdapterBDF->flags.flag3IsMandatory) {
4683                                 return false;
4684                             }
4685                             tokStAdapterBDF = tokStAdapterBDF + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4686                         }
4687                     }
4688                     WCH_ASSERT(tokStAdapterBDF == tokStAdapterBDFEnd);
4689                 } break;
4690                 };
4691                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4692             }
4693         }
4694         WCH_ASSERT(tok == srcTokensEnd);
4695         return true;
4696     }
4697 };
4698 
4699 template <>
4700 struct Demarshaller<TOK_S_CREATECONTEXT_PVTDATA> {
4701     template <typename _CREATECONTEXT_PVTDATAT>
4702     static bool demarshall(_CREATECONTEXT_PVTDATAT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
4703         const TokenHeader *tok = srcTokensBeg;
4704         while (tok < srcTokensEnd) {
4705             if (false == tok->flags.flag4IsVariableLength) {
4706                 switch (tok->id) {
4707                 default:
4708                     if (tok->flags.flag3IsMandatory) {
4709                         return false;
4710                     }
4711                     break;
4712                 case TOK_PBQ_CREATECONTEXT_PVTDATA__ANONYMOUS18449__P_HW_CONTEXT_ID: {
4713                     dst.pHwContextId = readTokValue<decltype(dst.pHwContextId)>(*tok);
4714                 } break;
4715                 case TOK_FBD_CREATECONTEXT_PVTDATA__NUMBER_OF_HW_CONTEXT_IDS: {
4716                     dst.NumberOfHwContextIds = readTokValue<decltype(dst.NumberOfHwContextIds)>(*tok);
4717                 } break;
4718                 case TOK_FBD_CREATECONTEXT_PVTDATA__PROCESS_ID: {
4719                     dst.ProcessID = readTokValue<decltype(dst.ProcessID)>(*tok);
4720                 } break;
4721                 case TOK_FBC_CREATECONTEXT_PVTDATA__IS_PROTECTED_PROCESS: {
4722                     dst.IsProtectedProcess = readTokValue<decltype(dst.IsProtectedProcess)>(*tok);
4723                 } break;
4724                 case TOK_FBC_CREATECONTEXT_PVTDATA__IS_DWM: {
4725                     dst.IsDwm = readTokValue<decltype(dst.IsDwm)>(*tok);
4726                 } break;
4727                 case TOK_FBC_CREATECONTEXT_PVTDATA__IS_MEDIA_USAGE: {
4728                     dst.IsMediaUsage = readTokValue<decltype(dst.IsMediaUsage)>(*tok);
4729                 } break;
4730                 case TOK_FBC_CREATECONTEXT_PVTDATA__GPU_VACONTEXT: {
4731                     dst.GpuVAContext = readTokValue<decltype(dst.GpuVAContext)>(*tok);
4732                 } break;
4733                 case TOK_FBC_CREATECONTEXT_PVTDATA__NO_RING_FLUSHES: {
4734                     dst.NoRingFlushes = readTokValue<decltype(dst.NoRingFlushes)>(*tok);
4735                 } break;
4736                 };
4737                 tok = tok + 1 + tok->valueDwordCount;
4738             } else {
4739                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
4740                 switch (tok->id) {
4741                 default:
4742                     if (tok->flags.flag3IsMandatory) {
4743                         return false;
4744                     }
4745                     break;
4746                 case TOK_S_CREATECONTEXT_PVTDATA:
4747                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
4748                         return false;
4749                     }
4750                     break;
4751                 };
4752                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4753             }
4754         }
4755         WCH_ASSERT(tok == srcTokensEnd);
4756         return true;
4757     }
4758 };
4759 
4760 template <>
4761 struct Demarshaller<TOK_S_COMMAND_BUFFER_HEADER_REC> {
4762     template <typename COMMAND_BUFFER_HEADER_RECT>
4763     static bool demarshall(COMMAND_BUFFER_HEADER_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
4764         const TokenHeader *tok = srcTokensBeg;
4765         while (tok < srcTokensEnd) {
4766             if (false == tok->flags.flag4IsVariableLength) {
4767                 switch (tok->id) {
4768                 default:
4769                     if (tok->flags.flag3IsMandatory) {
4770                         return false;
4771                     }
4772                     break;
4773                 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_CONTEXT_TYPE: {
4774                     dst.UmdContextType = readTokValue<decltype(dst.UmdContextType)>(*tok);
4775                 } break;
4776                 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_PATCH_LIST: {
4777                     dst.UmdPatchList = readTokValue<decltype(dst.UmdPatchList)>(*tok);
4778                 } break;
4779                 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_REQUESTED_SLICE_STATE: {
4780                     dst.UmdRequestedSliceState = readTokValue<decltype(dst.UmdRequestedSliceState)>(*tok);
4781                 } break;
4782                 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_REQUESTED_SUBSLICE_COUNT: {
4783                     dst.UmdRequestedSubsliceCount = readTokValue<decltype(dst.UmdRequestedSubsliceCount)>(*tok);
4784                 } break;
4785                 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__UMD_REQUESTED_EUCOUNT: {
4786                     dst.UmdRequestedEUCount = readTokValue<decltype(dst.UmdRequestedEUCount)>(*tok);
4787                 } break;
4788                 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__USES_RESOURCE_STREAMER: {
4789                     dst.UsesResourceStreamer = readTokValue<decltype(dst.UsesResourceStreamer)>(*tok);
4790                 } break;
4791                 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__NEEDS_MID_BATCH_PRE_EMPTION_SUPPORT: {
4792                     dst.NeedsMidBatchPreEmptionSupport = readTokValue<decltype(dst.NeedsMidBatchPreEmptionSupport)>(*tok);
4793                 } break;
4794                 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__USES_GPGPUPIPELINE: {
4795                     dst.UsesGPGPUPipeline = readTokValue<decltype(dst.UsesGPGPUPipeline)>(*tok);
4796                 } break;
4797                 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__REQUIRES_COHERENCY: {
4798                     dst.RequiresCoherency = readTokValue<decltype(dst.RequiresCoherency)>(*tok);
4799                 } break;
4800                 case TOK_FBD_COMMAND_BUFFER_HEADER_REC__PERF_TAG: {
4801                     dst.PerfTag = readTokValue<decltype(dst.PerfTag)>(*tok);
4802                 } break;
4803                 case TOK_FBQ_COMMAND_BUFFER_HEADER_REC__MONITOR_FENCE_VA: {
4804                     dst.MonitorFenceVA = readTokValue<decltype(dst.MonitorFenceVA)>(*tok);
4805                 } break;
4806                 case TOK_FBQ_COMMAND_BUFFER_HEADER_REC__MONITOR_FENCE_VALUE: {
4807                     dst.MonitorFenceValue = readTokValue<decltype(dst.MonitorFenceValue)>(*tok);
4808                 } break;
4809                 };
4810                 tok = tok + 1 + tok->valueDwordCount;
4811             } else {
4812                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
4813                 switch (tok->id) {
4814                 default:
4815                     if (tok->flags.flag3IsMandatory) {
4816                         return false;
4817                     }
4818                     break;
4819                 case TOK_S_COMMAND_BUFFER_HEADER_REC:
4820                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
4821                         return false;
4822                     }
4823                     break;
4824                 };
4825                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
4826             }
4827         }
4828         WCH_ASSERT(tok == srcTokensEnd);
4829         return true;
4830     }
4831 };
4832 
4833 template <>
4834 struct Demarshaller<TOK_S_GMM_RESOURCE_FLAG_REC> {
4835     template <typename GMM_RESOURCE_FLAG_RECT>
4836     static bool demarshall(GMM_RESOURCE_FLAG_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
4837         const TokenHeader *tok = srcTokensBeg;
4838         while (tok < srcTokensEnd) {
4839             if (false == tok->flags.flag4IsVariableLength) {
4840                 if (tok->flags.flag3IsMandatory) {
4841                     return false;
4842                 }
4843                 tok = tok + 1 + tok->valueDwordCount;
4844             } else {
4845                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
4846                 switch (tok->id) {
4847                 default:
4848                     if (tok->flags.flag3IsMandatory) {
4849                         return false;
4850                     }
4851                     break;
4852                 case TOK_S_GMM_RESOURCE_FLAG_REC:
4853                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
4854                         return false;
4855                     }
4856                     break;
4857                 case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: {
4858                     const TokenHeader *tokGpu = varLen->getValue<TokenHeader>();
4859                     const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
4860                     while (tokGpu < tokGpuEnd) {
4861                         if (false == tokGpu->flags.flag4IsVariableLength) {
4862                             switch (tokGpu->id) {
4863                             default:
4864                                 if (tokGpu->flags.flag3IsMandatory) {
4865                                     return false;
4866                                 }
4867                                 break;
4868                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: {
4869                                 dst.Gpu.CameraCapture = readTokValue<decltype(dst.Gpu.CameraCapture)>(*tokGpu);
4870                             } break;
4871                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: {
4872                                 dst.Gpu.CCS = readTokValue<decltype(dst.Gpu.CCS)>(*tokGpu);
4873                             } break;
4874                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: {
4875                                 dst.Gpu.ColorDiscard = readTokValue<decltype(dst.Gpu.ColorDiscard)>(*tokGpu);
4876                             } break;
4877                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: {
4878                                 dst.Gpu.ColorSeparation = readTokValue<decltype(dst.Gpu.ColorSeparation)>(*tokGpu);
4879                             } break;
4880                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: {
4881                                 dst.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.Gpu.ColorSeparationRGBX)>(*tokGpu);
4882                             } break;
4883                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: {
4884                                 dst.Gpu.Constant = readTokValue<decltype(dst.Gpu.Constant)>(*tokGpu);
4885                             } break;
4886                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: {
4887                                 dst.Gpu.Depth = readTokValue<decltype(dst.Gpu.Depth)>(*tokGpu);
4888                             } break;
4889                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: {
4890                                 dst.Gpu.FlipChain = readTokValue<decltype(dst.Gpu.FlipChain)>(*tokGpu);
4891                             } break;
4892                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: {
4893                                 dst.Gpu.FlipChainPreferred = readTokValue<decltype(dst.Gpu.FlipChainPreferred)>(*tokGpu);
4894                             } break;
4895                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: {
4896                                 dst.Gpu.HistoryBuffer = readTokValue<decltype(dst.Gpu.HistoryBuffer)>(*tokGpu);
4897                             } break;
4898                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: {
4899                                 dst.Gpu.HiZ = readTokValue<decltype(dst.Gpu.HiZ)>(*tokGpu);
4900                             } break;
4901                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: {
4902                                 dst.Gpu.Index = readTokValue<decltype(dst.Gpu.Index)>(*tokGpu);
4903                             } break;
4904                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: {
4905                                 dst.Gpu.IndirectClearColor = readTokValue<decltype(dst.Gpu.IndirectClearColor)>(*tokGpu);
4906                             } break;
4907                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: {
4908                                 dst.Gpu.InstructionFlat = readTokValue<decltype(dst.Gpu.InstructionFlat)>(*tokGpu);
4909                             } break;
4910                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: {
4911                                 dst.Gpu.InterlacedScan = readTokValue<decltype(dst.Gpu.InterlacedScan)>(*tokGpu);
4912                             } break;
4913                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: {
4914                                 dst.Gpu.MCS = readTokValue<decltype(dst.Gpu.MCS)>(*tokGpu);
4915                             } break;
4916                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: {
4917                                 dst.Gpu.MMC = readTokValue<decltype(dst.Gpu.MMC)>(*tokGpu);
4918                             } break;
4919                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: {
4920                                 dst.Gpu.MotionComp = readTokValue<decltype(dst.Gpu.MotionComp)>(*tokGpu);
4921                             } break;
4922                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: {
4923                                 dst.Gpu.NoRestriction = readTokValue<decltype(dst.Gpu.NoRestriction)>(*tokGpu);
4924                             } break;
4925                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: {
4926                                 dst.Gpu.Overlay = readTokValue<decltype(dst.Gpu.Overlay)>(*tokGpu);
4927                             } break;
4928                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: {
4929                                 dst.Gpu.Presentable = readTokValue<decltype(dst.Gpu.Presentable)>(*tokGpu);
4930                             } break;
4931                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: {
4932                                 dst.Gpu.ProceduralTexture = readTokValue<decltype(dst.Gpu.ProceduralTexture)>(*tokGpu);
4933                             } break;
4934                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: {
4935                                 dst.Gpu.Query = readTokValue<decltype(dst.Gpu.Query)>(*tokGpu);
4936                             } break;
4937                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: {
4938                                 dst.Gpu.RenderTarget = readTokValue<decltype(dst.Gpu.RenderTarget)>(*tokGpu);
4939                             } break;
4940                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: {
4941                                 dst.Gpu.S3d = readTokValue<decltype(dst.Gpu.S3d)>(*tokGpu);
4942                             } break;
4943                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: {
4944                                 dst.Gpu.S3dDx = readTokValue<decltype(dst.Gpu.S3dDx)>(*tokGpu);
4945                             } break;
4946                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: {
4947                                 dst.Gpu.__S3dNonPacked = readTokValue<decltype(dst.Gpu.__S3dNonPacked)>(*tokGpu);
4948                             } break;
4949                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: {
4950                                 dst.Gpu.__S3dWidi = readTokValue<decltype(dst.Gpu.__S3dWidi)>(*tokGpu);
4951                             } break;
4952                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: {
4953                                 dst.Gpu.ScratchFlat = readTokValue<decltype(dst.Gpu.ScratchFlat)>(*tokGpu);
4954                             } break;
4955                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: {
4956                                 dst.Gpu.SeparateStencil = readTokValue<decltype(dst.Gpu.SeparateStencil)>(*tokGpu);
4957                             } break;
4958                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: {
4959                                 dst.Gpu.State = readTokValue<decltype(dst.Gpu.State)>(*tokGpu);
4960                             } break;
4961                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: {
4962                                 dst.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.Gpu.StateDx9ConstantBuffer)>(*tokGpu);
4963                             } break;
4964                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: {
4965                                 dst.Gpu.Stream = readTokValue<decltype(dst.Gpu.Stream)>(*tokGpu);
4966                             } break;
4967                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: {
4968                                 dst.Gpu.TextApi = readTokValue<decltype(dst.Gpu.TextApi)>(*tokGpu);
4969                             } break;
4970                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: {
4971                                 dst.Gpu.Texture = readTokValue<decltype(dst.Gpu.Texture)>(*tokGpu);
4972                             } break;
4973                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: {
4974                                 dst.Gpu.TiledResource = readTokValue<decltype(dst.Gpu.TiledResource)>(*tokGpu);
4975                             } break;
4976                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: {
4977                                 dst.Gpu.TilePool = readTokValue<decltype(dst.Gpu.TilePool)>(*tokGpu);
4978                             } break;
4979                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: {
4980                                 dst.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.Gpu.UnifiedAuxSurface)>(*tokGpu);
4981                             } break;
4982                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: {
4983                                 dst.Gpu.Vertex = readTokValue<decltype(dst.Gpu.Vertex)>(*tokGpu);
4984                             } break;
4985                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: {
4986                                 dst.Gpu.Video = readTokValue<decltype(dst.Gpu.Video)>(*tokGpu);
4987                             } break;
4988                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: {
4989                                 dst.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.Gpu.__NonMsaaTileXCcs)>(*tokGpu);
4990                             } break;
4991                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: {
4992                                 dst.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.Gpu.__NonMsaaTileYCcs)>(*tokGpu);
4993                             } break;
4994                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: {
4995                                 dst.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.Gpu.__MsaaTileMcs)>(*tokGpu);
4996                             } break;
4997                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: {
4998                                 dst.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.Gpu.__NonMsaaLinearCCS)>(*tokGpu);
4999                             } break;
5000                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: {
5001                                 dst.Gpu.__Remaining = readTokValue<decltype(dst.Gpu.__Remaining)>(*tokGpu);
5002                             } break;
5003                             };
5004                             tokGpu = tokGpu + 1 + tokGpu->valueDwordCount;
5005                         } else {
5006                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu);
5007                             if (tokGpu->flags.flag3IsMandatory) {
5008                                 return false;
5009                             }
5010                             tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5011                         }
5012                     }
5013                     WCH_ASSERT(tokGpu == tokGpuEnd);
5014                 } break;
5015                 case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: {
5016                     const TokenHeader *tokInfo = varLen->getValue<TokenHeader>();
5017                     const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
5018                     while (tokInfo < tokInfoEnd) {
5019                         if (false == tokInfo->flags.flag4IsVariableLength) {
5020                             switch (tokInfo->id) {
5021                             default:
5022                                 if (tokInfo->flags.flag3IsMandatory) {
5023                                     return false;
5024                                 }
5025                                 break;
5026                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: {
5027                                 dst.Info.AllowVirtualPadding = readTokValue<decltype(dst.Info.AllowVirtualPadding)>(*tokInfo);
5028                             } break;
5029                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: {
5030                                 dst.Info.BigPage = readTokValue<decltype(dst.Info.BigPage)>(*tokInfo);
5031                             } break;
5032                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: {
5033                                 dst.Info.Cacheable = readTokValue<decltype(dst.Info.Cacheable)>(*tokInfo);
5034                             } break;
5035                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: {
5036                                 dst.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.Info.ContigPhysMemoryForiDART)>(*tokInfo);
5037                             } break;
5038                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: {
5039                                 dst.Info.CornerTexelMode = readTokValue<decltype(dst.Info.CornerTexelMode)>(*tokInfo);
5040                             } break;
5041                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: {
5042                                 dst.Info.ExistingSysMem = readTokValue<decltype(dst.Info.ExistingSysMem)>(*tokInfo);
5043                             } break;
5044                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: {
5045                                 dst.Info.ForceResidency = readTokValue<decltype(dst.Info.ForceResidency)>(*tokInfo);
5046                             } break;
5047                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: {
5048                                 dst.Info.Gfdt = readTokValue<decltype(dst.Info.Gfdt)>(*tokInfo);
5049                             } break;
5050                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: {
5051                                 dst.Info.GttMapType = readTokValue<decltype(dst.Info.GttMapType)>(*tokInfo);
5052                             } break;
5053                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: {
5054                                 dst.Info.HardwareProtected = readTokValue<decltype(dst.Info.HardwareProtected)>(*tokInfo);
5055                             } break;
5056                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: {
5057                                 dst.Info.KernelModeMapped = readTokValue<decltype(dst.Info.KernelModeMapped)>(*tokInfo);
5058                             } break;
5059                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: {
5060                                 dst.Info.LayoutBelow = readTokValue<decltype(dst.Info.LayoutBelow)>(*tokInfo);
5061                             } break;
5062                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: {
5063                                 dst.Info.LayoutMono = readTokValue<decltype(dst.Info.LayoutMono)>(*tokInfo);
5064                             } break;
5065                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: {
5066                                 dst.Info.LayoutRight = readTokValue<decltype(dst.Info.LayoutRight)>(*tokInfo);
5067                             } break;
5068                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: {
5069                                 dst.Info.LocalOnly = readTokValue<decltype(dst.Info.LocalOnly)>(*tokInfo);
5070                             } break;
5071                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: {
5072                                 dst.Info.Linear = readTokValue<decltype(dst.Info.Linear)>(*tokInfo);
5073                             } break;
5074                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: {
5075                                 dst.Info.MediaCompressed = readTokValue<decltype(dst.Info.MediaCompressed)>(*tokInfo);
5076                             } break;
5077                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: {
5078                                 dst.Info.NoOptimizationPadding = readTokValue<decltype(dst.Info.NoOptimizationPadding)>(*tokInfo);
5079                             } break;
5080                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: {
5081                                 dst.Info.NoPhysMemory = readTokValue<decltype(dst.Info.NoPhysMemory)>(*tokInfo);
5082                             } break;
5083                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: {
5084                                 dst.Info.NotLockable = readTokValue<decltype(dst.Info.NotLockable)>(*tokInfo);
5085                             } break;
5086                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: {
5087                                 dst.Info.NonLocalOnly = readTokValue<decltype(dst.Info.NonLocalOnly)>(*tokInfo);
5088                             } break;
5089                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: {
5090                                 dst.Info.StdSwizzle = readTokValue<decltype(dst.Info.StdSwizzle)>(*tokInfo);
5091                             } break;
5092                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: {
5093                                 dst.Info.PseudoStdSwizzle = readTokValue<decltype(dst.Info.PseudoStdSwizzle)>(*tokInfo);
5094                             } break;
5095                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: {
5096                                 dst.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.Info.Undefined64KBSwizzle)>(*tokInfo);
5097                             } break;
5098                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: {
5099                                 dst.Info.RedecribedPlanes = readTokValue<decltype(dst.Info.RedecribedPlanes)>(*tokInfo);
5100                             } break;
5101                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: {
5102                                 dst.Info.RenderCompressed = readTokValue<decltype(dst.Info.RenderCompressed)>(*tokInfo);
5103                             } break;
5104                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: {
5105                                 dst.Info.Rotated = readTokValue<decltype(dst.Info.Rotated)>(*tokInfo);
5106                             } break;
5107                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: {
5108                                 dst.Info.Shared = readTokValue<decltype(dst.Info.Shared)>(*tokInfo);
5109                             } break;
5110                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: {
5111                                 dst.Info.SoftwareProtected = readTokValue<decltype(dst.Info.SoftwareProtected)>(*tokInfo);
5112                             } break;
5113                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: {
5114                                 dst.Info.SVM = readTokValue<decltype(dst.Info.SVM)>(*tokInfo);
5115                             } break;
5116                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: {
5117                                 dst.Info.Tile4 = readTokValue<decltype(dst.Info.Tile4)>(*tokInfo);
5118                             } break;
5119                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: {
5120                                 dst.Info.Tile64 = readTokValue<decltype(dst.Info.Tile64)>(*tokInfo);
5121                             } break;
5122                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: {
5123                                 dst.Info.TiledW = readTokValue<decltype(dst.Info.TiledW)>(*tokInfo);
5124                             } break;
5125                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: {
5126                                 dst.Info.TiledX = readTokValue<decltype(dst.Info.TiledX)>(*tokInfo);
5127                             } break;
5128                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: {
5129                                 dst.Info.TiledY = readTokValue<decltype(dst.Info.TiledY)>(*tokInfo);
5130                             } break;
5131                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: {
5132                                 dst.Info.TiledYf = readTokValue<decltype(dst.Info.TiledYf)>(*tokInfo);
5133                             } break;
5134                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: {
5135                                 dst.Info.TiledYs = readTokValue<decltype(dst.Info.TiledYs)>(*tokInfo);
5136                             } break;
5137                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: {
5138                                 dst.Info.WddmProtected = readTokValue<decltype(dst.Info.WddmProtected)>(*tokInfo);
5139                             } break;
5140                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: {
5141                                 dst.Info.XAdapter = readTokValue<decltype(dst.Info.XAdapter)>(*tokInfo);
5142                             } break;
5143                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: {
5144                                 dst.Info.__PreallocatedResInfo = readTokValue<decltype(dst.Info.__PreallocatedResInfo)>(*tokInfo);
5145                             } break;
5146                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: {
5147                                 dst.Info.__PreWddm2SVM = readTokValue<decltype(dst.Info.__PreWddm2SVM)>(*tokInfo);
5148                             } break;
5149                             };
5150                             tokInfo = tokInfo + 1 + tokInfo->valueDwordCount;
5151                         } else {
5152                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo);
5153                             if (tokInfo->flags.flag3IsMandatory) {
5154                                 return false;
5155                             }
5156                             tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5157                         }
5158                     }
5159                     WCH_ASSERT(tokInfo == tokInfoEnd);
5160                 } break;
5161                 case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: {
5162                     const TokenHeader *tokWa = varLen->getValue<TokenHeader>();
5163                     const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
5164                     while (tokWa < tokWaEnd) {
5165                         if (false == tokWa->flags.flag4IsVariableLength) {
5166                             switch (tokWa->id) {
5167                             default:
5168                                 if (tokWa->flags.flag3IsMandatory) {
5169                                     return false;
5170                                 }
5171                                 break;
5172                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: {
5173                                 dst.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa);
5174                             } break;
5175                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: {
5176                                 dst.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa);
5177                             } break;
5178                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: {
5179                                 dst.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa);
5180                             } break;
5181                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: {
5182                                 dst.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.Wa.NoBufferSamplerPadding)>(*tokWa);
5183                             } break;
5184                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: {
5185                                 dst.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa);
5186                             } break;
5187                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: {
5188                                 dst.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.Wa.CHVAstcSkipVirtualMips)>(*tokWa);
5189                             } break;
5190                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: {
5191                                 dst.Wa.DisablePackedMipTail = readTokValue<decltype(dst.Wa.DisablePackedMipTail)>(*tokWa);
5192                             } break;
5193                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: {
5194                                 dst.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.Wa.__ForceOtherHVALIGN4)>(*tokWa);
5195                             } break;
5196                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: {
5197                                 dst.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.Wa.DisableDisplayCcsClearColor)>(*tokWa);
5198                             } break;
5199                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: {
5200                                 dst.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.Wa.DisableDisplayCcsCompression)>(*tokWa);
5201                             } break;
5202                             case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
5203                                 dst.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.Wa.PreGen12FastClearOnly)>(*tokWa);
5204                             } break;
5205                             };
5206                             tokWa = tokWa + 1 + tokWa->valueDwordCount;
5207                         } else {
5208                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa);
5209                             if (tokWa->flags.flag3IsMandatory) {
5210                                 return false;
5211                             }
5212                             tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5213                         }
5214                     }
5215                     WCH_ASSERT(tokWa == tokWaEnd);
5216                 } break;
5217                 };
5218                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5219             }
5220         }
5221         WCH_ASSERT(tok == srcTokensEnd);
5222         return true;
5223     }
5224 };
5225 
5226 template <>
5227 struct Demarshaller<TOK_S_GMM_RESOURCE_MSAA_INFO_REC> {
5228     template <typename GMM_RESOURCE_MSAA_INFO_RECT>
5229     static bool demarshall(GMM_RESOURCE_MSAA_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
5230         const TokenHeader *tok = srcTokensBeg;
5231         while (tok < srcTokensEnd) {
5232             if (false == tok->flags.flag4IsVariableLength) {
5233                 switch (tok->id) {
5234                 default:
5235                     if (tok->flags.flag3IsMandatory) {
5236                         return false;
5237                     }
5238                     break;
5239                 case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: {
5240                     dst.SamplePattern = readTokValue<decltype(dst.SamplePattern)>(*tok);
5241                 } break;
5242                 case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: {
5243                     dst.NumSamples = readTokValue<decltype(dst.NumSamples)>(*tok);
5244                 } break;
5245                 };
5246                 tok = tok + 1 + tok->valueDwordCount;
5247             } else {
5248                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
5249                 switch (tok->id) {
5250                 default:
5251                     if (tok->flags.flag3IsMandatory) {
5252                         return false;
5253                     }
5254                     break;
5255                 case TOK_S_GMM_RESOURCE_MSAA_INFO_REC:
5256                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
5257                         return false;
5258                     }
5259                     break;
5260                 };
5261                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5262             }
5263         }
5264         WCH_ASSERT(tok == srcTokensEnd);
5265         return true;
5266     }
5267 };
5268 
5269 template <>
5270 struct Demarshaller<TOK_S_GMM_RESOURCE_ALIGNMENT_REC> {
5271     template <typename GMM_RESOURCE_ALIGNMENT_RECT>
5272     static bool demarshall(GMM_RESOURCE_ALIGNMENT_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
5273         const TokenHeader *tok = srcTokensBeg;
5274         while (tok < srcTokensEnd) {
5275             if (false == tok->flags.flag4IsVariableLength) {
5276                 switch (tok->id) {
5277                 default:
5278                     if (tok->flags.flag3IsMandatory) {
5279                         return false;
5280                     }
5281                     break;
5282                 case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: {
5283                     dst.ArraySpacingSingleLod = readTokValue<decltype(dst.ArraySpacingSingleLod)>(*tok);
5284                 } break;
5285                 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: {
5286                     dst.BaseAlignment = readTokValue<decltype(dst.BaseAlignment)>(*tok);
5287                 } break;
5288                 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: {
5289                     dst.HAlign = readTokValue<decltype(dst.HAlign)>(*tok);
5290                 } break;
5291                 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: {
5292                     dst.VAlign = readTokValue<decltype(dst.VAlign)>(*tok);
5293                 } break;
5294                 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: {
5295                     dst.DAlign = readTokValue<decltype(dst.DAlign)>(*tok);
5296                 } break;
5297                 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: {
5298                     dst.MipTailStartLod = readTokValue<decltype(dst.MipTailStartLod)>(*tok);
5299                 } break;
5300                 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: {
5301                     dst.PackedMipStartLod = readTokValue<decltype(dst.PackedMipStartLod)>(*tok);
5302                 } break;
5303                 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: {
5304                     dst.PackedMipWidth = readTokValue<decltype(dst.PackedMipWidth)>(*tok);
5305                 } break;
5306                 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: {
5307                     dst.PackedMipHeight = readTokValue<decltype(dst.PackedMipHeight)>(*tok);
5308                 } break;
5309                 case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: {
5310                     dst.QPitch = readTokValue<decltype(dst.QPitch)>(*tok);
5311                 } break;
5312                 };
5313                 tok = tok + 1 + tok->valueDwordCount;
5314             } else {
5315                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
5316                 switch (tok->id) {
5317                 default:
5318                     if (tok->flags.flag3IsMandatory) {
5319                         return false;
5320                     }
5321                     break;
5322                 case TOK_S_GMM_RESOURCE_ALIGNMENT_REC:
5323                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
5324                         return false;
5325                     }
5326                     break;
5327                 };
5328                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5329             }
5330         }
5331         WCH_ASSERT(tok == srcTokensEnd);
5332         return true;
5333     }
5334 };
5335 
5336 template <>
5337 struct Demarshaller<TOK_S_GMM_S3D_INFO_REC> {
5338     template <typename GMM_S3D_INFO_RECT>
5339     static bool demarshall(GMM_S3D_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
5340         const TokenHeader *tok = srcTokensBeg;
5341         while (tok < srcTokensEnd) {
5342             if (false == tok->flags.flag4IsVariableLength) {
5343                 switch (tok->id) {
5344                 default:
5345                     if (tok->flags.flag3IsMandatory) {
5346                         return false;
5347                     }
5348                     break;
5349                 case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: {
5350                     dst.DisplayModeHeight = readTokValue<decltype(dst.DisplayModeHeight)>(*tok);
5351                 } break;
5352                 case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: {
5353                     dst.NumBlankActiveLines = readTokValue<decltype(dst.NumBlankActiveLines)>(*tok);
5354                 } break;
5355                 case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: {
5356                     dst.RFrameOffset = readTokValue<decltype(dst.RFrameOffset)>(*tok);
5357                 } break;
5358                 case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: {
5359                     dst.BlankAreaOffset = readTokValue<decltype(dst.BlankAreaOffset)>(*tok);
5360                 } break;
5361                 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: {
5362                     dst.TallBufferHeight = readTokValue<decltype(dst.TallBufferHeight)>(*tok);
5363                 } break;
5364                 case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: {
5365                     dst.TallBufferSize = readTokValue<decltype(dst.TallBufferSize)>(*tok);
5366                 } break;
5367                 case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: {
5368                     dst.IsRFrame = readTokValue<decltype(dst.IsRFrame)>(*tok);
5369                 } break;
5370                 };
5371                 tok = tok + 1 + tok->valueDwordCount;
5372             } else {
5373                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
5374                 switch (tok->id) {
5375                 default:
5376                     if (tok->flags.flag3IsMandatory) {
5377                         return false;
5378                     }
5379                     break;
5380                 case TOK_S_GMM_S3D_INFO_REC:
5381                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
5382                         return false;
5383                     }
5384                     break;
5385                 };
5386                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5387             }
5388         }
5389         WCH_ASSERT(tok == srcTokensEnd);
5390         return true;
5391     }
5392 };
5393 
5394 template <>
5395 struct Demarshaller<TOK_S_GMM_MULTI_TILE_ARCH_REC> {
5396     template <typename GMM_MULTI_TILE_ARCH_RECT>
5397     static bool demarshall(GMM_MULTI_TILE_ARCH_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
5398         const TokenHeader *tok = srcTokensBeg;
5399         while (tok < srcTokensEnd) {
5400             if (false == tok->flags.flag4IsVariableLength) {
5401                 switch (tok->id) {
5402                 default:
5403                     if (tok->flags.flag3IsMandatory) {
5404                         return false;
5405                     }
5406                     break;
5407                 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__ENABLE: {
5408                     dst.Enable = readTokValue<decltype(dst.Enable)>(*tok);
5409                 } break;
5410                 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__TILE_INSTANCED: {
5411                     dst.TileInstanced = readTokValue<decltype(dst.TileInstanced)>(*tok);
5412                 } break;
5413                 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__GPU_VA_MAPPING_SET: {
5414                     dst.GpuVaMappingSet = readTokValue<decltype(dst.GpuVaMappingSet)>(*tok);
5415                 } break;
5416                 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_ELIGIBILITY_SET: {
5417                     dst.LocalMemEligibilitySet = readTokValue<decltype(dst.LocalMemEligibilitySet)>(*tok);
5418                 } break;
5419                 case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_PREFERRED_SET: {
5420                     dst.LocalMemPreferredSet = readTokValue<decltype(dst.LocalMemPreferredSet)>(*tok);
5421                 } break;
5422                 };
5423                 tok = tok + 1 + tok->valueDwordCount;
5424             } else {
5425                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
5426                 switch (tok->id) {
5427                 default:
5428                     if (tok->flags.flag3IsMandatory) {
5429                         return false;
5430                     }
5431                     break;
5432                 case TOK_S_GMM_MULTI_TILE_ARCH_REC:
5433                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
5434                         return false;
5435                     }
5436                     break;
5437                 };
5438                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5439             }
5440         }
5441         WCH_ASSERT(tok == srcTokensEnd);
5442         return true;
5443     }
5444 };
5445 
5446 template <>
5447 struct Demarshaller<TOK_S_GMM_PLANAR_OFFSET_INFO_REC> {
5448     template <typename GMM_PLANAR_OFFSET_INFO_RECT>
5449     static bool demarshall(GMM_PLANAR_OFFSET_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
5450         const TokenHeader *tok = srcTokensBeg;
5451         while (tok < srcTokensEnd) {
5452             if (false == tok->flags.flag4IsVariableLength) {
5453                 switch (tok->id) {
5454                 default:
5455                     if (tok->flags.flag3IsMandatory) {
5456                         return false;
5457                     }
5458                     break;
5459                 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: {
5460                     dst.ArrayQPitch = readTokValue<decltype(dst.ArrayQPitch)>(*tok);
5461                 } break;
5462                 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: {
5463                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tok).getValue<char>();
5464                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tok).getValueSizeInBytes();
5465                     if (srcSize < sizeof(dst.X)) {
5466                         return false;
5467                     }
5468                     WCH_SAFE_COPY(dst.X, sizeof(dst.X), srcData, sizeof(dst.X));
5469                 } break;
5470                 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: {
5471                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tok).getValue<char>();
5472                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tok).getValueSizeInBytes();
5473                     if (srcSize < sizeof(dst.Y)) {
5474                         return false;
5475                     }
5476                     WCH_SAFE_COPY(dst.Y, sizeof(dst.Y), srcData, sizeof(dst.Y));
5477                 } break;
5478                 case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: {
5479                     dst.NoOfPlanes = readTokValue<decltype(dst.NoOfPlanes)>(*tok);
5480                 } break;
5481                 case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: {
5482                     dst.IsTileAlignedPlanes = readTokValue<decltype(dst.IsTileAlignedPlanes)>(*tok);
5483                 } break;
5484                 };
5485                 tok = tok + 1 + tok->valueDwordCount;
5486             } else {
5487                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
5488                 switch (tok->id) {
5489                 default:
5490                     if (tok->flags.flag3IsMandatory) {
5491                         return false;
5492                     }
5493                     break;
5494                 case TOK_S_GMM_PLANAR_OFFSET_INFO_REC:
5495                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
5496                         return false;
5497                     }
5498                     break;
5499                 case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: {
5500                     const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>();
5501                     const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
5502                     while (tokUnAligned < tokUnAlignedEnd) {
5503                         if (false == tokUnAligned->flags.flag4IsVariableLength) {
5504                             switch (tokUnAligned->id) {
5505                             default:
5506                                 if (tokUnAligned->flags.flag3IsMandatory) {
5507                                     return false;
5508                                 }
5509                                 break;
5510                             case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: {
5511                                 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>();
5512                                 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes();
5513                                 if (srcSize < sizeof(dst.UnAligned.Height)) {
5514                                     return false;
5515                                 }
5516                                 WCH_SAFE_COPY(dst.UnAligned.Height, sizeof(dst.UnAligned.Height), srcData, sizeof(dst.UnAligned.Height));
5517                             } break;
5518                             };
5519                             tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount;
5520                         } else {
5521                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned);
5522                             if (tokUnAligned->flags.flag3IsMandatory) {
5523                                 return false;
5524                             }
5525                             tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5526                         }
5527                     }
5528                     WCH_ASSERT(tokUnAligned == tokUnAlignedEnd);
5529                 } break;
5530                 };
5531                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5532             }
5533         }
5534         WCH_ASSERT(tok == srcTokensEnd);
5535         return true;
5536     }
5537 };
5538 
5539 template <>
5540 struct Demarshaller<TOK_S_GMM_2D_TEXTURE_OFFSET_INFO_REC> {
5541     template <typename GMM_2D_TEXTURE_OFFSET_INFO_RECT>
5542     static bool demarshall(GMM_2D_TEXTURE_OFFSET_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
5543         const TokenHeader *tok = srcTokensBeg;
5544         while (tok < srcTokensEnd) {
5545             if (false == tok->flags.flag4IsVariableLength) {
5546                 switch (tok->id) {
5547                 default:
5548                     if (tok->flags.flag3IsMandatory) {
5549                         return false;
5550                     }
5551                     break;
5552                 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: {
5553                     dst.ArrayQPitchLock = readTokValue<decltype(dst.ArrayQPitchLock)>(*tok);
5554                 } break;
5555                 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: {
5556                     dst.ArrayQPitchRender = readTokValue<decltype(dst.ArrayQPitchRender)>(*tok);
5557                 } break;
5558                 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
5559                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tok).getValue<char>();
5560                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tok).getValueSizeInBytes();
5561                     if (srcSize < sizeof(dst.Offset)) {
5562                         return false;
5563                     }
5564                     WCH_SAFE_COPY(dst.Offset, sizeof(dst.Offset), srcData, sizeof(dst.Offset));
5565                 } break;
5566                 };
5567                 tok = tok + 1 + tok->valueDwordCount;
5568             } else {
5569                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
5570                 switch (tok->id) {
5571                 default:
5572                     if (tok->flags.flag3IsMandatory) {
5573                         return false;
5574                     }
5575                     break;
5576                 case TOK_S_GMM_2D_TEXTURE_OFFSET_INFO_REC:
5577                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
5578                         return false;
5579                     }
5580                     break;
5581                 };
5582                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5583             }
5584         }
5585         WCH_ASSERT(tok == srcTokensEnd);
5586         return true;
5587     }
5588 };
5589 
5590 template <>
5591 struct Demarshaller<TOK_S_GMM_3D_TEXTURE_OFFSET_INFO_REC> {
5592     template <typename GMM_3D_TEXTURE_OFFSET_INFO_RECT>
5593     static bool demarshall(GMM_3D_TEXTURE_OFFSET_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
5594         const TokenHeader *tok = srcTokensBeg;
5595         while (tok < srcTokensEnd) {
5596             if (false == tok->flags.flag4IsVariableLength) {
5597                 switch (tok->id) {
5598                 default:
5599                     if (tok->flags.flag3IsMandatory) {
5600                         return false;
5601                     }
5602                     break;
5603                 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: {
5604                     dst.Mip0SlicePitch = readTokValue<decltype(dst.Mip0SlicePitch)>(*tok);
5605                 } break;
5606                 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
5607                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tok).getValue<char>();
5608                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tok).getValueSizeInBytes();
5609                     if (srcSize < sizeof(dst.Offset)) {
5610                         return false;
5611                     }
5612                     WCH_SAFE_COPY(dst.Offset, sizeof(dst.Offset), srcData, sizeof(dst.Offset));
5613                 } break;
5614                 };
5615                 tok = tok + 1 + tok->valueDwordCount;
5616             } else {
5617                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
5618                 switch (tok->id) {
5619                 default:
5620                     if (tok->flags.flag3IsMandatory) {
5621                         return false;
5622                     }
5623                     break;
5624                 case TOK_S_GMM_3D_TEXTURE_OFFSET_INFO_REC:
5625                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
5626                         return false;
5627                     }
5628                     break;
5629                 };
5630                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5631             }
5632         }
5633         WCH_ASSERT(tok == srcTokensEnd);
5634         return true;
5635     }
5636 };
5637 
5638 template <>
5639 struct Demarshaller<TOK_S_GMM_OFFSET_INFO_REC> {
5640     template <typename GMM_OFFSET_INFO_RECT>
5641     static bool demarshall(GMM_OFFSET_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
5642         const TokenHeader *tok = srcTokensBeg;
5643         while (tok < srcTokensEnd) {
5644             if (false == tok->flags.flag4IsVariableLength) {
5645                 if (tok->flags.flag3IsMandatory) {
5646                     return false;
5647                 }
5648                 tok = tok + 1 + tok->valueDwordCount;
5649             } else {
5650                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
5651                 switch (tok->id) {
5652                 default:
5653                     if (tok->flags.flag3IsMandatory) {
5654                         return false;
5655                     }
5656                     break;
5657                 case TOK_S_GMM_OFFSET_INFO_REC:
5658                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
5659                         return false;
5660                     }
5661                     break;
5662                 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: {
5663                     const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>();
5664                     const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
5665                     while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) {
5666                         if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) {
5667                             switch (tokTexture3DOffsetInfo->id) {
5668                             default:
5669                                 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
5670                                     return false;
5671                                 }
5672                                 break;
5673                             case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: {
5674                                 dst.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo);
5675                             } break;
5676                             case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
5677                                 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>();
5678                                 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes();
5679                                 if (srcSize < sizeof(dst.Texture3DOffsetInfo.Offset)) {
5680                                     return false;
5681                                 }
5682                                 WCH_SAFE_COPY(dst.Texture3DOffsetInfo.Offset, sizeof(dst.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.Texture3DOffsetInfo.Offset));
5683                             } break;
5684                             };
5685                             tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount;
5686                         } else {
5687                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo);
5688                             if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
5689                                 return false;
5690                             }
5691                             tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5692                         }
5693                     }
5694                     WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd);
5695                 } break;
5696                 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: {
5697                     const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>();
5698                     const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
5699                     while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) {
5700                         if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) {
5701                             switch (tokTexture2DOffsetInfo->id) {
5702                             default:
5703                                 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
5704                                     return false;
5705                                 }
5706                                 break;
5707                             case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: {
5708                                 dst.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo);
5709                             } break;
5710                             case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: {
5711                                 dst.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo);
5712                             } break;
5713                             case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
5714                                 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>();
5715                                 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes();
5716                                 if (srcSize < sizeof(dst.Texture2DOffsetInfo.Offset)) {
5717                                     return false;
5718                                 }
5719                                 WCH_SAFE_COPY(dst.Texture2DOffsetInfo.Offset, sizeof(dst.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.Texture2DOffsetInfo.Offset));
5720                             } break;
5721                             };
5722                             tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount;
5723                         } else {
5724                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo);
5725                             if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
5726                                 return false;
5727                             }
5728                             tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5729                         }
5730                     }
5731                     WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd);
5732                 } break;
5733                 case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: {
5734                     const TokenHeader *tokPlane = varLen->getValue<TokenHeader>();
5735                     const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
5736                     while (tokPlane < tokPlaneEnd) {
5737                         if (false == tokPlane->flags.flag4IsVariableLength) {
5738                             switch (tokPlane->id) {
5739                             default:
5740                                 if (tokPlane->flags.flag3IsMandatory) {
5741                                     return false;
5742                                 }
5743                                 break;
5744                             case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: {
5745                                 dst.Plane.ArrayQPitch = readTokValue<decltype(dst.Plane.ArrayQPitch)>(*tokPlane);
5746                             } break;
5747                             case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: {
5748                                 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
5749                                 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
5750                                 if (srcSize < sizeof(dst.Plane.X)) {
5751                                     return false;
5752                                 }
5753                                 WCH_SAFE_COPY(dst.Plane.X, sizeof(dst.Plane.X), srcData, sizeof(dst.Plane.X));
5754                             } break;
5755                             case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: {
5756                                 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
5757                                 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
5758                                 if (srcSize < sizeof(dst.Plane.Y)) {
5759                                     return false;
5760                                 }
5761                                 WCH_SAFE_COPY(dst.Plane.Y, sizeof(dst.Plane.Y), srcData, sizeof(dst.Plane.Y));
5762                             } break;
5763                             case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: {
5764                                 dst.Plane.NoOfPlanes = readTokValue<decltype(dst.Plane.NoOfPlanes)>(*tokPlane);
5765                             } break;
5766                             case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: {
5767                                 dst.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.Plane.IsTileAlignedPlanes)>(*tokPlane);
5768                             } break;
5769                             };
5770                             tokPlane = tokPlane + 1 + tokPlane->valueDwordCount;
5771                         } else {
5772                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane);
5773                             switch (tokPlane->id) {
5774                             default:
5775                                 if (tokPlane->flags.flag3IsMandatory) {
5776                                     return false;
5777                                 }
5778                                 break;
5779                             case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: {
5780                                 const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>();
5781                                 const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
5782                                 while (tokUnAligned < tokUnAlignedEnd) {
5783                                     if (false == tokUnAligned->flags.flag4IsVariableLength) {
5784                                         switch (tokUnAligned->id) {
5785                                         default:
5786                                             if (tokUnAligned->flags.flag3IsMandatory) {
5787                                                 return false;
5788                                             }
5789                                             break;
5790                                         case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: {
5791                                             auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>();
5792                                             auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes();
5793                                             if (srcSize < sizeof(dst.Plane.UnAligned.Height)) {
5794                                                 return false;
5795                                             }
5796                                             WCH_SAFE_COPY(dst.Plane.UnAligned.Height, sizeof(dst.Plane.UnAligned.Height), srcData, sizeof(dst.Plane.UnAligned.Height));
5797                                         } break;
5798                                         };
5799                                         tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount;
5800                                     } else {
5801                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned);
5802                                         if (tokUnAligned->flags.flag3IsMandatory) {
5803                                             return false;
5804                                         }
5805                                         tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5806                                     }
5807                                 }
5808                                 WCH_ASSERT(tokUnAligned == tokUnAlignedEnd);
5809                             } break;
5810                             };
5811                             tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5812                         }
5813                     }
5814                     WCH_ASSERT(tokPlane == tokPlaneEnd);
5815                 } break;
5816                 };
5817                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
5818             }
5819         }
5820         WCH_ASSERT(tok == srcTokensEnd);
5821         return true;
5822     }
5823 };
5824 
5825 template <>
5826 struct Demarshaller<TOK_S_GMM_TEXTURE_INFO_REC> {
5827     template <typename GMM_TEXTURE_INFO_RECT>
5828     static bool demarshall(GMM_TEXTURE_INFO_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
5829         const TokenHeader *tok = srcTokensBeg;
5830         while (tok < srcTokensEnd) {
5831             if (false == tok->flags.flag4IsVariableLength) {
5832                 switch (tok->id) {
5833                 default:
5834                     if (tok->flags.flag3IsMandatory) {
5835                         return false;
5836                     }
5837                     break;
5838                 case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: {
5839                     dst.Type = readTokValue<decltype(dst.Type)>(*tok);
5840                 } break;
5841                 case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: {
5842                     dst.Format = readTokValue<decltype(dst.Format)>(*tok);
5843                 } break;
5844                 case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: {
5845                     dst.BitsPerPixel = readTokValue<decltype(dst.BitsPerPixel)>(*tok);
5846                 } break;
5847                 case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: {
5848                     dst.BaseWidth = readTokValue<decltype(dst.BaseWidth)>(*tok);
5849                 } break;
5850                 case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: {
5851                     dst.BaseHeight = readTokValue<decltype(dst.BaseHeight)>(*tok);
5852                 } break;
5853                 case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: {
5854                     dst.Depth = readTokValue<decltype(dst.Depth)>(*tok);
5855                 } break;
5856                 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: {
5857                     dst.MaxLod = readTokValue<decltype(dst.MaxLod)>(*tok);
5858                 } break;
5859                 case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: {
5860                     dst.ArraySize = readTokValue<decltype(dst.ArraySize)>(*tok);
5861                 } break;
5862                 case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: {
5863                     dst.CpTag = readTokValue<decltype(dst.CpTag)>(*tok);
5864                 } break;
5865                 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: {
5866                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tok).getValue<char>();
5867                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tok).getValueSizeInBytes();
5868                     if (srcSize < sizeof(dst.MmcMode)) {
5869                         return false;
5870                     }
5871                     WCH_SAFE_COPY(dst.MmcMode, sizeof(dst.MmcMode), srcData, sizeof(dst.MmcMode));
5872                 } break;
5873                 case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: {
5874                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tok).getValue<char>();
5875                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tok).getValueSizeInBytes();
5876                     if (srcSize < sizeof(dst.MmcHint)) {
5877                         return false;
5878                     }
5879                     WCH_SAFE_COPY(dst.MmcHint, sizeof(dst.MmcHint), srcData, sizeof(dst.MmcHint));
5880                 } break;
5881                 case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: {
5882                     dst.Pitch = readTokValue<decltype(dst.Pitch)>(*tok);
5883                 } break;
5884                 case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: {
5885                     dst.OverridePitch = readTokValue<decltype(dst.OverridePitch)>(*tok);
5886                 } break;
5887                 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: {
5888                     dst.Size = readTokValue<decltype(dst.Size)>(*tok);
5889                 } break;
5890                 case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: {
5891                     dst.CCSize = readTokValue<decltype(dst.CCSize)>(*tok);
5892                 } break;
5893                 case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: {
5894                     dst.UnpaddedSize = readTokValue<decltype(dst.UnpaddedSize)>(*tok);
5895                 } break;
5896                 case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: {
5897                     dst.SizeReportToOS = readTokValue<decltype(dst.SizeReportToOS)>(*tok);
5898                 } break;
5899                 case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: {
5900                     dst.TileMode = readTokValue<decltype(dst.TileMode)>(*tok);
5901                 } break;
5902                 case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: {
5903                     dst.CCSModeAlign = readTokValue<decltype(dst.CCSModeAlign)>(*tok);
5904                 } break;
5905                 case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: {
5906                     dst.LegacyFlags = readTokValue<decltype(dst.LegacyFlags)>(*tok);
5907                 } break;
5908                 case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: {
5909                     dst.MaximumRenamingListLength = readTokValue<decltype(dst.MaximumRenamingListLength)>(*tok);
5910                 } break;
5911                 };
5912                 tok = tok + 1 + tok->valueDwordCount;
5913             } else {
5914                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
5915                 switch (tok->id) {
5916                 default:
5917                     if (tok->flags.flag3IsMandatory) {
5918                         return false;
5919                     }
5920                     break;
5921                 case TOK_S_GMM_TEXTURE_INFO_REC:
5922                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
5923                         return false;
5924                     }
5925                     break;
5926                 case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: {
5927                     const TokenHeader *tokFlags = varLen->getValue<TokenHeader>();
5928                     const TokenHeader *tokFlagsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
5929                     while (tokFlags < tokFlagsEnd) {
5930                         if (false == tokFlags->flags.flag4IsVariableLength) {
5931                             if (tokFlags->flags.flag3IsMandatory) {
5932                                 return false;
5933                             }
5934                             tokFlags = tokFlags + 1 + tokFlags->valueDwordCount;
5935                         } else {
5936                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokFlags);
5937                             switch (tokFlags->id) {
5938                             default:
5939                                 if (tokFlags->flags.flag3IsMandatory) {
5940                                     return false;
5941                                 }
5942                                 break;
5943                             case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: {
5944                                 const TokenHeader *tokGpu = varLen->getValue<TokenHeader>();
5945                                 const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
5946                                 while (tokGpu < tokGpuEnd) {
5947                                     if (false == tokGpu->flags.flag4IsVariableLength) {
5948                                         switch (tokGpu->id) {
5949                                         default:
5950                                             if (tokGpu->flags.flag3IsMandatory) {
5951                                                 return false;
5952                                             }
5953                                             break;
5954                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: {
5955                                             dst.Flags.Gpu.CameraCapture = readTokValue<decltype(dst.Flags.Gpu.CameraCapture)>(*tokGpu);
5956                                         } break;
5957                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: {
5958                                             dst.Flags.Gpu.CCS = readTokValue<decltype(dst.Flags.Gpu.CCS)>(*tokGpu);
5959                                         } break;
5960                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: {
5961                                             dst.Flags.Gpu.ColorDiscard = readTokValue<decltype(dst.Flags.Gpu.ColorDiscard)>(*tokGpu);
5962                                         } break;
5963                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: {
5964                                             dst.Flags.Gpu.ColorSeparation = readTokValue<decltype(dst.Flags.Gpu.ColorSeparation)>(*tokGpu);
5965                                         } break;
5966                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: {
5967                                             dst.Flags.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.Flags.Gpu.ColorSeparationRGBX)>(*tokGpu);
5968                                         } break;
5969                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: {
5970                                             dst.Flags.Gpu.Constant = readTokValue<decltype(dst.Flags.Gpu.Constant)>(*tokGpu);
5971                                         } break;
5972                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: {
5973                                             dst.Flags.Gpu.Depth = readTokValue<decltype(dst.Flags.Gpu.Depth)>(*tokGpu);
5974                                         } break;
5975                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: {
5976                                             dst.Flags.Gpu.FlipChain = readTokValue<decltype(dst.Flags.Gpu.FlipChain)>(*tokGpu);
5977                                         } break;
5978                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: {
5979                                             dst.Flags.Gpu.FlipChainPreferred = readTokValue<decltype(dst.Flags.Gpu.FlipChainPreferred)>(*tokGpu);
5980                                         } break;
5981                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: {
5982                                             dst.Flags.Gpu.HistoryBuffer = readTokValue<decltype(dst.Flags.Gpu.HistoryBuffer)>(*tokGpu);
5983                                         } break;
5984                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: {
5985                                             dst.Flags.Gpu.HiZ = readTokValue<decltype(dst.Flags.Gpu.HiZ)>(*tokGpu);
5986                                         } break;
5987                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: {
5988                                             dst.Flags.Gpu.Index = readTokValue<decltype(dst.Flags.Gpu.Index)>(*tokGpu);
5989                                         } break;
5990                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: {
5991                                             dst.Flags.Gpu.IndirectClearColor = readTokValue<decltype(dst.Flags.Gpu.IndirectClearColor)>(*tokGpu);
5992                                         } break;
5993                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: {
5994                                             dst.Flags.Gpu.InstructionFlat = readTokValue<decltype(dst.Flags.Gpu.InstructionFlat)>(*tokGpu);
5995                                         } break;
5996                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: {
5997                                             dst.Flags.Gpu.InterlacedScan = readTokValue<decltype(dst.Flags.Gpu.InterlacedScan)>(*tokGpu);
5998                                         } break;
5999                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: {
6000                                             dst.Flags.Gpu.MCS = readTokValue<decltype(dst.Flags.Gpu.MCS)>(*tokGpu);
6001                                         } break;
6002                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: {
6003                                             dst.Flags.Gpu.MMC = readTokValue<decltype(dst.Flags.Gpu.MMC)>(*tokGpu);
6004                                         } break;
6005                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: {
6006                                             dst.Flags.Gpu.MotionComp = readTokValue<decltype(dst.Flags.Gpu.MotionComp)>(*tokGpu);
6007                                         } break;
6008                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: {
6009                                             dst.Flags.Gpu.NoRestriction = readTokValue<decltype(dst.Flags.Gpu.NoRestriction)>(*tokGpu);
6010                                         } break;
6011                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: {
6012                                             dst.Flags.Gpu.Overlay = readTokValue<decltype(dst.Flags.Gpu.Overlay)>(*tokGpu);
6013                                         } break;
6014                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: {
6015                                             dst.Flags.Gpu.Presentable = readTokValue<decltype(dst.Flags.Gpu.Presentable)>(*tokGpu);
6016                                         } break;
6017                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: {
6018                                             dst.Flags.Gpu.ProceduralTexture = readTokValue<decltype(dst.Flags.Gpu.ProceduralTexture)>(*tokGpu);
6019                                         } break;
6020                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: {
6021                                             dst.Flags.Gpu.Query = readTokValue<decltype(dst.Flags.Gpu.Query)>(*tokGpu);
6022                                         } break;
6023                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: {
6024                                             dst.Flags.Gpu.RenderTarget = readTokValue<decltype(dst.Flags.Gpu.RenderTarget)>(*tokGpu);
6025                                         } break;
6026                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: {
6027                                             dst.Flags.Gpu.S3d = readTokValue<decltype(dst.Flags.Gpu.S3d)>(*tokGpu);
6028                                         } break;
6029                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: {
6030                                             dst.Flags.Gpu.S3dDx = readTokValue<decltype(dst.Flags.Gpu.S3dDx)>(*tokGpu);
6031                                         } break;
6032                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: {
6033                                             dst.Flags.Gpu.__S3dNonPacked = readTokValue<decltype(dst.Flags.Gpu.__S3dNonPacked)>(*tokGpu);
6034                                         } break;
6035                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: {
6036                                             dst.Flags.Gpu.__S3dWidi = readTokValue<decltype(dst.Flags.Gpu.__S3dWidi)>(*tokGpu);
6037                                         } break;
6038                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: {
6039                                             dst.Flags.Gpu.ScratchFlat = readTokValue<decltype(dst.Flags.Gpu.ScratchFlat)>(*tokGpu);
6040                                         } break;
6041                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: {
6042                                             dst.Flags.Gpu.SeparateStencil = readTokValue<decltype(dst.Flags.Gpu.SeparateStencil)>(*tokGpu);
6043                                         } break;
6044                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: {
6045                                             dst.Flags.Gpu.State = readTokValue<decltype(dst.Flags.Gpu.State)>(*tokGpu);
6046                                         } break;
6047                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: {
6048                                             dst.Flags.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.Flags.Gpu.StateDx9ConstantBuffer)>(*tokGpu);
6049                                         } break;
6050                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: {
6051                                             dst.Flags.Gpu.Stream = readTokValue<decltype(dst.Flags.Gpu.Stream)>(*tokGpu);
6052                                         } break;
6053                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: {
6054                                             dst.Flags.Gpu.TextApi = readTokValue<decltype(dst.Flags.Gpu.TextApi)>(*tokGpu);
6055                                         } break;
6056                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: {
6057                                             dst.Flags.Gpu.Texture = readTokValue<decltype(dst.Flags.Gpu.Texture)>(*tokGpu);
6058                                         } break;
6059                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: {
6060                                             dst.Flags.Gpu.TiledResource = readTokValue<decltype(dst.Flags.Gpu.TiledResource)>(*tokGpu);
6061                                         } break;
6062                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: {
6063                                             dst.Flags.Gpu.TilePool = readTokValue<decltype(dst.Flags.Gpu.TilePool)>(*tokGpu);
6064                                         } break;
6065                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: {
6066                                             dst.Flags.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.Flags.Gpu.UnifiedAuxSurface)>(*tokGpu);
6067                                         } break;
6068                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: {
6069                                             dst.Flags.Gpu.Vertex = readTokValue<decltype(dst.Flags.Gpu.Vertex)>(*tokGpu);
6070                                         } break;
6071                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: {
6072                                             dst.Flags.Gpu.Video = readTokValue<decltype(dst.Flags.Gpu.Video)>(*tokGpu);
6073                                         } break;
6074                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: {
6075                                             dst.Flags.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.Flags.Gpu.__NonMsaaTileXCcs)>(*tokGpu);
6076                                         } break;
6077                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: {
6078                                             dst.Flags.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.Flags.Gpu.__NonMsaaTileYCcs)>(*tokGpu);
6079                                         } break;
6080                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: {
6081                                             dst.Flags.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.Flags.Gpu.__MsaaTileMcs)>(*tokGpu);
6082                                         } break;
6083                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: {
6084                                             dst.Flags.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.Flags.Gpu.__NonMsaaLinearCCS)>(*tokGpu);
6085                                         } break;
6086                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: {
6087                                             dst.Flags.Gpu.__Remaining = readTokValue<decltype(dst.Flags.Gpu.__Remaining)>(*tokGpu);
6088                                         } break;
6089                                         };
6090                                         tokGpu = tokGpu + 1 + tokGpu->valueDwordCount;
6091                                     } else {
6092                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu);
6093                                         if (tokGpu->flags.flag3IsMandatory) {
6094                                             return false;
6095                                         }
6096                                         tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6097                                     }
6098                                 }
6099                                 WCH_ASSERT(tokGpu == tokGpuEnd);
6100                             } break;
6101                             case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: {
6102                                 const TokenHeader *tokInfo = varLen->getValue<TokenHeader>();
6103                                 const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6104                                 while (tokInfo < tokInfoEnd) {
6105                                     if (false == tokInfo->flags.flag4IsVariableLength) {
6106                                         switch (tokInfo->id) {
6107                                         default:
6108                                             if (tokInfo->flags.flag3IsMandatory) {
6109                                                 return false;
6110                                             }
6111                                             break;
6112                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: {
6113                                             dst.Flags.Info.AllowVirtualPadding = readTokValue<decltype(dst.Flags.Info.AllowVirtualPadding)>(*tokInfo);
6114                                         } break;
6115                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: {
6116                                             dst.Flags.Info.BigPage = readTokValue<decltype(dst.Flags.Info.BigPage)>(*tokInfo);
6117                                         } break;
6118                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: {
6119                                             dst.Flags.Info.Cacheable = readTokValue<decltype(dst.Flags.Info.Cacheable)>(*tokInfo);
6120                                         } break;
6121                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: {
6122                                             dst.Flags.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.Flags.Info.ContigPhysMemoryForiDART)>(*tokInfo);
6123                                         } break;
6124                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: {
6125                                             dst.Flags.Info.CornerTexelMode = readTokValue<decltype(dst.Flags.Info.CornerTexelMode)>(*tokInfo);
6126                                         } break;
6127                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: {
6128                                             dst.Flags.Info.ExistingSysMem = readTokValue<decltype(dst.Flags.Info.ExistingSysMem)>(*tokInfo);
6129                                         } break;
6130                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: {
6131                                             dst.Flags.Info.ForceResidency = readTokValue<decltype(dst.Flags.Info.ForceResidency)>(*tokInfo);
6132                                         } break;
6133                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: {
6134                                             dst.Flags.Info.Gfdt = readTokValue<decltype(dst.Flags.Info.Gfdt)>(*tokInfo);
6135                                         } break;
6136                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: {
6137                                             dst.Flags.Info.GttMapType = readTokValue<decltype(dst.Flags.Info.GttMapType)>(*tokInfo);
6138                                         } break;
6139                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: {
6140                                             dst.Flags.Info.HardwareProtected = readTokValue<decltype(dst.Flags.Info.HardwareProtected)>(*tokInfo);
6141                                         } break;
6142                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: {
6143                                             dst.Flags.Info.KernelModeMapped = readTokValue<decltype(dst.Flags.Info.KernelModeMapped)>(*tokInfo);
6144                                         } break;
6145                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: {
6146                                             dst.Flags.Info.LayoutBelow = readTokValue<decltype(dst.Flags.Info.LayoutBelow)>(*tokInfo);
6147                                         } break;
6148                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: {
6149                                             dst.Flags.Info.LayoutMono = readTokValue<decltype(dst.Flags.Info.LayoutMono)>(*tokInfo);
6150                                         } break;
6151                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: {
6152                                             dst.Flags.Info.LayoutRight = readTokValue<decltype(dst.Flags.Info.LayoutRight)>(*tokInfo);
6153                                         } break;
6154                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: {
6155                                             dst.Flags.Info.LocalOnly = readTokValue<decltype(dst.Flags.Info.LocalOnly)>(*tokInfo);
6156                                         } break;
6157                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: {
6158                                             dst.Flags.Info.Linear = readTokValue<decltype(dst.Flags.Info.Linear)>(*tokInfo);
6159                                         } break;
6160                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: {
6161                                             dst.Flags.Info.MediaCompressed = readTokValue<decltype(dst.Flags.Info.MediaCompressed)>(*tokInfo);
6162                                         } break;
6163                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: {
6164                                             dst.Flags.Info.NoOptimizationPadding = readTokValue<decltype(dst.Flags.Info.NoOptimizationPadding)>(*tokInfo);
6165                                         } break;
6166                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: {
6167                                             dst.Flags.Info.NoPhysMemory = readTokValue<decltype(dst.Flags.Info.NoPhysMemory)>(*tokInfo);
6168                                         } break;
6169                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: {
6170                                             dst.Flags.Info.NotLockable = readTokValue<decltype(dst.Flags.Info.NotLockable)>(*tokInfo);
6171                                         } break;
6172                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: {
6173                                             dst.Flags.Info.NonLocalOnly = readTokValue<decltype(dst.Flags.Info.NonLocalOnly)>(*tokInfo);
6174                                         } break;
6175                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: {
6176                                             dst.Flags.Info.StdSwizzle = readTokValue<decltype(dst.Flags.Info.StdSwizzle)>(*tokInfo);
6177                                         } break;
6178                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: {
6179                                             dst.Flags.Info.PseudoStdSwizzle = readTokValue<decltype(dst.Flags.Info.PseudoStdSwizzle)>(*tokInfo);
6180                                         } break;
6181                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: {
6182                                             dst.Flags.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.Flags.Info.Undefined64KBSwizzle)>(*tokInfo);
6183                                         } break;
6184                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: {
6185                                             dst.Flags.Info.RedecribedPlanes = readTokValue<decltype(dst.Flags.Info.RedecribedPlanes)>(*tokInfo);
6186                                         } break;
6187                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: {
6188                                             dst.Flags.Info.RenderCompressed = readTokValue<decltype(dst.Flags.Info.RenderCompressed)>(*tokInfo);
6189                                         } break;
6190                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: {
6191                                             dst.Flags.Info.Rotated = readTokValue<decltype(dst.Flags.Info.Rotated)>(*tokInfo);
6192                                         } break;
6193                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: {
6194                                             dst.Flags.Info.Shared = readTokValue<decltype(dst.Flags.Info.Shared)>(*tokInfo);
6195                                         } break;
6196                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: {
6197                                             dst.Flags.Info.SoftwareProtected = readTokValue<decltype(dst.Flags.Info.SoftwareProtected)>(*tokInfo);
6198                                         } break;
6199                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: {
6200                                             dst.Flags.Info.SVM = readTokValue<decltype(dst.Flags.Info.SVM)>(*tokInfo);
6201                                         } break;
6202                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: {
6203                                             dst.Flags.Info.Tile4 = readTokValue<decltype(dst.Flags.Info.Tile4)>(*tokInfo);
6204                                         } break;
6205                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: {
6206                                             dst.Flags.Info.Tile64 = readTokValue<decltype(dst.Flags.Info.Tile64)>(*tokInfo);
6207                                         } break;
6208                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: {
6209                                             dst.Flags.Info.TiledW = readTokValue<decltype(dst.Flags.Info.TiledW)>(*tokInfo);
6210                                         } break;
6211                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: {
6212                                             dst.Flags.Info.TiledX = readTokValue<decltype(dst.Flags.Info.TiledX)>(*tokInfo);
6213                                         } break;
6214                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: {
6215                                             dst.Flags.Info.TiledY = readTokValue<decltype(dst.Flags.Info.TiledY)>(*tokInfo);
6216                                         } break;
6217                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: {
6218                                             dst.Flags.Info.TiledYf = readTokValue<decltype(dst.Flags.Info.TiledYf)>(*tokInfo);
6219                                         } break;
6220                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: {
6221                                             dst.Flags.Info.TiledYs = readTokValue<decltype(dst.Flags.Info.TiledYs)>(*tokInfo);
6222                                         } break;
6223                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: {
6224                                             dst.Flags.Info.WddmProtected = readTokValue<decltype(dst.Flags.Info.WddmProtected)>(*tokInfo);
6225                                         } break;
6226                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: {
6227                                             dst.Flags.Info.XAdapter = readTokValue<decltype(dst.Flags.Info.XAdapter)>(*tokInfo);
6228                                         } break;
6229                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: {
6230                                             dst.Flags.Info.__PreallocatedResInfo = readTokValue<decltype(dst.Flags.Info.__PreallocatedResInfo)>(*tokInfo);
6231                                         } break;
6232                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: {
6233                                             dst.Flags.Info.__PreWddm2SVM = readTokValue<decltype(dst.Flags.Info.__PreWddm2SVM)>(*tokInfo);
6234                                         } break;
6235                                         };
6236                                         tokInfo = tokInfo + 1 + tokInfo->valueDwordCount;
6237                                     } else {
6238                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo);
6239                                         if (tokInfo->flags.flag3IsMandatory) {
6240                                             return false;
6241                                         }
6242                                         tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6243                                     }
6244                                 }
6245                                 WCH_ASSERT(tokInfo == tokInfoEnd);
6246                             } break;
6247                             case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: {
6248                                 const TokenHeader *tokWa = varLen->getValue<TokenHeader>();
6249                                 const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6250                                 while (tokWa < tokWaEnd) {
6251                                     if (false == tokWa->flags.flag4IsVariableLength) {
6252                                         switch (tokWa->id) {
6253                                         default:
6254                                             if (tokWa->flags.flag3IsMandatory) {
6255                                                 return false;
6256                                             }
6257                                             break;
6258                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: {
6259                                             dst.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa);
6260                                         } break;
6261                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: {
6262                                             dst.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.Flags.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa);
6263                                         } break;
6264                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: {
6265                                             dst.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa);
6266                                         } break;
6267                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: {
6268                                             dst.Flags.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.Flags.Wa.NoBufferSamplerPadding)>(*tokWa);
6269                                         } break;
6270                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: {
6271                                             dst.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa);
6272                                         } break;
6273                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: {
6274                                             dst.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.Flags.Wa.CHVAstcSkipVirtualMips)>(*tokWa);
6275                                         } break;
6276                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: {
6277                                             dst.Flags.Wa.DisablePackedMipTail = readTokValue<decltype(dst.Flags.Wa.DisablePackedMipTail)>(*tokWa);
6278                                         } break;
6279                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: {
6280                                             dst.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.Flags.Wa.__ForceOtherHVALIGN4)>(*tokWa);
6281                                         } break;
6282                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: {
6283                                             dst.Flags.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.Flags.Wa.DisableDisplayCcsClearColor)>(*tokWa);
6284                                         } break;
6285                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: {
6286                                             dst.Flags.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.Flags.Wa.DisableDisplayCcsCompression)>(*tokWa);
6287                                         } break;
6288                                         case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
6289                                             dst.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.Flags.Wa.PreGen12FastClearOnly)>(*tokWa);
6290                                         } break;
6291                                         };
6292                                         tokWa = tokWa + 1 + tokWa->valueDwordCount;
6293                                     } else {
6294                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa);
6295                                         if (tokWa->flags.flag3IsMandatory) {
6296                                             return false;
6297                                         }
6298                                         tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6299                                     }
6300                                 }
6301                                 WCH_ASSERT(tokWa == tokWaEnd);
6302                             } break;
6303                             };
6304                             tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6305                         }
6306                     }
6307                     WCH_ASSERT(tokFlags == tokFlagsEnd);
6308                 } break;
6309                 case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: {
6310                     const TokenHeader *tokCachePolicy = varLen->getValue<TokenHeader>();
6311                     const TokenHeader *tokCachePolicyEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6312                     while (tokCachePolicy < tokCachePolicyEnd) {
6313                         if (false == tokCachePolicy->flags.flag4IsVariableLength) {
6314                             switch (tokCachePolicy->id) {
6315                             default:
6316                                 if (tokCachePolicy->flags.flag3IsMandatory) {
6317                                     return false;
6318                                 }
6319                                 break;
6320                             case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: {
6321                                 dst.CachePolicy.Usage = readTokValue<decltype(dst.CachePolicy.Usage)>(*tokCachePolicy);
6322                             } break;
6323                             };
6324                             tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount;
6325                         } else {
6326                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCachePolicy);
6327                             if (tokCachePolicy->flags.flag3IsMandatory) {
6328                                 return false;
6329                             }
6330                             tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6331                         }
6332                     }
6333                     WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd);
6334                 } break;
6335                 case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: {
6336                     const TokenHeader *tokMSAA = varLen->getValue<TokenHeader>();
6337                     const TokenHeader *tokMSAAEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6338                     while (tokMSAA < tokMSAAEnd) {
6339                         if (false == tokMSAA->flags.flag4IsVariableLength) {
6340                             switch (tokMSAA->id) {
6341                             default:
6342                                 if (tokMSAA->flags.flag3IsMandatory) {
6343                                     return false;
6344                                 }
6345                                 break;
6346                             case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: {
6347                                 dst.MSAA.SamplePattern = readTokValue<decltype(dst.MSAA.SamplePattern)>(*tokMSAA);
6348                             } break;
6349                             case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: {
6350                                 dst.MSAA.NumSamples = readTokValue<decltype(dst.MSAA.NumSamples)>(*tokMSAA);
6351                             } break;
6352                             };
6353                             tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount;
6354                         } else {
6355                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMSAA);
6356                             if (tokMSAA->flags.flag3IsMandatory) {
6357                                 return false;
6358                             }
6359                             tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6360                         }
6361                     }
6362                     WCH_ASSERT(tokMSAA == tokMSAAEnd);
6363                 } break;
6364                 case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: {
6365                     const TokenHeader *tokAlignment = varLen->getValue<TokenHeader>();
6366                     const TokenHeader *tokAlignmentEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6367                     while (tokAlignment < tokAlignmentEnd) {
6368                         if (false == tokAlignment->flags.flag4IsVariableLength) {
6369                             switch (tokAlignment->id) {
6370                             default:
6371                                 if (tokAlignment->flags.flag3IsMandatory) {
6372                                     return false;
6373                                 }
6374                                 break;
6375                             case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: {
6376                                 dst.Alignment.ArraySpacingSingleLod = readTokValue<decltype(dst.Alignment.ArraySpacingSingleLod)>(*tokAlignment);
6377                             } break;
6378                             case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: {
6379                                 dst.Alignment.BaseAlignment = readTokValue<decltype(dst.Alignment.BaseAlignment)>(*tokAlignment);
6380                             } break;
6381                             case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: {
6382                                 dst.Alignment.HAlign = readTokValue<decltype(dst.Alignment.HAlign)>(*tokAlignment);
6383                             } break;
6384                             case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: {
6385                                 dst.Alignment.VAlign = readTokValue<decltype(dst.Alignment.VAlign)>(*tokAlignment);
6386                             } break;
6387                             case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: {
6388                                 dst.Alignment.DAlign = readTokValue<decltype(dst.Alignment.DAlign)>(*tokAlignment);
6389                             } break;
6390                             case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: {
6391                                 dst.Alignment.MipTailStartLod = readTokValue<decltype(dst.Alignment.MipTailStartLod)>(*tokAlignment);
6392                             } break;
6393                             case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: {
6394                                 dst.Alignment.PackedMipStartLod = readTokValue<decltype(dst.Alignment.PackedMipStartLod)>(*tokAlignment);
6395                             } break;
6396                             case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: {
6397                                 dst.Alignment.PackedMipWidth = readTokValue<decltype(dst.Alignment.PackedMipWidth)>(*tokAlignment);
6398                             } break;
6399                             case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: {
6400                                 dst.Alignment.PackedMipHeight = readTokValue<decltype(dst.Alignment.PackedMipHeight)>(*tokAlignment);
6401                             } break;
6402                             case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: {
6403                                 dst.Alignment.QPitch = readTokValue<decltype(dst.Alignment.QPitch)>(*tokAlignment);
6404                             } break;
6405                             };
6406                             tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount;
6407                         } else {
6408                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAlignment);
6409                             if (tokAlignment->flags.flag3IsMandatory) {
6410                                 return false;
6411                             }
6412                             tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6413                         }
6414                     }
6415                     WCH_ASSERT(tokAlignment == tokAlignmentEnd);
6416                 } break;
6417                 case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: {
6418                     const TokenHeader *tokOffsetInfo = varLen->getValue<TokenHeader>();
6419                     const TokenHeader *tokOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6420                     while (tokOffsetInfo < tokOffsetInfoEnd) {
6421                         if (false == tokOffsetInfo->flags.flag4IsVariableLength) {
6422                             if (tokOffsetInfo->flags.flag3IsMandatory) {
6423                                 return false;
6424                             }
6425                             tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount;
6426                         } else {
6427                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOffsetInfo);
6428                             switch (tokOffsetInfo->id) {
6429                             default:
6430                                 if (tokOffsetInfo->flags.flag3IsMandatory) {
6431                                     return false;
6432                                 }
6433                                 break;
6434                             case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: {
6435                                 const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>();
6436                                 const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6437                                 while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) {
6438                                     if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) {
6439                                         switch (tokTexture3DOffsetInfo->id) {
6440                                         default:
6441                                             if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
6442                                                 return false;
6443                                             }
6444                                             break;
6445                                         case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: {
6446                                             dst.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo);
6447                                         } break;
6448                                         case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
6449                                             auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>();
6450                                             auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes();
6451                                             if (srcSize < sizeof(dst.OffsetInfo.Texture3DOffsetInfo.Offset)) {
6452                                                 return false;
6453                                             }
6454                                             WCH_SAFE_COPY(dst.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.OffsetInfo.Texture3DOffsetInfo.Offset));
6455                                         } break;
6456                                         };
6457                                         tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount;
6458                                     } else {
6459                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo);
6460                                         if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
6461                                             return false;
6462                                         }
6463                                         tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6464                                     }
6465                                 }
6466                                 WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd);
6467                             } break;
6468                             case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: {
6469                                 const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>();
6470                                 const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6471                                 while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) {
6472                                     if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) {
6473                                         switch (tokTexture2DOffsetInfo->id) {
6474                                         default:
6475                                             if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
6476                                                 return false;
6477                                             }
6478                                             break;
6479                                         case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: {
6480                                             dst.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo);
6481                                         } break;
6482                                         case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: {
6483                                             dst.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo);
6484                                         } break;
6485                                         case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
6486                                             auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>();
6487                                             auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes();
6488                                             if (srcSize < sizeof(dst.OffsetInfo.Texture2DOffsetInfo.Offset)) {
6489                                                 return false;
6490                                             }
6491                                             WCH_SAFE_COPY(dst.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.OffsetInfo.Texture2DOffsetInfo.Offset));
6492                                         } break;
6493                                         };
6494                                         tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount;
6495                                     } else {
6496                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo);
6497                                         if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
6498                                             return false;
6499                                         }
6500                                         tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6501                                     }
6502                                 }
6503                                 WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd);
6504                             } break;
6505                             case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: {
6506                                 const TokenHeader *tokPlane = varLen->getValue<TokenHeader>();
6507                                 const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6508                                 while (tokPlane < tokPlaneEnd) {
6509                                     if (false == tokPlane->flags.flag4IsVariableLength) {
6510                                         switch (tokPlane->id) {
6511                                         default:
6512                                             if (tokPlane->flags.flag3IsMandatory) {
6513                                                 return false;
6514                                             }
6515                                             break;
6516                                         case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: {
6517                                             dst.OffsetInfo.Plane.ArrayQPitch = readTokValue<decltype(dst.OffsetInfo.Plane.ArrayQPitch)>(*tokPlane);
6518                                         } break;
6519                                         case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: {
6520                                             auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
6521                                             auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
6522                                             if (srcSize < sizeof(dst.OffsetInfo.Plane.X)) {
6523                                                 return false;
6524                                             }
6525                                             WCH_SAFE_COPY(dst.OffsetInfo.Plane.X, sizeof(dst.OffsetInfo.Plane.X), srcData, sizeof(dst.OffsetInfo.Plane.X));
6526                                         } break;
6527                                         case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: {
6528                                             auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
6529                                             auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
6530                                             if (srcSize < sizeof(dst.OffsetInfo.Plane.Y)) {
6531                                                 return false;
6532                                             }
6533                                             WCH_SAFE_COPY(dst.OffsetInfo.Plane.Y, sizeof(dst.OffsetInfo.Plane.Y), srcData, sizeof(dst.OffsetInfo.Plane.Y));
6534                                         } break;
6535                                         case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: {
6536                                             dst.OffsetInfo.Plane.NoOfPlanes = readTokValue<decltype(dst.OffsetInfo.Plane.NoOfPlanes)>(*tokPlane);
6537                                         } break;
6538                                         case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: {
6539                                             dst.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.OffsetInfo.Plane.IsTileAlignedPlanes)>(*tokPlane);
6540                                         } break;
6541                                         };
6542                                         tokPlane = tokPlane + 1 + tokPlane->valueDwordCount;
6543                                     } else {
6544                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane);
6545                                         switch (tokPlane->id) {
6546                                         default:
6547                                             if (tokPlane->flags.flag3IsMandatory) {
6548                                                 return false;
6549                                             }
6550                                             break;
6551                                         case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: {
6552                                             const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>();
6553                                             const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6554                                             while (tokUnAligned < tokUnAlignedEnd) {
6555                                                 if (false == tokUnAligned->flags.flag4IsVariableLength) {
6556                                                     switch (tokUnAligned->id) {
6557                                                     default:
6558                                                         if (tokUnAligned->flags.flag3IsMandatory) {
6559                                                             return false;
6560                                                         }
6561                                                         break;
6562                                                     case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: {
6563                                                         auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>();
6564                                                         auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes();
6565                                                         if (srcSize < sizeof(dst.OffsetInfo.Plane.UnAligned.Height)) {
6566                                                             return false;
6567                                                         }
6568                                                         WCH_SAFE_COPY(dst.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.OffsetInfo.Plane.UnAligned.Height));
6569                                                     } break;
6570                                                     };
6571                                                     tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount;
6572                                                 } else {
6573                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned);
6574                                                     if (tokUnAligned->flags.flag3IsMandatory) {
6575                                                         return false;
6576                                                     }
6577                                                     tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6578                                                 }
6579                                             }
6580                                             WCH_ASSERT(tokUnAligned == tokUnAlignedEnd);
6581                                         } break;
6582                                         };
6583                                         tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6584                                     }
6585                                 }
6586                                 WCH_ASSERT(tokPlane == tokPlaneEnd);
6587                             } break;
6588                             };
6589                             tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6590                         }
6591                     }
6592                     WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd);
6593                 } break;
6594                 case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: {
6595                     const TokenHeader *tokS3d = varLen->getValue<TokenHeader>();
6596                     const TokenHeader *tokS3dEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6597                     while (tokS3d < tokS3dEnd) {
6598                         if (false == tokS3d->flags.flag4IsVariableLength) {
6599                             switch (tokS3d->id) {
6600                             default:
6601                                 if (tokS3d->flags.flag3IsMandatory) {
6602                                     return false;
6603                                 }
6604                                 break;
6605                             case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: {
6606                                 dst.S3d.DisplayModeHeight = readTokValue<decltype(dst.S3d.DisplayModeHeight)>(*tokS3d);
6607                             } break;
6608                             case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: {
6609                                 dst.S3d.NumBlankActiveLines = readTokValue<decltype(dst.S3d.NumBlankActiveLines)>(*tokS3d);
6610                             } break;
6611                             case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: {
6612                                 dst.S3d.RFrameOffset = readTokValue<decltype(dst.S3d.RFrameOffset)>(*tokS3d);
6613                             } break;
6614                             case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: {
6615                                 dst.S3d.BlankAreaOffset = readTokValue<decltype(dst.S3d.BlankAreaOffset)>(*tokS3d);
6616                             } break;
6617                             case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: {
6618                                 dst.S3d.TallBufferHeight = readTokValue<decltype(dst.S3d.TallBufferHeight)>(*tokS3d);
6619                             } break;
6620                             case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: {
6621                                 dst.S3d.TallBufferSize = readTokValue<decltype(dst.S3d.TallBufferSize)>(*tokS3d);
6622                             } break;
6623                             case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: {
6624                                 dst.S3d.IsRFrame = readTokValue<decltype(dst.S3d.IsRFrame)>(*tokS3d);
6625                             } break;
6626                             };
6627                             tokS3d = tokS3d + 1 + tokS3d->valueDwordCount;
6628                         } else {
6629                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokS3d);
6630                             if (tokS3d->flags.flag3IsMandatory) {
6631                                 return false;
6632                             }
6633                             tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6634                         }
6635                     }
6636                     WCH_ASSERT(tokS3d == tokS3dEnd);
6637                 } break;
6638                 case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: {
6639                     const TokenHeader *tokSegmentOverride = varLen->getValue<TokenHeader>();
6640                     const TokenHeader *tokSegmentOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6641                     while (tokSegmentOverride < tokSegmentOverrideEnd) {
6642                         if (false == tokSegmentOverride->flags.flag4IsVariableLength) {
6643                             switch (tokSegmentOverride->id) {
6644                             default:
6645                                 if (tokSegmentOverride->flags.flag3IsMandatory) {
6646                                     return false;
6647                                 }
6648                                 break;
6649                             case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: {
6650                                 dst.SegmentOverride.Seg1 = readTokValue<decltype(dst.SegmentOverride.Seg1)>(*tokSegmentOverride);
6651                             } break;
6652                             case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: {
6653                                 dst.SegmentOverride.Evict = readTokValue<decltype(dst.SegmentOverride.Evict)>(*tokSegmentOverride);
6654                             } break;
6655                             };
6656                             tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount;
6657                         } else {
6658                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSegmentOverride);
6659                             if (tokSegmentOverride->flags.flag3IsMandatory) {
6660                                 return false;
6661                             }
6662                             tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6663                         }
6664                     }
6665                     WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd);
6666                 } break;
6667                 case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: {
6668 #if _DEBUG || _RELEASE_INTERNAL
6669                     const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>();
6670                     const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6671                     while (tokPlatform < tokPlatformEnd) {
6672                         if (false == tokPlatform->flags.flag4IsVariableLength) {
6673                             switch (tokPlatform->id) {
6674                             default:
6675                                 if (tokPlatform->flags.flag3IsMandatory) {
6676                                     return false;
6677                                 }
6678                                 break;
6679                             case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
6680                                 dst.Platform.eProductFamily = readTokValue<decltype(dst.Platform.eProductFamily)>(*tokPlatform);
6681                             } break;
6682                             case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
6683                                 dst.Platform.ePCHProductFamily = readTokValue<decltype(dst.Platform.ePCHProductFamily)>(*tokPlatform);
6684                             } break;
6685                             case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
6686                                 dst.Platform.eDisplayCoreFamily = readTokValue<decltype(dst.Platform.eDisplayCoreFamily)>(*tokPlatform);
6687                             } break;
6688                             case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
6689                                 dst.Platform.eRenderCoreFamily = readTokValue<decltype(dst.Platform.eRenderCoreFamily)>(*tokPlatform);
6690                             } break;
6691                             case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
6692                                 dst.Platform.ePlatformType = readTokValue<decltype(dst.Platform.ePlatformType)>(*tokPlatform);
6693                             } break;
6694                             case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
6695                                 dst.Platform.usDeviceID = readTokValue<decltype(dst.Platform.usDeviceID)>(*tokPlatform);
6696                             } break;
6697                             case TOK_FBW_PLATFORM_STR__US_REV_ID: {
6698                                 dst.Platform.usRevId = readTokValue<decltype(dst.Platform.usRevId)>(*tokPlatform);
6699                             } break;
6700                             case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
6701                                 dst.Platform.usDeviceID_PCH = readTokValue<decltype(dst.Platform.usDeviceID_PCH)>(*tokPlatform);
6702                             } break;
6703                             case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
6704                                 dst.Platform.usRevId_PCH = readTokValue<decltype(dst.Platform.usRevId_PCH)>(*tokPlatform);
6705                             } break;
6706                             case TOK_FE_PLATFORM_STR__E_GTTYPE: {
6707                                 dst.Platform.eGTType = readTokValue<decltype(dst.Platform.eGTType)>(*tokPlatform);
6708                             } break;
6709                             };
6710                             tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount;
6711                         } else {
6712                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform);
6713                             if (tokPlatform->flags.flag3IsMandatory) {
6714                                 return false;
6715                             }
6716                             tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6717                         }
6718                     }
6719                     WCH_ASSERT(tokPlatform == tokPlatformEnd);
6720 #endif
6721                 } break;
6722                 case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: {
6723                     const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>();
6724                     const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6725                     while (tokExistingSysMem < tokExistingSysMemEnd) {
6726                         if (false == tokExistingSysMem->flags.flag4IsVariableLength) {
6727                             switch (tokExistingSysMem->id) {
6728                             default:
6729                                 if (tokExistingSysMem->flags.flag3IsMandatory) {
6730                                     return false;
6731                                 }
6732                                 break;
6733                             case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: {
6734                                 dst.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem);
6735                             } break;
6736                             case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: {
6737                                 dst.ExistingSysMem.IsPageAligned = readTokValue<decltype(dst.ExistingSysMem.IsPageAligned)>(*tokExistingSysMem);
6738                             } break;
6739                             };
6740                             tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount;
6741                         } else {
6742                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem);
6743                             if (tokExistingSysMem->flags.flag3IsMandatory) {
6744                                 return false;
6745                             }
6746                             tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6747                         }
6748                     }
6749                     WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd);
6750                 } break;
6751                 case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: {
6752 #if !(_DEBUG || _RELEASE_INTERNAL)
6753                     const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>();
6754                     const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6755                     while (tok__Platform < tok__PlatformEnd) {
6756                         if (false == tok__Platform->flags.flag4IsVariableLength) {
6757                             switch (tok__Platform->id) {
6758                             default:
6759                                 if (tok__Platform->flags.flag3IsMandatory) {
6760                                     return false;
6761                                 }
6762                                 break;
6763                             case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
6764                                 dst.__Platform.eProductFamily = readTokValue<decltype(dst.__Platform.eProductFamily)>(*tok__Platform);
6765                             } break;
6766                             case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
6767                                 dst.__Platform.ePCHProductFamily = readTokValue<decltype(dst.__Platform.ePCHProductFamily)>(*tok__Platform);
6768                             } break;
6769                             case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
6770                                 dst.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.__Platform.eDisplayCoreFamily)>(*tok__Platform);
6771                             } break;
6772                             case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
6773                                 dst.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.__Platform.eRenderCoreFamily)>(*tok__Platform);
6774                             } break;
6775                             case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
6776                                 dst.__Platform.ePlatformType = readTokValue<decltype(dst.__Platform.ePlatformType)>(*tok__Platform);
6777                             } break;
6778                             case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
6779                                 dst.__Platform.usDeviceID = readTokValue<decltype(dst.__Platform.usDeviceID)>(*tok__Platform);
6780                             } break;
6781                             case TOK_FBW_PLATFORM_STR__US_REV_ID: {
6782                                 dst.__Platform.usRevId = readTokValue<decltype(dst.__Platform.usRevId)>(*tok__Platform);
6783                             } break;
6784                             case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
6785                                 dst.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.__Platform.usDeviceID_PCH)>(*tok__Platform);
6786                             } break;
6787                             case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
6788                                 dst.__Platform.usRevId_PCH = readTokValue<decltype(dst.__Platform.usRevId_PCH)>(*tok__Platform);
6789                             } break;
6790                             case TOK_FE_PLATFORM_STR__E_GTTYPE: {
6791                                 dst.__Platform.eGTType = readTokValue<decltype(dst.__Platform.eGTType)>(*tok__Platform);
6792                             } break;
6793                             };
6794                             tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount;
6795                         } else {
6796                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform);
6797                             if (tok__Platform->flags.flag3IsMandatory) {
6798                                 return false;
6799                             }
6800                             tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6801                         }
6802                     }
6803                     WCH_ASSERT(tok__Platform == tok__PlatformEnd);
6804 #endif
6805                 } break;
6806                 };
6807                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6808             }
6809         }
6810         WCH_ASSERT(tok == srcTokensEnd);
6811         return true;
6812     }
6813 };
6814 
6815 template <>
6816 struct Demarshaller<TOK_S_GMM_EXISTING_SYS_MEM_REC> {
6817     template <typename GMM_EXISTING_SYS_MEM_RECT>
6818     static bool demarshall(GMM_EXISTING_SYS_MEM_RECT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
6819         const TokenHeader *tok = srcTokensBeg;
6820         while (tok < srcTokensEnd) {
6821             if (false == tok->flags.flag4IsVariableLength) {
6822                 switch (tok->id) {
6823                 default:
6824                     if (tok->flags.flag3IsMandatory) {
6825                         return false;
6826                     }
6827                     break;
6828                 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_EXISTING_SYS_MEM: {
6829                     dst.pExistingSysMem = readTokValue<decltype(dst.pExistingSysMem)>(*tok);
6830                 } break;
6831                 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_VIRT_ADDRESS: {
6832                     dst.pVirtAddress = readTokValue<decltype(dst.pVirtAddress)>(*tok);
6833                 } break;
6834                 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_GFX_ALIGNED_VIRT_ADDRESS: {
6835                     dst.pGfxAlignedVirtAddress = readTokValue<decltype(dst.pGfxAlignedVirtAddress)>(*tok);
6836                 } break;
6837                 case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__SIZE: {
6838                     dst.Size = readTokValue<decltype(dst.Size)>(*tok);
6839                 } break;
6840                 case TOK_FBC_GMM_EXISTING_SYS_MEM_REC__IS_GMM_ALLOCATED: {
6841                     dst.IsGmmAllocated = readTokValue<decltype(dst.IsGmmAllocated)>(*tok);
6842                 } break;
6843                 };
6844                 tok = tok + 1 + tok->valueDwordCount;
6845             } else {
6846                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
6847                 switch (tok->id) {
6848                 default:
6849                     if (tok->flags.flag3IsMandatory) {
6850                         return false;
6851                     }
6852                     break;
6853                 case TOK_S_GMM_EXISTING_SYS_MEM_REC:
6854                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
6855                         return false;
6856                     }
6857                     break;
6858                 };
6859                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
6860             }
6861         }
6862         WCH_ASSERT(tok == srcTokensEnd);
6863         return true;
6864     }
6865 };
6866 
6867 template <>
6868 struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_COMMON_STRUCT> {
6869     template <typename GmmResourceInfoCommonStructT>
6870     static bool demarshall(GmmResourceInfoCommonStructT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
6871         const TokenHeader *tok = srcTokensBeg;
6872         while (tok < srcTokensEnd) {
6873             if (false == tok->flags.flag4IsVariableLength) {
6874                 switch (tok->id) {
6875                 default:
6876                     if (tok->flags.flag3IsMandatory) {
6877                         return false;
6878                     }
6879                     break;
6880                 case TOK_FE_GMM_RESOURCE_INFO_COMMON_STRUCT__CLIENT_TYPE: {
6881                     dst.ClientType = readTokValue<decltype(dst.ClientType)>(*tok);
6882                 } break;
6883                 case TOK_FBD_GMM_RESOURCE_INFO_COMMON_STRUCT__ROTATE_INFO: {
6884                     dst.RotateInfo = readTokValue<decltype(dst.RotateInfo)>(*tok);
6885                 } break;
6886                 case TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__SVM_ADDRESS: {
6887                     dst.SvmAddress = readTokValue<decltype(dst.SvmAddress)>(*tok);
6888                 } break;
6889                 case TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__P_PRIVATE_DATA: {
6890                     dst.pPrivateData = readTokValue<decltype(dst.pPrivateData)>(*tok);
6891                 } break;
6892                 };
6893                 tok = tok + 1 + tok->valueDwordCount;
6894             } else {
6895                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
6896                 switch (tok->id) {
6897                 default:
6898                     if (tok->flags.flag3IsMandatory) {
6899                         return false;
6900                     }
6901                     break;
6902                 case TOK_S_GMM_RESOURCE_INFO_COMMON_STRUCT:
6903                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
6904                         return false;
6905                     }
6906                     break;
6907                 case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__SURF: {
6908                     const TokenHeader *tokSurf = varLen->getValue<TokenHeader>();
6909                     const TokenHeader *tokSurfEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
6910                     while (tokSurf < tokSurfEnd) {
6911                         if (false == tokSurf->flags.flag4IsVariableLength) {
6912                             switch (tokSurf->id) {
6913                             default:
6914                                 if (tokSurf->flags.flag3IsMandatory) {
6915                                     return false;
6916                                 }
6917                                 break;
6918                             case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: {
6919                                 dst.Surf.Type = readTokValue<decltype(dst.Surf.Type)>(*tokSurf);
6920                             } break;
6921                             case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: {
6922                                 dst.Surf.Format = readTokValue<decltype(dst.Surf.Format)>(*tokSurf);
6923                             } break;
6924                             case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: {
6925                                 dst.Surf.BitsPerPixel = readTokValue<decltype(dst.Surf.BitsPerPixel)>(*tokSurf);
6926                             } break;
6927                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: {
6928                                 dst.Surf.BaseWidth = readTokValue<decltype(dst.Surf.BaseWidth)>(*tokSurf);
6929                             } break;
6930                             case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: {
6931                                 dst.Surf.BaseHeight = readTokValue<decltype(dst.Surf.BaseHeight)>(*tokSurf);
6932                             } break;
6933                             case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: {
6934                                 dst.Surf.Depth = readTokValue<decltype(dst.Surf.Depth)>(*tokSurf);
6935                             } break;
6936                             case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: {
6937                                 dst.Surf.MaxLod = readTokValue<decltype(dst.Surf.MaxLod)>(*tokSurf);
6938                             } break;
6939                             case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: {
6940                                 dst.Surf.ArraySize = readTokValue<decltype(dst.Surf.ArraySize)>(*tokSurf);
6941                             } break;
6942                             case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: {
6943                                 dst.Surf.CpTag = readTokValue<decltype(dst.Surf.CpTag)>(*tokSurf);
6944                             } break;
6945                             case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: {
6946                                 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValue<char>();
6947                                 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValueSizeInBytes();
6948                                 if (srcSize < sizeof(dst.Surf.MmcMode)) {
6949                                     return false;
6950                                 }
6951                                 WCH_SAFE_COPY(dst.Surf.MmcMode, sizeof(dst.Surf.MmcMode), srcData, sizeof(dst.Surf.MmcMode));
6952                             } break;
6953                             case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: {
6954                                 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValue<char>();
6955                                 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValueSizeInBytes();
6956                                 if (srcSize < sizeof(dst.Surf.MmcHint)) {
6957                                     return false;
6958                                 }
6959                                 WCH_SAFE_COPY(dst.Surf.MmcHint, sizeof(dst.Surf.MmcHint), srcData, sizeof(dst.Surf.MmcHint));
6960                             } break;
6961                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: {
6962                                 dst.Surf.Pitch = readTokValue<decltype(dst.Surf.Pitch)>(*tokSurf);
6963                             } break;
6964                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: {
6965                                 dst.Surf.OverridePitch = readTokValue<decltype(dst.Surf.OverridePitch)>(*tokSurf);
6966                             } break;
6967                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: {
6968                                 dst.Surf.Size = readTokValue<decltype(dst.Surf.Size)>(*tokSurf);
6969                             } break;
6970                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: {
6971                                 dst.Surf.CCSize = readTokValue<decltype(dst.Surf.CCSize)>(*tokSurf);
6972                             } break;
6973                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: {
6974                                 dst.Surf.UnpaddedSize = readTokValue<decltype(dst.Surf.UnpaddedSize)>(*tokSurf);
6975                             } break;
6976                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: {
6977                                 dst.Surf.SizeReportToOS = readTokValue<decltype(dst.Surf.SizeReportToOS)>(*tokSurf);
6978                             } break;
6979                             case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: {
6980                                 dst.Surf.TileMode = readTokValue<decltype(dst.Surf.TileMode)>(*tokSurf);
6981                             } break;
6982                             case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: {
6983                                 dst.Surf.CCSModeAlign = readTokValue<decltype(dst.Surf.CCSModeAlign)>(*tokSurf);
6984                             } break;
6985                             case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: {
6986                                 dst.Surf.LegacyFlags = readTokValue<decltype(dst.Surf.LegacyFlags)>(*tokSurf);
6987                             } break;
6988                             case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: {
6989                                 dst.Surf.MaximumRenamingListLength = readTokValue<decltype(dst.Surf.MaximumRenamingListLength)>(*tokSurf);
6990                             } break;
6991                             };
6992                             tokSurf = tokSurf + 1 + tokSurf->valueDwordCount;
6993                         } else {
6994                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSurf);
6995                             switch (tokSurf->id) {
6996                             default:
6997                                 if (tokSurf->flags.flag3IsMandatory) {
6998                                     return false;
6999                                 }
7000                                 break;
7001                             case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: {
7002                                 const TokenHeader *tokFlags = varLen->getValue<TokenHeader>();
7003                                 const TokenHeader *tokFlagsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7004                                 while (tokFlags < tokFlagsEnd) {
7005                                     if (false == tokFlags->flags.flag4IsVariableLength) {
7006                                         if (tokFlags->flags.flag3IsMandatory) {
7007                                             return false;
7008                                         }
7009                                         tokFlags = tokFlags + 1 + tokFlags->valueDwordCount;
7010                                     } else {
7011                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokFlags);
7012                                         switch (tokFlags->id) {
7013                                         default:
7014                                             if (tokFlags->flags.flag3IsMandatory) {
7015                                                 return false;
7016                                             }
7017                                             break;
7018                                         case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: {
7019                                             const TokenHeader *tokGpu = varLen->getValue<TokenHeader>();
7020                                             const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7021                                             while (tokGpu < tokGpuEnd) {
7022                                                 if (false == tokGpu->flags.flag4IsVariableLength) {
7023                                                     switch (tokGpu->id) {
7024                                                     default:
7025                                                         if (tokGpu->flags.flag3IsMandatory) {
7026                                                             return false;
7027                                                         }
7028                                                         break;
7029                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: {
7030                                                         dst.Surf.Flags.Gpu.CameraCapture = readTokValue<decltype(dst.Surf.Flags.Gpu.CameraCapture)>(*tokGpu);
7031                                                     } break;
7032                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: {
7033                                                         dst.Surf.Flags.Gpu.CCS = readTokValue<decltype(dst.Surf.Flags.Gpu.CCS)>(*tokGpu);
7034                                                     } break;
7035                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: {
7036                                                         dst.Surf.Flags.Gpu.ColorDiscard = readTokValue<decltype(dst.Surf.Flags.Gpu.ColorDiscard)>(*tokGpu);
7037                                                     } break;
7038                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: {
7039                                                         dst.Surf.Flags.Gpu.ColorSeparation = readTokValue<decltype(dst.Surf.Flags.Gpu.ColorSeparation)>(*tokGpu);
7040                                                     } break;
7041                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: {
7042                                                         dst.Surf.Flags.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.Surf.Flags.Gpu.ColorSeparationRGBX)>(*tokGpu);
7043                                                     } break;
7044                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: {
7045                                                         dst.Surf.Flags.Gpu.Constant = readTokValue<decltype(dst.Surf.Flags.Gpu.Constant)>(*tokGpu);
7046                                                     } break;
7047                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: {
7048                                                         dst.Surf.Flags.Gpu.Depth = readTokValue<decltype(dst.Surf.Flags.Gpu.Depth)>(*tokGpu);
7049                                                     } break;
7050                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: {
7051                                                         dst.Surf.Flags.Gpu.FlipChain = readTokValue<decltype(dst.Surf.Flags.Gpu.FlipChain)>(*tokGpu);
7052                                                     } break;
7053                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: {
7054                                                         dst.Surf.Flags.Gpu.FlipChainPreferred = readTokValue<decltype(dst.Surf.Flags.Gpu.FlipChainPreferred)>(*tokGpu);
7055                                                     } break;
7056                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: {
7057                                                         dst.Surf.Flags.Gpu.HistoryBuffer = readTokValue<decltype(dst.Surf.Flags.Gpu.HistoryBuffer)>(*tokGpu);
7058                                                     } break;
7059                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: {
7060                                                         dst.Surf.Flags.Gpu.HiZ = readTokValue<decltype(dst.Surf.Flags.Gpu.HiZ)>(*tokGpu);
7061                                                     } break;
7062                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: {
7063                                                         dst.Surf.Flags.Gpu.Index = readTokValue<decltype(dst.Surf.Flags.Gpu.Index)>(*tokGpu);
7064                                                     } break;
7065                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: {
7066                                                         dst.Surf.Flags.Gpu.IndirectClearColor = readTokValue<decltype(dst.Surf.Flags.Gpu.IndirectClearColor)>(*tokGpu);
7067                                                     } break;
7068                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: {
7069                                                         dst.Surf.Flags.Gpu.InstructionFlat = readTokValue<decltype(dst.Surf.Flags.Gpu.InstructionFlat)>(*tokGpu);
7070                                                     } break;
7071                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: {
7072                                                         dst.Surf.Flags.Gpu.InterlacedScan = readTokValue<decltype(dst.Surf.Flags.Gpu.InterlacedScan)>(*tokGpu);
7073                                                     } break;
7074                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: {
7075                                                         dst.Surf.Flags.Gpu.MCS = readTokValue<decltype(dst.Surf.Flags.Gpu.MCS)>(*tokGpu);
7076                                                     } break;
7077                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: {
7078                                                         dst.Surf.Flags.Gpu.MMC = readTokValue<decltype(dst.Surf.Flags.Gpu.MMC)>(*tokGpu);
7079                                                     } break;
7080                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: {
7081                                                         dst.Surf.Flags.Gpu.MotionComp = readTokValue<decltype(dst.Surf.Flags.Gpu.MotionComp)>(*tokGpu);
7082                                                     } break;
7083                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: {
7084                                                         dst.Surf.Flags.Gpu.NoRestriction = readTokValue<decltype(dst.Surf.Flags.Gpu.NoRestriction)>(*tokGpu);
7085                                                     } break;
7086                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: {
7087                                                         dst.Surf.Flags.Gpu.Overlay = readTokValue<decltype(dst.Surf.Flags.Gpu.Overlay)>(*tokGpu);
7088                                                     } break;
7089                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: {
7090                                                         dst.Surf.Flags.Gpu.Presentable = readTokValue<decltype(dst.Surf.Flags.Gpu.Presentable)>(*tokGpu);
7091                                                     } break;
7092                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: {
7093                                                         dst.Surf.Flags.Gpu.ProceduralTexture = readTokValue<decltype(dst.Surf.Flags.Gpu.ProceduralTexture)>(*tokGpu);
7094                                                     } break;
7095                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: {
7096                                                         dst.Surf.Flags.Gpu.Query = readTokValue<decltype(dst.Surf.Flags.Gpu.Query)>(*tokGpu);
7097                                                     } break;
7098                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: {
7099                                                         dst.Surf.Flags.Gpu.RenderTarget = readTokValue<decltype(dst.Surf.Flags.Gpu.RenderTarget)>(*tokGpu);
7100                                                     } break;
7101                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: {
7102                                                         dst.Surf.Flags.Gpu.S3d = readTokValue<decltype(dst.Surf.Flags.Gpu.S3d)>(*tokGpu);
7103                                                     } break;
7104                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: {
7105                                                         dst.Surf.Flags.Gpu.S3dDx = readTokValue<decltype(dst.Surf.Flags.Gpu.S3dDx)>(*tokGpu);
7106                                                     } break;
7107                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: {
7108                                                         dst.Surf.Flags.Gpu.__S3dNonPacked = readTokValue<decltype(dst.Surf.Flags.Gpu.__S3dNonPacked)>(*tokGpu);
7109                                                     } break;
7110                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: {
7111                                                         dst.Surf.Flags.Gpu.__S3dWidi = readTokValue<decltype(dst.Surf.Flags.Gpu.__S3dWidi)>(*tokGpu);
7112                                                     } break;
7113                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: {
7114                                                         dst.Surf.Flags.Gpu.ScratchFlat = readTokValue<decltype(dst.Surf.Flags.Gpu.ScratchFlat)>(*tokGpu);
7115                                                     } break;
7116                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: {
7117                                                         dst.Surf.Flags.Gpu.SeparateStencil = readTokValue<decltype(dst.Surf.Flags.Gpu.SeparateStencil)>(*tokGpu);
7118                                                     } break;
7119                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: {
7120                                                         dst.Surf.Flags.Gpu.State = readTokValue<decltype(dst.Surf.Flags.Gpu.State)>(*tokGpu);
7121                                                     } break;
7122                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: {
7123                                                         dst.Surf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.Surf.Flags.Gpu.StateDx9ConstantBuffer)>(*tokGpu);
7124                                                     } break;
7125                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: {
7126                                                         dst.Surf.Flags.Gpu.Stream = readTokValue<decltype(dst.Surf.Flags.Gpu.Stream)>(*tokGpu);
7127                                                     } break;
7128                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: {
7129                                                         dst.Surf.Flags.Gpu.TextApi = readTokValue<decltype(dst.Surf.Flags.Gpu.TextApi)>(*tokGpu);
7130                                                     } break;
7131                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: {
7132                                                         dst.Surf.Flags.Gpu.Texture = readTokValue<decltype(dst.Surf.Flags.Gpu.Texture)>(*tokGpu);
7133                                                     } break;
7134                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: {
7135                                                         dst.Surf.Flags.Gpu.TiledResource = readTokValue<decltype(dst.Surf.Flags.Gpu.TiledResource)>(*tokGpu);
7136                                                     } break;
7137                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: {
7138                                                         dst.Surf.Flags.Gpu.TilePool = readTokValue<decltype(dst.Surf.Flags.Gpu.TilePool)>(*tokGpu);
7139                                                     } break;
7140                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: {
7141                                                         dst.Surf.Flags.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.Surf.Flags.Gpu.UnifiedAuxSurface)>(*tokGpu);
7142                                                     } break;
7143                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: {
7144                                                         dst.Surf.Flags.Gpu.Vertex = readTokValue<decltype(dst.Surf.Flags.Gpu.Vertex)>(*tokGpu);
7145                                                     } break;
7146                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: {
7147                                                         dst.Surf.Flags.Gpu.Video = readTokValue<decltype(dst.Surf.Flags.Gpu.Video)>(*tokGpu);
7148                                                     } break;
7149                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: {
7150                                                         dst.Surf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.Surf.Flags.Gpu.__NonMsaaTileXCcs)>(*tokGpu);
7151                                                     } break;
7152                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: {
7153                                                         dst.Surf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.Surf.Flags.Gpu.__NonMsaaTileYCcs)>(*tokGpu);
7154                                                     } break;
7155                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: {
7156                                                         dst.Surf.Flags.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.Surf.Flags.Gpu.__MsaaTileMcs)>(*tokGpu);
7157                                                     } break;
7158                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: {
7159                                                         dst.Surf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.Surf.Flags.Gpu.__NonMsaaLinearCCS)>(*tokGpu);
7160                                                     } break;
7161                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: {
7162                                                         dst.Surf.Flags.Gpu.__Remaining = readTokValue<decltype(dst.Surf.Flags.Gpu.__Remaining)>(*tokGpu);
7163                                                     } break;
7164                                                     };
7165                                                     tokGpu = tokGpu + 1 + tokGpu->valueDwordCount;
7166                                                 } else {
7167                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu);
7168                                                     if (tokGpu->flags.flag3IsMandatory) {
7169                                                         return false;
7170                                                     }
7171                                                     tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7172                                                 }
7173                                             }
7174                                             WCH_ASSERT(tokGpu == tokGpuEnd);
7175                                         } break;
7176                                         case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: {
7177                                             const TokenHeader *tokInfo = varLen->getValue<TokenHeader>();
7178                                             const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7179                                             while (tokInfo < tokInfoEnd) {
7180                                                 if (false == tokInfo->flags.flag4IsVariableLength) {
7181                                                     switch (tokInfo->id) {
7182                                                     default:
7183                                                         if (tokInfo->flags.flag3IsMandatory) {
7184                                                             return false;
7185                                                         }
7186                                                         break;
7187                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: {
7188                                                         dst.Surf.Flags.Info.AllowVirtualPadding = readTokValue<decltype(dst.Surf.Flags.Info.AllowVirtualPadding)>(*tokInfo);
7189                                                     } break;
7190                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: {
7191                                                         dst.Surf.Flags.Info.BigPage = readTokValue<decltype(dst.Surf.Flags.Info.BigPage)>(*tokInfo);
7192                                                     } break;
7193                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: {
7194                                                         dst.Surf.Flags.Info.Cacheable = readTokValue<decltype(dst.Surf.Flags.Info.Cacheable)>(*tokInfo);
7195                                                     } break;
7196                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: {
7197                                                         dst.Surf.Flags.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.Surf.Flags.Info.ContigPhysMemoryForiDART)>(*tokInfo);
7198                                                     } break;
7199                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: {
7200                                                         dst.Surf.Flags.Info.CornerTexelMode = readTokValue<decltype(dst.Surf.Flags.Info.CornerTexelMode)>(*tokInfo);
7201                                                     } break;
7202                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: {
7203                                                         dst.Surf.Flags.Info.ExistingSysMem = readTokValue<decltype(dst.Surf.Flags.Info.ExistingSysMem)>(*tokInfo);
7204                                                     } break;
7205                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: {
7206                                                         dst.Surf.Flags.Info.ForceResidency = readTokValue<decltype(dst.Surf.Flags.Info.ForceResidency)>(*tokInfo);
7207                                                     } break;
7208                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: {
7209                                                         dst.Surf.Flags.Info.Gfdt = readTokValue<decltype(dst.Surf.Flags.Info.Gfdt)>(*tokInfo);
7210                                                     } break;
7211                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: {
7212                                                         dst.Surf.Flags.Info.GttMapType = readTokValue<decltype(dst.Surf.Flags.Info.GttMapType)>(*tokInfo);
7213                                                     } break;
7214                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: {
7215                                                         dst.Surf.Flags.Info.HardwareProtected = readTokValue<decltype(dst.Surf.Flags.Info.HardwareProtected)>(*tokInfo);
7216                                                     } break;
7217                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: {
7218                                                         dst.Surf.Flags.Info.KernelModeMapped = readTokValue<decltype(dst.Surf.Flags.Info.KernelModeMapped)>(*tokInfo);
7219                                                     } break;
7220                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: {
7221                                                         dst.Surf.Flags.Info.LayoutBelow = readTokValue<decltype(dst.Surf.Flags.Info.LayoutBelow)>(*tokInfo);
7222                                                     } break;
7223                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: {
7224                                                         dst.Surf.Flags.Info.LayoutMono = readTokValue<decltype(dst.Surf.Flags.Info.LayoutMono)>(*tokInfo);
7225                                                     } break;
7226                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: {
7227                                                         dst.Surf.Flags.Info.LayoutRight = readTokValue<decltype(dst.Surf.Flags.Info.LayoutRight)>(*tokInfo);
7228                                                     } break;
7229                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: {
7230                                                         dst.Surf.Flags.Info.LocalOnly = readTokValue<decltype(dst.Surf.Flags.Info.LocalOnly)>(*tokInfo);
7231                                                     } break;
7232                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: {
7233                                                         dst.Surf.Flags.Info.Linear = readTokValue<decltype(dst.Surf.Flags.Info.Linear)>(*tokInfo);
7234                                                     } break;
7235                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: {
7236                                                         dst.Surf.Flags.Info.MediaCompressed = readTokValue<decltype(dst.Surf.Flags.Info.MediaCompressed)>(*tokInfo);
7237                                                     } break;
7238                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: {
7239                                                         dst.Surf.Flags.Info.NoOptimizationPadding = readTokValue<decltype(dst.Surf.Flags.Info.NoOptimizationPadding)>(*tokInfo);
7240                                                     } break;
7241                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: {
7242                                                         dst.Surf.Flags.Info.NoPhysMemory = readTokValue<decltype(dst.Surf.Flags.Info.NoPhysMemory)>(*tokInfo);
7243                                                     } break;
7244                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: {
7245                                                         dst.Surf.Flags.Info.NotLockable = readTokValue<decltype(dst.Surf.Flags.Info.NotLockable)>(*tokInfo);
7246                                                     } break;
7247                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: {
7248                                                         dst.Surf.Flags.Info.NonLocalOnly = readTokValue<decltype(dst.Surf.Flags.Info.NonLocalOnly)>(*tokInfo);
7249                                                     } break;
7250                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: {
7251                                                         dst.Surf.Flags.Info.StdSwizzle = readTokValue<decltype(dst.Surf.Flags.Info.StdSwizzle)>(*tokInfo);
7252                                                     } break;
7253                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: {
7254                                                         dst.Surf.Flags.Info.PseudoStdSwizzle = readTokValue<decltype(dst.Surf.Flags.Info.PseudoStdSwizzle)>(*tokInfo);
7255                                                     } break;
7256                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: {
7257                                                         dst.Surf.Flags.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.Surf.Flags.Info.Undefined64KBSwizzle)>(*tokInfo);
7258                                                     } break;
7259                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: {
7260                                                         dst.Surf.Flags.Info.RedecribedPlanes = readTokValue<decltype(dst.Surf.Flags.Info.RedecribedPlanes)>(*tokInfo);
7261                                                     } break;
7262                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: {
7263                                                         dst.Surf.Flags.Info.RenderCompressed = readTokValue<decltype(dst.Surf.Flags.Info.RenderCompressed)>(*tokInfo);
7264                                                     } break;
7265                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: {
7266                                                         dst.Surf.Flags.Info.Rotated = readTokValue<decltype(dst.Surf.Flags.Info.Rotated)>(*tokInfo);
7267                                                     } break;
7268                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: {
7269                                                         dst.Surf.Flags.Info.Shared = readTokValue<decltype(dst.Surf.Flags.Info.Shared)>(*tokInfo);
7270                                                     } break;
7271                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: {
7272                                                         dst.Surf.Flags.Info.SoftwareProtected = readTokValue<decltype(dst.Surf.Flags.Info.SoftwareProtected)>(*tokInfo);
7273                                                     } break;
7274                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: {
7275                                                         dst.Surf.Flags.Info.SVM = readTokValue<decltype(dst.Surf.Flags.Info.SVM)>(*tokInfo);
7276                                                     } break;
7277                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: {
7278                                                         dst.Surf.Flags.Info.Tile4 = readTokValue<decltype(dst.Surf.Flags.Info.Tile4)>(*tokInfo);
7279                                                     } break;
7280                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: {
7281                                                         dst.Surf.Flags.Info.Tile64 = readTokValue<decltype(dst.Surf.Flags.Info.Tile64)>(*tokInfo);
7282                                                     } break;
7283                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: {
7284                                                         dst.Surf.Flags.Info.TiledW = readTokValue<decltype(dst.Surf.Flags.Info.TiledW)>(*tokInfo);
7285                                                     } break;
7286                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: {
7287                                                         dst.Surf.Flags.Info.TiledX = readTokValue<decltype(dst.Surf.Flags.Info.TiledX)>(*tokInfo);
7288                                                     } break;
7289                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: {
7290                                                         dst.Surf.Flags.Info.TiledY = readTokValue<decltype(dst.Surf.Flags.Info.TiledY)>(*tokInfo);
7291                                                     } break;
7292                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: {
7293                                                         dst.Surf.Flags.Info.TiledYf = readTokValue<decltype(dst.Surf.Flags.Info.TiledYf)>(*tokInfo);
7294                                                     } break;
7295                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: {
7296                                                         dst.Surf.Flags.Info.TiledYs = readTokValue<decltype(dst.Surf.Flags.Info.TiledYs)>(*tokInfo);
7297                                                     } break;
7298                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: {
7299                                                         dst.Surf.Flags.Info.WddmProtected = readTokValue<decltype(dst.Surf.Flags.Info.WddmProtected)>(*tokInfo);
7300                                                     } break;
7301                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: {
7302                                                         dst.Surf.Flags.Info.XAdapter = readTokValue<decltype(dst.Surf.Flags.Info.XAdapter)>(*tokInfo);
7303                                                     } break;
7304                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: {
7305                                                         dst.Surf.Flags.Info.__PreallocatedResInfo = readTokValue<decltype(dst.Surf.Flags.Info.__PreallocatedResInfo)>(*tokInfo);
7306                                                     } break;
7307                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: {
7308                                                         dst.Surf.Flags.Info.__PreWddm2SVM = readTokValue<decltype(dst.Surf.Flags.Info.__PreWddm2SVM)>(*tokInfo);
7309                                                     } break;
7310                                                     };
7311                                                     tokInfo = tokInfo + 1 + tokInfo->valueDwordCount;
7312                                                 } else {
7313                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo);
7314                                                     if (tokInfo->flags.flag3IsMandatory) {
7315                                                         return false;
7316                                                     }
7317                                                     tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7318                                                 }
7319                                             }
7320                                             WCH_ASSERT(tokInfo == tokInfoEnd);
7321                                         } break;
7322                                         case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: {
7323                                             const TokenHeader *tokWa = varLen->getValue<TokenHeader>();
7324                                             const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7325                                             while (tokWa < tokWaEnd) {
7326                                                 if (false == tokWa->flags.flag4IsVariableLength) {
7327                                                     switch (tokWa->id) {
7328                                                     default:
7329                                                         if (tokWa->flags.flag3IsMandatory) {
7330                                                             return false;
7331                                                         }
7332                                                         break;
7333                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: {
7334                                                         dst.Surf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.Surf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa);
7335                                                     } break;
7336                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: {
7337                                                         dst.Surf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.Surf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa);
7338                                                     } break;
7339                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: {
7340                                                         dst.Surf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.Surf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa);
7341                                                     } break;
7342                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: {
7343                                                         dst.Surf.Flags.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.Surf.Flags.Wa.NoBufferSamplerPadding)>(*tokWa);
7344                                                     } break;
7345                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: {
7346                                                         dst.Surf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.Surf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa);
7347                                                     } break;
7348                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: {
7349                                                         dst.Surf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.Surf.Flags.Wa.CHVAstcSkipVirtualMips)>(*tokWa);
7350                                                     } break;
7351                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: {
7352                                                         dst.Surf.Flags.Wa.DisablePackedMipTail = readTokValue<decltype(dst.Surf.Flags.Wa.DisablePackedMipTail)>(*tokWa);
7353                                                     } break;
7354                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: {
7355                                                         dst.Surf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.Surf.Flags.Wa.__ForceOtherHVALIGN4)>(*tokWa);
7356                                                     } break;
7357                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: {
7358                                                         dst.Surf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.Surf.Flags.Wa.DisableDisplayCcsClearColor)>(*tokWa);
7359                                                     } break;
7360                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: {
7361                                                         dst.Surf.Flags.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.Surf.Flags.Wa.DisableDisplayCcsCompression)>(*tokWa);
7362                                                     } break;
7363                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
7364                                                         dst.Surf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.Surf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa);
7365                                                     } break;
7366                                                     };
7367                                                     tokWa = tokWa + 1 + tokWa->valueDwordCount;
7368                                                 } else {
7369                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa);
7370                                                     if (tokWa->flags.flag3IsMandatory) {
7371                                                         return false;
7372                                                     }
7373                                                     tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7374                                                 }
7375                                             }
7376                                             WCH_ASSERT(tokWa == tokWaEnd);
7377                                         } break;
7378                                         };
7379                                         tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7380                                     }
7381                                 }
7382                                 WCH_ASSERT(tokFlags == tokFlagsEnd);
7383                             } break;
7384                             case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: {
7385                                 const TokenHeader *tokCachePolicy = varLen->getValue<TokenHeader>();
7386                                 const TokenHeader *tokCachePolicyEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7387                                 while (tokCachePolicy < tokCachePolicyEnd) {
7388                                     if (false == tokCachePolicy->flags.flag4IsVariableLength) {
7389                                         switch (tokCachePolicy->id) {
7390                                         default:
7391                                             if (tokCachePolicy->flags.flag3IsMandatory) {
7392                                                 return false;
7393                                             }
7394                                             break;
7395                                         case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: {
7396                                             dst.Surf.CachePolicy.Usage = readTokValue<decltype(dst.Surf.CachePolicy.Usage)>(*tokCachePolicy);
7397                                         } break;
7398                                         };
7399                                         tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount;
7400                                     } else {
7401                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCachePolicy);
7402                                         if (tokCachePolicy->flags.flag3IsMandatory) {
7403                                             return false;
7404                                         }
7405                                         tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7406                                     }
7407                                 }
7408                                 WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd);
7409                             } break;
7410                             case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: {
7411                                 const TokenHeader *tokMSAA = varLen->getValue<TokenHeader>();
7412                                 const TokenHeader *tokMSAAEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7413                                 while (tokMSAA < tokMSAAEnd) {
7414                                     if (false == tokMSAA->flags.flag4IsVariableLength) {
7415                                         switch (tokMSAA->id) {
7416                                         default:
7417                                             if (tokMSAA->flags.flag3IsMandatory) {
7418                                                 return false;
7419                                             }
7420                                             break;
7421                                         case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: {
7422                                             dst.Surf.MSAA.SamplePattern = readTokValue<decltype(dst.Surf.MSAA.SamplePattern)>(*tokMSAA);
7423                                         } break;
7424                                         case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: {
7425                                             dst.Surf.MSAA.NumSamples = readTokValue<decltype(dst.Surf.MSAA.NumSamples)>(*tokMSAA);
7426                                         } break;
7427                                         };
7428                                         tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount;
7429                                     } else {
7430                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMSAA);
7431                                         if (tokMSAA->flags.flag3IsMandatory) {
7432                                             return false;
7433                                         }
7434                                         tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7435                                     }
7436                                 }
7437                                 WCH_ASSERT(tokMSAA == tokMSAAEnd);
7438                             } break;
7439                             case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: {
7440                                 const TokenHeader *tokAlignment = varLen->getValue<TokenHeader>();
7441                                 const TokenHeader *tokAlignmentEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7442                                 while (tokAlignment < tokAlignmentEnd) {
7443                                     if (false == tokAlignment->flags.flag4IsVariableLength) {
7444                                         switch (tokAlignment->id) {
7445                                         default:
7446                                             if (tokAlignment->flags.flag3IsMandatory) {
7447                                                 return false;
7448                                             }
7449                                             break;
7450                                         case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: {
7451                                             dst.Surf.Alignment.ArraySpacingSingleLod = readTokValue<decltype(dst.Surf.Alignment.ArraySpacingSingleLod)>(*tokAlignment);
7452                                         } break;
7453                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: {
7454                                             dst.Surf.Alignment.BaseAlignment = readTokValue<decltype(dst.Surf.Alignment.BaseAlignment)>(*tokAlignment);
7455                                         } break;
7456                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: {
7457                                             dst.Surf.Alignment.HAlign = readTokValue<decltype(dst.Surf.Alignment.HAlign)>(*tokAlignment);
7458                                         } break;
7459                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: {
7460                                             dst.Surf.Alignment.VAlign = readTokValue<decltype(dst.Surf.Alignment.VAlign)>(*tokAlignment);
7461                                         } break;
7462                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: {
7463                                             dst.Surf.Alignment.DAlign = readTokValue<decltype(dst.Surf.Alignment.DAlign)>(*tokAlignment);
7464                                         } break;
7465                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: {
7466                                             dst.Surf.Alignment.MipTailStartLod = readTokValue<decltype(dst.Surf.Alignment.MipTailStartLod)>(*tokAlignment);
7467                                         } break;
7468                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: {
7469                                             dst.Surf.Alignment.PackedMipStartLod = readTokValue<decltype(dst.Surf.Alignment.PackedMipStartLod)>(*tokAlignment);
7470                                         } break;
7471                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: {
7472                                             dst.Surf.Alignment.PackedMipWidth = readTokValue<decltype(dst.Surf.Alignment.PackedMipWidth)>(*tokAlignment);
7473                                         } break;
7474                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: {
7475                                             dst.Surf.Alignment.PackedMipHeight = readTokValue<decltype(dst.Surf.Alignment.PackedMipHeight)>(*tokAlignment);
7476                                         } break;
7477                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: {
7478                                             dst.Surf.Alignment.QPitch = readTokValue<decltype(dst.Surf.Alignment.QPitch)>(*tokAlignment);
7479                                         } break;
7480                                         };
7481                                         tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount;
7482                                     } else {
7483                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAlignment);
7484                                         if (tokAlignment->flags.flag3IsMandatory) {
7485                                             return false;
7486                                         }
7487                                         tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7488                                     }
7489                                 }
7490                                 WCH_ASSERT(tokAlignment == tokAlignmentEnd);
7491                             } break;
7492                             case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: {
7493                                 const TokenHeader *tokOffsetInfo = varLen->getValue<TokenHeader>();
7494                                 const TokenHeader *tokOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7495                                 while (tokOffsetInfo < tokOffsetInfoEnd) {
7496                                     if (false == tokOffsetInfo->flags.flag4IsVariableLength) {
7497                                         if (tokOffsetInfo->flags.flag3IsMandatory) {
7498                                             return false;
7499                                         }
7500                                         tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount;
7501                                     } else {
7502                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOffsetInfo);
7503                                         switch (tokOffsetInfo->id) {
7504                                         default:
7505                                             if (tokOffsetInfo->flags.flag3IsMandatory) {
7506                                                 return false;
7507                                             }
7508                                             break;
7509                                         case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: {
7510                                             const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>();
7511                                             const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7512                                             while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) {
7513                                                 if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) {
7514                                                     switch (tokTexture3DOffsetInfo->id) {
7515                                                     default:
7516                                                         if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
7517                                                             return false;
7518                                                         }
7519                                                         break;
7520                                                     case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: {
7521                                                         dst.Surf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.Surf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo);
7522                                                     } break;
7523                                                     case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
7524                                                         auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>();
7525                                                         auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes();
7526                                                         if (srcSize < sizeof(dst.Surf.OffsetInfo.Texture3DOffsetInfo.Offset)) {
7527                                                             return false;
7528                                                         }
7529                                                         WCH_SAFE_COPY(dst.Surf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.Surf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.Surf.OffsetInfo.Texture3DOffsetInfo.Offset));
7530                                                     } break;
7531                                                     };
7532                                                     tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount;
7533                                                 } else {
7534                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo);
7535                                                     if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
7536                                                         return false;
7537                                                     }
7538                                                     tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7539                                                 }
7540                                             }
7541                                             WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd);
7542                                         } break;
7543                                         case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: {
7544                                             const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>();
7545                                             const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7546                                             while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) {
7547                                                 if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) {
7548                                                     switch (tokTexture2DOffsetInfo->id) {
7549                                                     default:
7550                                                         if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
7551                                                             return false;
7552                                                         }
7553                                                         break;
7554                                                     case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: {
7555                                                         dst.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo);
7556                                                     } break;
7557                                                     case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: {
7558                                                         dst.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo);
7559                                                     } break;
7560                                                     case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
7561                                                         auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>();
7562                                                         auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes();
7563                                                         if (srcSize < sizeof(dst.Surf.OffsetInfo.Texture2DOffsetInfo.Offset)) {
7564                                                             return false;
7565                                                         }
7566                                                         WCH_SAFE_COPY(dst.Surf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.Surf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.Surf.OffsetInfo.Texture2DOffsetInfo.Offset));
7567                                                     } break;
7568                                                     };
7569                                                     tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount;
7570                                                 } else {
7571                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo);
7572                                                     if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
7573                                                         return false;
7574                                                     }
7575                                                     tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7576                                                 }
7577                                             }
7578                                             WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd);
7579                                         } break;
7580                                         case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: {
7581                                             const TokenHeader *tokPlane = varLen->getValue<TokenHeader>();
7582                                             const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7583                                             while (tokPlane < tokPlaneEnd) {
7584                                                 if (false == tokPlane->flags.flag4IsVariableLength) {
7585                                                     switch (tokPlane->id) {
7586                                                     default:
7587                                                         if (tokPlane->flags.flag3IsMandatory) {
7588                                                             return false;
7589                                                         }
7590                                                         break;
7591                                                     case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: {
7592                                                         dst.Surf.OffsetInfo.Plane.ArrayQPitch = readTokValue<decltype(dst.Surf.OffsetInfo.Plane.ArrayQPitch)>(*tokPlane);
7593                                                     } break;
7594                                                     case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: {
7595                                                         auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
7596                                                         auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
7597                                                         if (srcSize < sizeof(dst.Surf.OffsetInfo.Plane.X)) {
7598                                                             return false;
7599                                                         }
7600                                                         WCH_SAFE_COPY(dst.Surf.OffsetInfo.Plane.X, sizeof(dst.Surf.OffsetInfo.Plane.X), srcData, sizeof(dst.Surf.OffsetInfo.Plane.X));
7601                                                     } break;
7602                                                     case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: {
7603                                                         auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
7604                                                         auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
7605                                                         if (srcSize < sizeof(dst.Surf.OffsetInfo.Plane.Y)) {
7606                                                             return false;
7607                                                         }
7608                                                         WCH_SAFE_COPY(dst.Surf.OffsetInfo.Plane.Y, sizeof(dst.Surf.OffsetInfo.Plane.Y), srcData, sizeof(dst.Surf.OffsetInfo.Plane.Y));
7609                                                     } break;
7610                                                     case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: {
7611                                                         dst.Surf.OffsetInfo.Plane.NoOfPlanes = readTokValue<decltype(dst.Surf.OffsetInfo.Plane.NoOfPlanes)>(*tokPlane);
7612                                                     } break;
7613                                                     case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: {
7614                                                         dst.Surf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.Surf.OffsetInfo.Plane.IsTileAlignedPlanes)>(*tokPlane);
7615                                                     } break;
7616                                                     };
7617                                                     tokPlane = tokPlane + 1 + tokPlane->valueDwordCount;
7618                                                 } else {
7619                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane);
7620                                                     switch (tokPlane->id) {
7621                                                     default:
7622                                                         if (tokPlane->flags.flag3IsMandatory) {
7623                                                             return false;
7624                                                         }
7625                                                         break;
7626                                                     case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: {
7627                                                         const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>();
7628                                                         const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7629                                                         while (tokUnAligned < tokUnAlignedEnd) {
7630                                                             if (false == tokUnAligned->flags.flag4IsVariableLength) {
7631                                                                 switch (tokUnAligned->id) {
7632                                                                 default:
7633                                                                     if (tokUnAligned->flags.flag3IsMandatory) {
7634                                                                         return false;
7635                                                                     }
7636                                                                     break;
7637                                                                 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: {
7638                                                                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>();
7639                                                                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes();
7640                                                                     if (srcSize < sizeof(dst.Surf.OffsetInfo.Plane.UnAligned.Height)) {
7641                                                                         return false;
7642                                                                     }
7643                                                                     WCH_SAFE_COPY(dst.Surf.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.Surf.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.Surf.OffsetInfo.Plane.UnAligned.Height));
7644                                                                 } break;
7645                                                                 };
7646                                                                 tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount;
7647                                                             } else {
7648                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned);
7649                                                                 if (tokUnAligned->flags.flag3IsMandatory) {
7650                                                                     return false;
7651                                                                 }
7652                                                                 tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7653                                                             }
7654                                                         }
7655                                                         WCH_ASSERT(tokUnAligned == tokUnAlignedEnd);
7656                                                     } break;
7657                                                     };
7658                                                     tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7659                                                 }
7660                                             }
7661                                             WCH_ASSERT(tokPlane == tokPlaneEnd);
7662                                         } break;
7663                                         };
7664                                         tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7665                                     }
7666                                 }
7667                                 WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd);
7668                             } break;
7669                             case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: {
7670                                 const TokenHeader *tokS3d = varLen->getValue<TokenHeader>();
7671                                 const TokenHeader *tokS3dEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7672                                 while (tokS3d < tokS3dEnd) {
7673                                     if (false == tokS3d->flags.flag4IsVariableLength) {
7674                                         switch (tokS3d->id) {
7675                                         default:
7676                                             if (tokS3d->flags.flag3IsMandatory) {
7677                                                 return false;
7678                                             }
7679                                             break;
7680                                         case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: {
7681                                             dst.Surf.S3d.DisplayModeHeight = readTokValue<decltype(dst.Surf.S3d.DisplayModeHeight)>(*tokS3d);
7682                                         } break;
7683                                         case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: {
7684                                             dst.Surf.S3d.NumBlankActiveLines = readTokValue<decltype(dst.Surf.S3d.NumBlankActiveLines)>(*tokS3d);
7685                                         } break;
7686                                         case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: {
7687                                             dst.Surf.S3d.RFrameOffset = readTokValue<decltype(dst.Surf.S3d.RFrameOffset)>(*tokS3d);
7688                                         } break;
7689                                         case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: {
7690                                             dst.Surf.S3d.BlankAreaOffset = readTokValue<decltype(dst.Surf.S3d.BlankAreaOffset)>(*tokS3d);
7691                                         } break;
7692                                         case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: {
7693                                             dst.Surf.S3d.TallBufferHeight = readTokValue<decltype(dst.Surf.S3d.TallBufferHeight)>(*tokS3d);
7694                                         } break;
7695                                         case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: {
7696                                             dst.Surf.S3d.TallBufferSize = readTokValue<decltype(dst.Surf.S3d.TallBufferSize)>(*tokS3d);
7697                                         } break;
7698                                         case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: {
7699                                             dst.Surf.S3d.IsRFrame = readTokValue<decltype(dst.Surf.S3d.IsRFrame)>(*tokS3d);
7700                                         } break;
7701                                         };
7702                                         tokS3d = tokS3d + 1 + tokS3d->valueDwordCount;
7703                                     } else {
7704                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokS3d);
7705                                         if (tokS3d->flags.flag3IsMandatory) {
7706                                             return false;
7707                                         }
7708                                         tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7709                                     }
7710                                 }
7711                                 WCH_ASSERT(tokS3d == tokS3dEnd);
7712                             } break;
7713                             case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: {
7714                                 const TokenHeader *tokSegmentOverride = varLen->getValue<TokenHeader>();
7715                                 const TokenHeader *tokSegmentOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7716                                 while (tokSegmentOverride < tokSegmentOverrideEnd) {
7717                                     if (false == tokSegmentOverride->flags.flag4IsVariableLength) {
7718                                         switch (tokSegmentOverride->id) {
7719                                         default:
7720                                             if (tokSegmentOverride->flags.flag3IsMandatory) {
7721                                                 return false;
7722                                             }
7723                                             break;
7724                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: {
7725                                             dst.Surf.SegmentOverride.Seg1 = readTokValue<decltype(dst.Surf.SegmentOverride.Seg1)>(*tokSegmentOverride);
7726                                         } break;
7727                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: {
7728                                             dst.Surf.SegmentOverride.Evict = readTokValue<decltype(dst.Surf.SegmentOverride.Evict)>(*tokSegmentOverride);
7729                                         } break;
7730                                         };
7731                                         tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount;
7732                                     } else {
7733                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSegmentOverride);
7734                                         if (tokSegmentOverride->flags.flag3IsMandatory) {
7735                                             return false;
7736                                         }
7737                                         tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7738                                     }
7739                                 }
7740                                 WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd);
7741                             } break;
7742                             case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: {
7743 #if _DEBUG || _RELEASE_INTERNAL
7744                                 const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>();
7745                                 const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7746                                 while (tokPlatform < tokPlatformEnd) {
7747                                     if (false == tokPlatform->flags.flag4IsVariableLength) {
7748                                         switch (tokPlatform->id) {
7749                                         default:
7750                                             if (tokPlatform->flags.flag3IsMandatory) {
7751                                                 return false;
7752                                             }
7753                                             break;
7754                                         case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
7755                                             dst.Surf.Platform.eProductFamily = readTokValue<decltype(dst.Surf.Platform.eProductFamily)>(*tokPlatform);
7756                                         } break;
7757                                         case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
7758                                             dst.Surf.Platform.ePCHProductFamily = readTokValue<decltype(dst.Surf.Platform.ePCHProductFamily)>(*tokPlatform);
7759                                         } break;
7760                                         case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
7761                                             dst.Surf.Platform.eDisplayCoreFamily = readTokValue<decltype(dst.Surf.Platform.eDisplayCoreFamily)>(*tokPlatform);
7762                                         } break;
7763                                         case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
7764                                             dst.Surf.Platform.eRenderCoreFamily = readTokValue<decltype(dst.Surf.Platform.eRenderCoreFamily)>(*tokPlatform);
7765                                         } break;
7766                                         case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
7767                                             dst.Surf.Platform.ePlatformType = readTokValue<decltype(dst.Surf.Platform.ePlatformType)>(*tokPlatform);
7768                                         } break;
7769                                         case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
7770                                             dst.Surf.Platform.usDeviceID = readTokValue<decltype(dst.Surf.Platform.usDeviceID)>(*tokPlatform);
7771                                         } break;
7772                                         case TOK_FBW_PLATFORM_STR__US_REV_ID: {
7773                                             dst.Surf.Platform.usRevId = readTokValue<decltype(dst.Surf.Platform.usRevId)>(*tokPlatform);
7774                                         } break;
7775                                         case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
7776                                             dst.Surf.Platform.usDeviceID_PCH = readTokValue<decltype(dst.Surf.Platform.usDeviceID_PCH)>(*tokPlatform);
7777                                         } break;
7778                                         case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
7779                                             dst.Surf.Platform.usRevId_PCH = readTokValue<decltype(dst.Surf.Platform.usRevId_PCH)>(*tokPlatform);
7780                                         } break;
7781                                         case TOK_FE_PLATFORM_STR__E_GTTYPE: {
7782                                             dst.Surf.Platform.eGTType = readTokValue<decltype(dst.Surf.Platform.eGTType)>(*tokPlatform);
7783                                         } break;
7784                                         };
7785                                         tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount;
7786                                     } else {
7787                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform);
7788                                         if (tokPlatform->flags.flag3IsMandatory) {
7789                                             return false;
7790                                         }
7791                                         tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7792                                     }
7793                                 }
7794                                 WCH_ASSERT(tokPlatform == tokPlatformEnd);
7795 #endif
7796                             } break;
7797                             case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: {
7798                                 const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>();
7799                                 const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7800                                 while (tokExistingSysMem < tokExistingSysMemEnd) {
7801                                     if (false == tokExistingSysMem->flags.flag4IsVariableLength) {
7802                                         switch (tokExistingSysMem->id) {
7803                                         default:
7804                                             if (tokExistingSysMem->flags.flag3IsMandatory) {
7805                                                 return false;
7806                                             }
7807                                             break;
7808                                         case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: {
7809                                             dst.Surf.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.Surf.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem);
7810                                         } break;
7811                                         case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: {
7812                                             dst.Surf.ExistingSysMem.IsPageAligned = readTokValue<decltype(dst.Surf.ExistingSysMem.IsPageAligned)>(*tokExistingSysMem);
7813                                         } break;
7814                                         };
7815                                         tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount;
7816                                     } else {
7817                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem);
7818                                         if (tokExistingSysMem->flags.flag3IsMandatory) {
7819                                             return false;
7820                                         }
7821                                         tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7822                                     }
7823                                 }
7824                                 WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd);
7825                             } break;
7826                             case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: {
7827 #if !(_DEBUG || _RELEASE_INTERNAL)
7828                                 const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>();
7829                                 const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7830                                 while (tok__Platform < tok__PlatformEnd) {
7831                                     if (false == tok__Platform->flags.flag4IsVariableLength) {
7832                                         switch (tok__Platform->id) {
7833                                         default:
7834                                             if (tok__Platform->flags.flag3IsMandatory) {
7835                                                 return false;
7836                                             }
7837                                             break;
7838                                         case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
7839                                             dst.Surf.__Platform.eProductFamily = readTokValue<decltype(dst.Surf.__Platform.eProductFamily)>(*tok__Platform);
7840                                         } break;
7841                                         case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
7842                                             dst.Surf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.Surf.__Platform.ePCHProductFamily)>(*tok__Platform);
7843                                         } break;
7844                                         case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
7845                                             dst.Surf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.Surf.__Platform.eDisplayCoreFamily)>(*tok__Platform);
7846                                         } break;
7847                                         case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
7848                                             dst.Surf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.Surf.__Platform.eRenderCoreFamily)>(*tok__Platform);
7849                                         } break;
7850                                         case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
7851                                             dst.Surf.__Platform.ePlatformType = readTokValue<decltype(dst.Surf.__Platform.ePlatformType)>(*tok__Platform);
7852                                         } break;
7853                                         case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
7854                                             dst.Surf.__Platform.usDeviceID = readTokValue<decltype(dst.Surf.__Platform.usDeviceID)>(*tok__Platform);
7855                                         } break;
7856                                         case TOK_FBW_PLATFORM_STR__US_REV_ID: {
7857                                             dst.Surf.__Platform.usRevId = readTokValue<decltype(dst.Surf.__Platform.usRevId)>(*tok__Platform);
7858                                         } break;
7859                                         case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
7860                                             dst.Surf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.Surf.__Platform.usDeviceID_PCH)>(*tok__Platform);
7861                                         } break;
7862                                         case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
7863                                             dst.Surf.__Platform.usRevId_PCH = readTokValue<decltype(dst.Surf.__Platform.usRevId_PCH)>(*tok__Platform);
7864                                         } break;
7865                                         case TOK_FE_PLATFORM_STR__E_GTTYPE: {
7866                                             dst.Surf.__Platform.eGTType = readTokValue<decltype(dst.Surf.__Platform.eGTType)>(*tok__Platform);
7867                                         } break;
7868                                         };
7869                                         tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount;
7870                                     } else {
7871                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform);
7872                                         if (tok__Platform->flags.flag3IsMandatory) {
7873                                             return false;
7874                                         }
7875                                         tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7876                                     }
7877                                 }
7878                                 WCH_ASSERT(tok__Platform == tok__PlatformEnd);
7879 #endif
7880                             } break;
7881                             };
7882                             tokSurf = tokSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
7883                         }
7884                     }
7885                     WCH_ASSERT(tokSurf == tokSurfEnd);
7886                 } break;
7887                 case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SURF: {
7888                     const TokenHeader *tokAuxSurf = varLen->getValue<TokenHeader>();
7889                     const TokenHeader *tokAuxSurfEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7890                     while (tokAuxSurf < tokAuxSurfEnd) {
7891                         if (false == tokAuxSurf->flags.flag4IsVariableLength) {
7892                             switch (tokAuxSurf->id) {
7893                             default:
7894                                 if (tokAuxSurf->flags.flag3IsMandatory) {
7895                                     return false;
7896                                 }
7897                                 break;
7898                             case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: {
7899                                 dst.AuxSurf.Type = readTokValue<decltype(dst.AuxSurf.Type)>(*tokAuxSurf);
7900                             } break;
7901                             case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: {
7902                                 dst.AuxSurf.Format = readTokValue<decltype(dst.AuxSurf.Format)>(*tokAuxSurf);
7903                             } break;
7904                             case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: {
7905                                 dst.AuxSurf.BitsPerPixel = readTokValue<decltype(dst.AuxSurf.BitsPerPixel)>(*tokAuxSurf);
7906                             } break;
7907                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: {
7908                                 dst.AuxSurf.BaseWidth = readTokValue<decltype(dst.AuxSurf.BaseWidth)>(*tokAuxSurf);
7909                             } break;
7910                             case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: {
7911                                 dst.AuxSurf.BaseHeight = readTokValue<decltype(dst.AuxSurf.BaseHeight)>(*tokAuxSurf);
7912                             } break;
7913                             case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: {
7914                                 dst.AuxSurf.Depth = readTokValue<decltype(dst.AuxSurf.Depth)>(*tokAuxSurf);
7915                             } break;
7916                             case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: {
7917                                 dst.AuxSurf.MaxLod = readTokValue<decltype(dst.AuxSurf.MaxLod)>(*tokAuxSurf);
7918                             } break;
7919                             case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: {
7920                                 dst.AuxSurf.ArraySize = readTokValue<decltype(dst.AuxSurf.ArraySize)>(*tokAuxSurf);
7921                             } break;
7922                             case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: {
7923                                 dst.AuxSurf.CpTag = readTokValue<decltype(dst.AuxSurf.CpTag)>(*tokAuxSurf);
7924                             } break;
7925                             case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: {
7926                                 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValue<char>();
7927                                 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValueSizeInBytes();
7928                                 if (srcSize < sizeof(dst.AuxSurf.MmcMode)) {
7929                                     return false;
7930                                 }
7931                                 WCH_SAFE_COPY(dst.AuxSurf.MmcMode, sizeof(dst.AuxSurf.MmcMode), srcData, sizeof(dst.AuxSurf.MmcMode));
7932                             } break;
7933                             case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: {
7934                                 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValue<char>();
7935                                 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValueSizeInBytes();
7936                                 if (srcSize < sizeof(dst.AuxSurf.MmcHint)) {
7937                                     return false;
7938                                 }
7939                                 WCH_SAFE_COPY(dst.AuxSurf.MmcHint, sizeof(dst.AuxSurf.MmcHint), srcData, sizeof(dst.AuxSurf.MmcHint));
7940                             } break;
7941                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: {
7942                                 dst.AuxSurf.Pitch = readTokValue<decltype(dst.AuxSurf.Pitch)>(*tokAuxSurf);
7943                             } break;
7944                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: {
7945                                 dst.AuxSurf.OverridePitch = readTokValue<decltype(dst.AuxSurf.OverridePitch)>(*tokAuxSurf);
7946                             } break;
7947                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: {
7948                                 dst.AuxSurf.Size = readTokValue<decltype(dst.AuxSurf.Size)>(*tokAuxSurf);
7949                             } break;
7950                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: {
7951                                 dst.AuxSurf.CCSize = readTokValue<decltype(dst.AuxSurf.CCSize)>(*tokAuxSurf);
7952                             } break;
7953                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: {
7954                                 dst.AuxSurf.UnpaddedSize = readTokValue<decltype(dst.AuxSurf.UnpaddedSize)>(*tokAuxSurf);
7955                             } break;
7956                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: {
7957                                 dst.AuxSurf.SizeReportToOS = readTokValue<decltype(dst.AuxSurf.SizeReportToOS)>(*tokAuxSurf);
7958                             } break;
7959                             case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: {
7960                                 dst.AuxSurf.TileMode = readTokValue<decltype(dst.AuxSurf.TileMode)>(*tokAuxSurf);
7961                             } break;
7962                             case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: {
7963                                 dst.AuxSurf.CCSModeAlign = readTokValue<decltype(dst.AuxSurf.CCSModeAlign)>(*tokAuxSurf);
7964                             } break;
7965                             case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: {
7966                                 dst.AuxSurf.LegacyFlags = readTokValue<decltype(dst.AuxSurf.LegacyFlags)>(*tokAuxSurf);
7967                             } break;
7968                             case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: {
7969                                 dst.AuxSurf.MaximumRenamingListLength = readTokValue<decltype(dst.AuxSurf.MaximumRenamingListLength)>(*tokAuxSurf);
7970                             } break;
7971                             };
7972                             tokAuxSurf = tokAuxSurf + 1 + tokAuxSurf->valueDwordCount;
7973                         } else {
7974                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAuxSurf);
7975                             switch (tokAuxSurf->id) {
7976                             default:
7977                                 if (tokAuxSurf->flags.flag3IsMandatory) {
7978                                     return false;
7979                                 }
7980                                 break;
7981                             case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: {
7982                                 const TokenHeader *tokFlags = varLen->getValue<TokenHeader>();
7983                                 const TokenHeader *tokFlagsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
7984                                 while (tokFlags < tokFlagsEnd) {
7985                                     if (false == tokFlags->flags.flag4IsVariableLength) {
7986                                         if (tokFlags->flags.flag3IsMandatory) {
7987                                             return false;
7988                                         }
7989                                         tokFlags = tokFlags + 1 + tokFlags->valueDwordCount;
7990                                     } else {
7991                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokFlags);
7992                                         switch (tokFlags->id) {
7993                                         default:
7994                                             if (tokFlags->flags.flag3IsMandatory) {
7995                                                 return false;
7996                                             }
7997                                             break;
7998                                         case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: {
7999                                             const TokenHeader *tokGpu = varLen->getValue<TokenHeader>();
8000                                             const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8001                                             while (tokGpu < tokGpuEnd) {
8002                                                 if (false == tokGpu->flags.flag4IsVariableLength) {
8003                                                     switch (tokGpu->id) {
8004                                                     default:
8005                                                         if (tokGpu->flags.flag3IsMandatory) {
8006                                                             return false;
8007                                                         }
8008                                                         break;
8009                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: {
8010                                                         dst.AuxSurf.Flags.Gpu.CameraCapture = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.CameraCapture)>(*tokGpu);
8011                                                     } break;
8012                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: {
8013                                                         dst.AuxSurf.Flags.Gpu.CCS = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.CCS)>(*tokGpu);
8014                                                     } break;
8015                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: {
8016                                                         dst.AuxSurf.Flags.Gpu.ColorDiscard = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.ColorDiscard)>(*tokGpu);
8017                                                     } break;
8018                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: {
8019                                                         dst.AuxSurf.Flags.Gpu.ColorSeparation = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.ColorSeparation)>(*tokGpu);
8020                                                     } break;
8021                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: {
8022                                                         dst.AuxSurf.Flags.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.ColorSeparationRGBX)>(*tokGpu);
8023                                                     } break;
8024                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: {
8025                                                         dst.AuxSurf.Flags.Gpu.Constant = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Constant)>(*tokGpu);
8026                                                     } break;
8027                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: {
8028                                                         dst.AuxSurf.Flags.Gpu.Depth = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Depth)>(*tokGpu);
8029                                                     } break;
8030                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: {
8031                                                         dst.AuxSurf.Flags.Gpu.FlipChain = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.FlipChain)>(*tokGpu);
8032                                                     } break;
8033                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: {
8034                                                         dst.AuxSurf.Flags.Gpu.FlipChainPreferred = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.FlipChainPreferred)>(*tokGpu);
8035                                                     } break;
8036                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: {
8037                                                         dst.AuxSurf.Flags.Gpu.HistoryBuffer = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.HistoryBuffer)>(*tokGpu);
8038                                                     } break;
8039                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: {
8040                                                         dst.AuxSurf.Flags.Gpu.HiZ = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.HiZ)>(*tokGpu);
8041                                                     } break;
8042                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: {
8043                                                         dst.AuxSurf.Flags.Gpu.Index = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Index)>(*tokGpu);
8044                                                     } break;
8045                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: {
8046                                                         dst.AuxSurf.Flags.Gpu.IndirectClearColor = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.IndirectClearColor)>(*tokGpu);
8047                                                     } break;
8048                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: {
8049                                                         dst.AuxSurf.Flags.Gpu.InstructionFlat = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.InstructionFlat)>(*tokGpu);
8050                                                     } break;
8051                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: {
8052                                                         dst.AuxSurf.Flags.Gpu.InterlacedScan = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.InterlacedScan)>(*tokGpu);
8053                                                     } break;
8054                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: {
8055                                                         dst.AuxSurf.Flags.Gpu.MCS = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.MCS)>(*tokGpu);
8056                                                     } break;
8057                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: {
8058                                                         dst.AuxSurf.Flags.Gpu.MMC = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.MMC)>(*tokGpu);
8059                                                     } break;
8060                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: {
8061                                                         dst.AuxSurf.Flags.Gpu.MotionComp = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.MotionComp)>(*tokGpu);
8062                                                     } break;
8063                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: {
8064                                                         dst.AuxSurf.Flags.Gpu.NoRestriction = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.NoRestriction)>(*tokGpu);
8065                                                     } break;
8066                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: {
8067                                                         dst.AuxSurf.Flags.Gpu.Overlay = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Overlay)>(*tokGpu);
8068                                                     } break;
8069                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: {
8070                                                         dst.AuxSurf.Flags.Gpu.Presentable = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Presentable)>(*tokGpu);
8071                                                     } break;
8072                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: {
8073                                                         dst.AuxSurf.Flags.Gpu.ProceduralTexture = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.ProceduralTexture)>(*tokGpu);
8074                                                     } break;
8075                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: {
8076                                                         dst.AuxSurf.Flags.Gpu.Query = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Query)>(*tokGpu);
8077                                                     } break;
8078                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: {
8079                                                         dst.AuxSurf.Flags.Gpu.RenderTarget = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.RenderTarget)>(*tokGpu);
8080                                                     } break;
8081                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: {
8082                                                         dst.AuxSurf.Flags.Gpu.S3d = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.S3d)>(*tokGpu);
8083                                                     } break;
8084                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: {
8085                                                         dst.AuxSurf.Flags.Gpu.S3dDx = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.S3dDx)>(*tokGpu);
8086                                                     } break;
8087                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: {
8088                                                         dst.AuxSurf.Flags.Gpu.__S3dNonPacked = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.__S3dNonPacked)>(*tokGpu);
8089                                                     } break;
8090                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: {
8091                                                         dst.AuxSurf.Flags.Gpu.__S3dWidi = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.__S3dWidi)>(*tokGpu);
8092                                                     } break;
8093                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: {
8094                                                         dst.AuxSurf.Flags.Gpu.ScratchFlat = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.ScratchFlat)>(*tokGpu);
8095                                                     } break;
8096                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: {
8097                                                         dst.AuxSurf.Flags.Gpu.SeparateStencil = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.SeparateStencil)>(*tokGpu);
8098                                                     } break;
8099                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: {
8100                                                         dst.AuxSurf.Flags.Gpu.State = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.State)>(*tokGpu);
8101                                                     } break;
8102                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: {
8103                                                         dst.AuxSurf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.StateDx9ConstantBuffer)>(*tokGpu);
8104                                                     } break;
8105                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: {
8106                                                         dst.AuxSurf.Flags.Gpu.Stream = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Stream)>(*tokGpu);
8107                                                     } break;
8108                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: {
8109                                                         dst.AuxSurf.Flags.Gpu.TextApi = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.TextApi)>(*tokGpu);
8110                                                     } break;
8111                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: {
8112                                                         dst.AuxSurf.Flags.Gpu.Texture = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Texture)>(*tokGpu);
8113                                                     } break;
8114                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: {
8115                                                         dst.AuxSurf.Flags.Gpu.TiledResource = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.TiledResource)>(*tokGpu);
8116                                                     } break;
8117                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: {
8118                                                         dst.AuxSurf.Flags.Gpu.TilePool = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.TilePool)>(*tokGpu);
8119                                                     } break;
8120                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: {
8121                                                         dst.AuxSurf.Flags.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.UnifiedAuxSurface)>(*tokGpu);
8122                                                     } break;
8123                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: {
8124                                                         dst.AuxSurf.Flags.Gpu.Vertex = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Vertex)>(*tokGpu);
8125                                                     } break;
8126                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: {
8127                                                         dst.AuxSurf.Flags.Gpu.Video = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.Video)>(*tokGpu);
8128                                                     } break;
8129                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: {
8130                                                         dst.AuxSurf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.__NonMsaaTileXCcs)>(*tokGpu);
8131                                                     } break;
8132                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: {
8133                                                         dst.AuxSurf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.__NonMsaaTileYCcs)>(*tokGpu);
8134                                                     } break;
8135                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: {
8136                                                         dst.AuxSurf.Flags.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.__MsaaTileMcs)>(*tokGpu);
8137                                                     } break;
8138                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: {
8139                                                         dst.AuxSurf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.__NonMsaaLinearCCS)>(*tokGpu);
8140                                                     } break;
8141                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: {
8142                                                         dst.AuxSurf.Flags.Gpu.__Remaining = readTokValue<decltype(dst.AuxSurf.Flags.Gpu.__Remaining)>(*tokGpu);
8143                                                     } break;
8144                                                     };
8145                                                     tokGpu = tokGpu + 1 + tokGpu->valueDwordCount;
8146                                                 } else {
8147                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu);
8148                                                     if (tokGpu->flags.flag3IsMandatory) {
8149                                                         return false;
8150                                                     }
8151                                                     tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8152                                                 }
8153                                             }
8154                                             WCH_ASSERT(tokGpu == tokGpuEnd);
8155                                         } break;
8156                                         case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: {
8157                                             const TokenHeader *tokInfo = varLen->getValue<TokenHeader>();
8158                                             const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8159                                             while (tokInfo < tokInfoEnd) {
8160                                                 if (false == tokInfo->flags.flag4IsVariableLength) {
8161                                                     switch (tokInfo->id) {
8162                                                     default:
8163                                                         if (tokInfo->flags.flag3IsMandatory) {
8164                                                             return false;
8165                                                         }
8166                                                         break;
8167                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: {
8168                                                         dst.AuxSurf.Flags.Info.AllowVirtualPadding = readTokValue<decltype(dst.AuxSurf.Flags.Info.AllowVirtualPadding)>(*tokInfo);
8169                                                     } break;
8170                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: {
8171                                                         dst.AuxSurf.Flags.Info.BigPage = readTokValue<decltype(dst.AuxSurf.Flags.Info.BigPage)>(*tokInfo);
8172                                                     } break;
8173                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: {
8174                                                         dst.AuxSurf.Flags.Info.Cacheable = readTokValue<decltype(dst.AuxSurf.Flags.Info.Cacheable)>(*tokInfo);
8175                                                     } break;
8176                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: {
8177                                                         dst.AuxSurf.Flags.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.AuxSurf.Flags.Info.ContigPhysMemoryForiDART)>(*tokInfo);
8178                                                     } break;
8179                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: {
8180                                                         dst.AuxSurf.Flags.Info.CornerTexelMode = readTokValue<decltype(dst.AuxSurf.Flags.Info.CornerTexelMode)>(*tokInfo);
8181                                                     } break;
8182                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: {
8183                                                         dst.AuxSurf.Flags.Info.ExistingSysMem = readTokValue<decltype(dst.AuxSurf.Flags.Info.ExistingSysMem)>(*tokInfo);
8184                                                     } break;
8185                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: {
8186                                                         dst.AuxSurf.Flags.Info.ForceResidency = readTokValue<decltype(dst.AuxSurf.Flags.Info.ForceResidency)>(*tokInfo);
8187                                                     } break;
8188                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: {
8189                                                         dst.AuxSurf.Flags.Info.Gfdt = readTokValue<decltype(dst.AuxSurf.Flags.Info.Gfdt)>(*tokInfo);
8190                                                     } break;
8191                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: {
8192                                                         dst.AuxSurf.Flags.Info.GttMapType = readTokValue<decltype(dst.AuxSurf.Flags.Info.GttMapType)>(*tokInfo);
8193                                                     } break;
8194                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: {
8195                                                         dst.AuxSurf.Flags.Info.HardwareProtected = readTokValue<decltype(dst.AuxSurf.Flags.Info.HardwareProtected)>(*tokInfo);
8196                                                     } break;
8197                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: {
8198                                                         dst.AuxSurf.Flags.Info.KernelModeMapped = readTokValue<decltype(dst.AuxSurf.Flags.Info.KernelModeMapped)>(*tokInfo);
8199                                                     } break;
8200                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: {
8201                                                         dst.AuxSurf.Flags.Info.LayoutBelow = readTokValue<decltype(dst.AuxSurf.Flags.Info.LayoutBelow)>(*tokInfo);
8202                                                     } break;
8203                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: {
8204                                                         dst.AuxSurf.Flags.Info.LayoutMono = readTokValue<decltype(dst.AuxSurf.Flags.Info.LayoutMono)>(*tokInfo);
8205                                                     } break;
8206                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: {
8207                                                         dst.AuxSurf.Flags.Info.LayoutRight = readTokValue<decltype(dst.AuxSurf.Flags.Info.LayoutRight)>(*tokInfo);
8208                                                     } break;
8209                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: {
8210                                                         dst.AuxSurf.Flags.Info.LocalOnly = readTokValue<decltype(dst.AuxSurf.Flags.Info.LocalOnly)>(*tokInfo);
8211                                                     } break;
8212                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: {
8213                                                         dst.AuxSurf.Flags.Info.Linear = readTokValue<decltype(dst.AuxSurf.Flags.Info.Linear)>(*tokInfo);
8214                                                     } break;
8215                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: {
8216                                                         dst.AuxSurf.Flags.Info.MediaCompressed = readTokValue<decltype(dst.AuxSurf.Flags.Info.MediaCompressed)>(*tokInfo);
8217                                                     } break;
8218                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: {
8219                                                         dst.AuxSurf.Flags.Info.NoOptimizationPadding = readTokValue<decltype(dst.AuxSurf.Flags.Info.NoOptimizationPadding)>(*tokInfo);
8220                                                     } break;
8221                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: {
8222                                                         dst.AuxSurf.Flags.Info.NoPhysMemory = readTokValue<decltype(dst.AuxSurf.Flags.Info.NoPhysMemory)>(*tokInfo);
8223                                                     } break;
8224                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: {
8225                                                         dst.AuxSurf.Flags.Info.NotLockable = readTokValue<decltype(dst.AuxSurf.Flags.Info.NotLockable)>(*tokInfo);
8226                                                     } break;
8227                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: {
8228                                                         dst.AuxSurf.Flags.Info.NonLocalOnly = readTokValue<decltype(dst.AuxSurf.Flags.Info.NonLocalOnly)>(*tokInfo);
8229                                                     } break;
8230                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: {
8231                                                         dst.AuxSurf.Flags.Info.StdSwizzle = readTokValue<decltype(dst.AuxSurf.Flags.Info.StdSwizzle)>(*tokInfo);
8232                                                     } break;
8233                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: {
8234                                                         dst.AuxSurf.Flags.Info.PseudoStdSwizzle = readTokValue<decltype(dst.AuxSurf.Flags.Info.PseudoStdSwizzle)>(*tokInfo);
8235                                                     } break;
8236                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: {
8237                                                         dst.AuxSurf.Flags.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.AuxSurf.Flags.Info.Undefined64KBSwizzle)>(*tokInfo);
8238                                                     } break;
8239                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: {
8240                                                         dst.AuxSurf.Flags.Info.RedecribedPlanes = readTokValue<decltype(dst.AuxSurf.Flags.Info.RedecribedPlanes)>(*tokInfo);
8241                                                     } break;
8242                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: {
8243                                                         dst.AuxSurf.Flags.Info.RenderCompressed = readTokValue<decltype(dst.AuxSurf.Flags.Info.RenderCompressed)>(*tokInfo);
8244                                                     } break;
8245                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: {
8246                                                         dst.AuxSurf.Flags.Info.Rotated = readTokValue<decltype(dst.AuxSurf.Flags.Info.Rotated)>(*tokInfo);
8247                                                     } break;
8248                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: {
8249                                                         dst.AuxSurf.Flags.Info.Shared = readTokValue<decltype(dst.AuxSurf.Flags.Info.Shared)>(*tokInfo);
8250                                                     } break;
8251                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: {
8252                                                         dst.AuxSurf.Flags.Info.SoftwareProtected = readTokValue<decltype(dst.AuxSurf.Flags.Info.SoftwareProtected)>(*tokInfo);
8253                                                     } break;
8254                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: {
8255                                                         dst.AuxSurf.Flags.Info.SVM = readTokValue<decltype(dst.AuxSurf.Flags.Info.SVM)>(*tokInfo);
8256                                                     } break;
8257                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: {
8258                                                         dst.AuxSurf.Flags.Info.Tile4 = readTokValue<decltype(dst.AuxSurf.Flags.Info.Tile4)>(*tokInfo);
8259                                                     } break;
8260                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: {
8261                                                         dst.AuxSurf.Flags.Info.Tile64 = readTokValue<decltype(dst.AuxSurf.Flags.Info.Tile64)>(*tokInfo);
8262                                                     } break;
8263                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: {
8264                                                         dst.AuxSurf.Flags.Info.TiledW = readTokValue<decltype(dst.AuxSurf.Flags.Info.TiledW)>(*tokInfo);
8265                                                     } break;
8266                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: {
8267                                                         dst.AuxSurf.Flags.Info.TiledX = readTokValue<decltype(dst.AuxSurf.Flags.Info.TiledX)>(*tokInfo);
8268                                                     } break;
8269                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: {
8270                                                         dst.AuxSurf.Flags.Info.TiledY = readTokValue<decltype(dst.AuxSurf.Flags.Info.TiledY)>(*tokInfo);
8271                                                     } break;
8272                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: {
8273                                                         dst.AuxSurf.Flags.Info.TiledYf = readTokValue<decltype(dst.AuxSurf.Flags.Info.TiledYf)>(*tokInfo);
8274                                                     } break;
8275                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: {
8276                                                         dst.AuxSurf.Flags.Info.TiledYs = readTokValue<decltype(dst.AuxSurf.Flags.Info.TiledYs)>(*tokInfo);
8277                                                     } break;
8278                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: {
8279                                                         dst.AuxSurf.Flags.Info.WddmProtected = readTokValue<decltype(dst.AuxSurf.Flags.Info.WddmProtected)>(*tokInfo);
8280                                                     } break;
8281                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: {
8282                                                         dst.AuxSurf.Flags.Info.XAdapter = readTokValue<decltype(dst.AuxSurf.Flags.Info.XAdapter)>(*tokInfo);
8283                                                     } break;
8284                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: {
8285                                                         dst.AuxSurf.Flags.Info.__PreallocatedResInfo = readTokValue<decltype(dst.AuxSurf.Flags.Info.__PreallocatedResInfo)>(*tokInfo);
8286                                                     } break;
8287                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: {
8288                                                         dst.AuxSurf.Flags.Info.__PreWddm2SVM = readTokValue<decltype(dst.AuxSurf.Flags.Info.__PreWddm2SVM)>(*tokInfo);
8289                                                     } break;
8290                                                     };
8291                                                     tokInfo = tokInfo + 1 + tokInfo->valueDwordCount;
8292                                                 } else {
8293                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo);
8294                                                     if (tokInfo->flags.flag3IsMandatory) {
8295                                                         return false;
8296                                                     }
8297                                                     tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8298                                                 }
8299                                             }
8300                                             WCH_ASSERT(tokInfo == tokInfoEnd);
8301                                         } break;
8302                                         case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: {
8303                                             const TokenHeader *tokWa = varLen->getValue<TokenHeader>();
8304                                             const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8305                                             while (tokWa < tokWaEnd) {
8306                                                 if (false == tokWa->flags.flag4IsVariableLength) {
8307                                                     switch (tokWa->id) {
8308                                                     default:
8309                                                         if (tokWa->flags.flag3IsMandatory) {
8310                                                             return false;
8311                                                         }
8312                                                         break;
8313                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: {
8314                                                         dst.AuxSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.AuxSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa);
8315                                                     } break;
8316                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: {
8317                                                         dst.AuxSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.AuxSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa);
8318                                                     } break;
8319                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: {
8320                                                         dst.AuxSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.AuxSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa);
8321                                                     } break;
8322                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: {
8323                                                         dst.AuxSurf.Flags.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.AuxSurf.Flags.Wa.NoBufferSamplerPadding)>(*tokWa);
8324                                                     } break;
8325                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: {
8326                                                         dst.AuxSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.AuxSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa);
8327                                                     } break;
8328                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: {
8329                                                         dst.AuxSurf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.AuxSurf.Flags.Wa.CHVAstcSkipVirtualMips)>(*tokWa);
8330                                                     } break;
8331                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: {
8332                                                         dst.AuxSurf.Flags.Wa.DisablePackedMipTail = readTokValue<decltype(dst.AuxSurf.Flags.Wa.DisablePackedMipTail)>(*tokWa);
8333                                                     } break;
8334                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: {
8335                                                         dst.AuxSurf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.AuxSurf.Flags.Wa.__ForceOtherHVALIGN4)>(*tokWa);
8336                                                     } break;
8337                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: {
8338                                                         dst.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor)>(*tokWa);
8339                                                     } break;
8340                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: {
8341                                                         dst.AuxSurf.Flags.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.AuxSurf.Flags.Wa.DisableDisplayCcsCompression)>(*tokWa);
8342                                                     } break;
8343                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
8344                                                         dst.AuxSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.AuxSurf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa);
8345                                                     } break;
8346                                                     };
8347                                                     tokWa = tokWa + 1 + tokWa->valueDwordCount;
8348                                                 } else {
8349                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa);
8350                                                     if (tokWa->flags.flag3IsMandatory) {
8351                                                         return false;
8352                                                     }
8353                                                     tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8354                                                 }
8355                                             }
8356                                             WCH_ASSERT(tokWa == tokWaEnd);
8357                                         } break;
8358                                         };
8359                                         tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8360                                     }
8361                                 }
8362                                 WCH_ASSERT(tokFlags == tokFlagsEnd);
8363                             } break;
8364                             case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: {
8365                                 const TokenHeader *tokCachePolicy = varLen->getValue<TokenHeader>();
8366                                 const TokenHeader *tokCachePolicyEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8367                                 while (tokCachePolicy < tokCachePolicyEnd) {
8368                                     if (false == tokCachePolicy->flags.flag4IsVariableLength) {
8369                                         switch (tokCachePolicy->id) {
8370                                         default:
8371                                             if (tokCachePolicy->flags.flag3IsMandatory) {
8372                                                 return false;
8373                                             }
8374                                             break;
8375                                         case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: {
8376                                             dst.AuxSurf.CachePolicy.Usage = readTokValue<decltype(dst.AuxSurf.CachePolicy.Usage)>(*tokCachePolicy);
8377                                         } break;
8378                                         };
8379                                         tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount;
8380                                     } else {
8381                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCachePolicy);
8382                                         if (tokCachePolicy->flags.flag3IsMandatory) {
8383                                             return false;
8384                                         }
8385                                         tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8386                                     }
8387                                 }
8388                                 WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd);
8389                             } break;
8390                             case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: {
8391                                 const TokenHeader *tokMSAA = varLen->getValue<TokenHeader>();
8392                                 const TokenHeader *tokMSAAEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8393                                 while (tokMSAA < tokMSAAEnd) {
8394                                     if (false == tokMSAA->flags.flag4IsVariableLength) {
8395                                         switch (tokMSAA->id) {
8396                                         default:
8397                                             if (tokMSAA->flags.flag3IsMandatory) {
8398                                                 return false;
8399                                             }
8400                                             break;
8401                                         case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: {
8402                                             dst.AuxSurf.MSAA.SamplePattern = readTokValue<decltype(dst.AuxSurf.MSAA.SamplePattern)>(*tokMSAA);
8403                                         } break;
8404                                         case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: {
8405                                             dst.AuxSurf.MSAA.NumSamples = readTokValue<decltype(dst.AuxSurf.MSAA.NumSamples)>(*tokMSAA);
8406                                         } break;
8407                                         };
8408                                         tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount;
8409                                     } else {
8410                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMSAA);
8411                                         if (tokMSAA->flags.flag3IsMandatory) {
8412                                             return false;
8413                                         }
8414                                         tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8415                                     }
8416                                 }
8417                                 WCH_ASSERT(tokMSAA == tokMSAAEnd);
8418                             } break;
8419                             case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: {
8420                                 const TokenHeader *tokAlignment = varLen->getValue<TokenHeader>();
8421                                 const TokenHeader *tokAlignmentEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8422                                 while (tokAlignment < tokAlignmentEnd) {
8423                                     if (false == tokAlignment->flags.flag4IsVariableLength) {
8424                                         switch (tokAlignment->id) {
8425                                         default:
8426                                             if (tokAlignment->flags.flag3IsMandatory) {
8427                                                 return false;
8428                                             }
8429                                             break;
8430                                         case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: {
8431                                             dst.AuxSurf.Alignment.ArraySpacingSingleLod = readTokValue<decltype(dst.AuxSurf.Alignment.ArraySpacingSingleLod)>(*tokAlignment);
8432                                         } break;
8433                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: {
8434                                             dst.AuxSurf.Alignment.BaseAlignment = readTokValue<decltype(dst.AuxSurf.Alignment.BaseAlignment)>(*tokAlignment);
8435                                         } break;
8436                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: {
8437                                             dst.AuxSurf.Alignment.HAlign = readTokValue<decltype(dst.AuxSurf.Alignment.HAlign)>(*tokAlignment);
8438                                         } break;
8439                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: {
8440                                             dst.AuxSurf.Alignment.VAlign = readTokValue<decltype(dst.AuxSurf.Alignment.VAlign)>(*tokAlignment);
8441                                         } break;
8442                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: {
8443                                             dst.AuxSurf.Alignment.DAlign = readTokValue<decltype(dst.AuxSurf.Alignment.DAlign)>(*tokAlignment);
8444                                         } break;
8445                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: {
8446                                             dst.AuxSurf.Alignment.MipTailStartLod = readTokValue<decltype(dst.AuxSurf.Alignment.MipTailStartLod)>(*tokAlignment);
8447                                         } break;
8448                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: {
8449                                             dst.AuxSurf.Alignment.PackedMipStartLod = readTokValue<decltype(dst.AuxSurf.Alignment.PackedMipStartLod)>(*tokAlignment);
8450                                         } break;
8451                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: {
8452                                             dst.AuxSurf.Alignment.PackedMipWidth = readTokValue<decltype(dst.AuxSurf.Alignment.PackedMipWidth)>(*tokAlignment);
8453                                         } break;
8454                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: {
8455                                             dst.AuxSurf.Alignment.PackedMipHeight = readTokValue<decltype(dst.AuxSurf.Alignment.PackedMipHeight)>(*tokAlignment);
8456                                         } break;
8457                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: {
8458                                             dst.AuxSurf.Alignment.QPitch = readTokValue<decltype(dst.AuxSurf.Alignment.QPitch)>(*tokAlignment);
8459                                         } break;
8460                                         };
8461                                         tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount;
8462                                     } else {
8463                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAlignment);
8464                                         if (tokAlignment->flags.flag3IsMandatory) {
8465                                             return false;
8466                                         }
8467                                         tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8468                                     }
8469                                 }
8470                                 WCH_ASSERT(tokAlignment == tokAlignmentEnd);
8471                             } break;
8472                             case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: {
8473                                 const TokenHeader *tokOffsetInfo = varLen->getValue<TokenHeader>();
8474                                 const TokenHeader *tokOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8475                                 while (tokOffsetInfo < tokOffsetInfoEnd) {
8476                                     if (false == tokOffsetInfo->flags.flag4IsVariableLength) {
8477                                         if (tokOffsetInfo->flags.flag3IsMandatory) {
8478                                             return false;
8479                                         }
8480                                         tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount;
8481                                     } else {
8482                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOffsetInfo);
8483                                         switch (tokOffsetInfo->id) {
8484                                         default:
8485                                             if (tokOffsetInfo->flags.flag3IsMandatory) {
8486                                                 return false;
8487                                             }
8488                                             break;
8489                                         case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: {
8490                                             const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>();
8491                                             const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8492                                             while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) {
8493                                                 if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) {
8494                                                     switch (tokTexture3DOffsetInfo->id) {
8495                                                     default:
8496                                                         if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
8497                                                             return false;
8498                                                         }
8499                                                         break;
8500                                                     case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: {
8501                                                         dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo);
8502                                                     } break;
8503                                                     case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
8504                                                         auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>();
8505                                                         auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes();
8506                                                         if (srcSize < sizeof(dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset)) {
8507                                                             return false;
8508                                                         }
8509                                                         WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset));
8510                                                     } break;
8511                                                     };
8512                                                     tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount;
8513                                                 } else {
8514                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo);
8515                                                     if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
8516                                                         return false;
8517                                                     }
8518                                                     tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8519                                                 }
8520                                             }
8521                                             WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd);
8522                                         } break;
8523                                         case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: {
8524                                             const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>();
8525                                             const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8526                                             while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) {
8527                                                 if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) {
8528                                                     switch (tokTexture2DOffsetInfo->id) {
8529                                                     default:
8530                                                         if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
8531                                                             return false;
8532                                                         }
8533                                                         break;
8534                                                     case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: {
8535                                                         dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo);
8536                                                     } break;
8537                                                     case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: {
8538                                                         dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo);
8539                                                     } break;
8540                                                     case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
8541                                                         auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>();
8542                                                         auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes();
8543                                                         if (srcSize < sizeof(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset)) {
8544                                                             return false;
8545                                                         }
8546                                                         WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset));
8547                                                     } break;
8548                                                     };
8549                                                     tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount;
8550                                                 } else {
8551                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo);
8552                                                     if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
8553                                                         return false;
8554                                                     }
8555                                                     tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8556                                                 }
8557                                             }
8558                                             WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd);
8559                                         } break;
8560                                         case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: {
8561                                             const TokenHeader *tokPlane = varLen->getValue<TokenHeader>();
8562                                             const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8563                                             while (tokPlane < tokPlaneEnd) {
8564                                                 if (false == tokPlane->flags.flag4IsVariableLength) {
8565                                                     switch (tokPlane->id) {
8566                                                     default:
8567                                                         if (tokPlane->flags.flag3IsMandatory) {
8568                                                             return false;
8569                                                         }
8570                                                         break;
8571                                                     case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: {
8572                                                         dst.AuxSurf.OffsetInfo.Plane.ArrayQPitch = readTokValue<decltype(dst.AuxSurf.OffsetInfo.Plane.ArrayQPitch)>(*tokPlane);
8573                                                     } break;
8574                                                     case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: {
8575                                                         auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
8576                                                         auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
8577                                                         if (srcSize < sizeof(dst.AuxSurf.OffsetInfo.Plane.X)) {
8578                                                             return false;
8579                                                         }
8580                                                         WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Plane.X, sizeof(dst.AuxSurf.OffsetInfo.Plane.X), srcData, sizeof(dst.AuxSurf.OffsetInfo.Plane.X));
8581                                                     } break;
8582                                                     case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: {
8583                                                         auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
8584                                                         auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
8585                                                         if (srcSize < sizeof(dst.AuxSurf.OffsetInfo.Plane.Y)) {
8586                                                             return false;
8587                                                         }
8588                                                         WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Plane.Y, sizeof(dst.AuxSurf.OffsetInfo.Plane.Y), srcData, sizeof(dst.AuxSurf.OffsetInfo.Plane.Y));
8589                                                     } break;
8590                                                     case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: {
8591                                                         dst.AuxSurf.OffsetInfo.Plane.NoOfPlanes = readTokValue<decltype(dst.AuxSurf.OffsetInfo.Plane.NoOfPlanes)>(*tokPlane);
8592                                                     } break;
8593                                                     case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: {
8594                                                         dst.AuxSurf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.AuxSurf.OffsetInfo.Plane.IsTileAlignedPlanes)>(*tokPlane);
8595                                                     } break;
8596                                                     };
8597                                                     tokPlane = tokPlane + 1 + tokPlane->valueDwordCount;
8598                                                 } else {
8599                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane);
8600                                                     switch (tokPlane->id) {
8601                                                     default:
8602                                                         if (tokPlane->flags.flag3IsMandatory) {
8603                                                             return false;
8604                                                         }
8605                                                         break;
8606                                                     case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: {
8607                                                         const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>();
8608                                                         const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8609                                                         while (tokUnAligned < tokUnAlignedEnd) {
8610                                                             if (false == tokUnAligned->flags.flag4IsVariableLength) {
8611                                                                 switch (tokUnAligned->id) {
8612                                                                 default:
8613                                                                     if (tokUnAligned->flags.flag3IsMandatory) {
8614                                                                         return false;
8615                                                                     }
8616                                                                     break;
8617                                                                 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: {
8618                                                                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>();
8619                                                                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes();
8620                                                                     if (srcSize < sizeof(dst.AuxSurf.OffsetInfo.Plane.UnAligned.Height)) {
8621                                                                         return false;
8622                                                                     }
8623                                                                     WCH_SAFE_COPY(dst.AuxSurf.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.AuxSurf.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.AuxSurf.OffsetInfo.Plane.UnAligned.Height));
8624                                                                 } break;
8625                                                                 };
8626                                                                 tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount;
8627                                                             } else {
8628                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned);
8629                                                                 if (tokUnAligned->flags.flag3IsMandatory) {
8630                                                                     return false;
8631                                                                 }
8632                                                                 tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8633                                                             }
8634                                                         }
8635                                                         WCH_ASSERT(tokUnAligned == tokUnAlignedEnd);
8636                                                     } break;
8637                                                     };
8638                                                     tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8639                                                 }
8640                                             }
8641                                             WCH_ASSERT(tokPlane == tokPlaneEnd);
8642                                         } break;
8643                                         };
8644                                         tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8645                                     }
8646                                 }
8647                                 WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd);
8648                             } break;
8649                             case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: {
8650                                 const TokenHeader *tokS3d = varLen->getValue<TokenHeader>();
8651                                 const TokenHeader *tokS3dEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8652                                 while (tokS3d < tokS3dEnd) {
8653                                     if (false == tokS3d->flags.flag4IsVariableLength) {
8654                                         switch (tokS3d->id) {
8655                                         default:
8656                                             if (tokS3d->flags.flag3IsMandatory) {
8657                                                 return false;
8658                                             }
8659                                             break;
8660                                         case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: {
8661                                             dst.AuxSurf.S3d.DisplayModeHeight = readTokValue<decltype(dst.AuxSurf.S3d.DisplayModeHeight)>(*tokS3d);
8662                                         } break;
8663                                         case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: {
8664                                             dst.AuxSurf.S3d.NumBlankActiveLines = readTokValue<decltype(dst.AuxSurf.S3d.NumBlankActiveLines)>(*tokS3d);
8665                                         } break;
8666                                         case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: {
8667                                             dst.AuxSurf.S3d.RFrameOffset = readTokValue<decltype(dst.AuxSurf.S3d.RFrameOffset)>(*tokS3d);
8668                                         } break;
8669                                         case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: {
8670                                             dst.AuxSurf.S3d.BlankAreaOffset = readTokValue<decltype(dst.AuxSurf.S3d.BlankAreaOffset)>(*tokS3d);
8671                                         } break;
8672                                         case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: {
8673                                             dst.AuxSurf.S3d.TallBufferHeight = readTokValue<decltype(dst.AuxSurf.S3d.TallBufferHeight)>(*tokS3d);
8674                                         } break;
8675                                         case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: {
8676                                             dst.AuxSurf.S3d.TallBufferSize = readTokValue<decltype(dst.AuxSurf.S3d.TallBufferSize)>(*tokS3d);
8677                                         } break;
8678                                         case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: {
8679                                             dst.AuxSurf.S3d.IsRFrame = readTokValue<decltype(dst.AuxSurf.S3d.IsRFrame)>(*tokS3d);
8680                                         } break;
8681                                         };
8682                                         tokS3d = tokS3d + 1 + tokS3d->valueDwordCount;
8683                                     } else {
8684                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokS3d);
8685                                         if (tokS3d->flags.flag3IsMandatory) {
8686                                             return false;
8687                                         }
8688                                         tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8689                                     }
8690                                 }
8691                                 WCH_ASSERT(tokS3d == tokS3dEnd);
8692                             } break;
8693                             case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: {
8694                                 const TokenHeader *tokSegmentOverride = varLen->getValue<TokenHeader>();
8695                                 const TokenHeader *tokSegmentOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8696                                 while (tokSegmentOverride < tokSegmentOverrideEnd) {
8697                                     if (false == tokSegmentOverride->flags.flag4IsVariableLength) {
8698                                         switch (tokSegmentOverride->id) {
8699                                         default:
8700                                             if (tokSegmentOverride->flags.flag3IsMandatory) {
8701                                                 return false;
8702                                             }
8703                                             break;
8704                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: {
8705                                             dst.AuxSurf.SegmentOverride.Seg1 = readTokValue<decltype(dst.AuxSurf.SegmentOverride.Seg1)>(*tokSegmentOverride);
8706                                         } break;
8707                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: {
8708                                             dst.AuxSurf.SegmentOverride.Evict = readTokValue<decltype(dst.AuxSurf.SegmentOverride.Evict)>(*tokSegmentOverride);
8709                                         } break;
8710                                         };
8711                                         tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount;
8712                                     } else {
8713                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSegmentOverride);
8714                                         if (tokSegmentOverride->flags.flag3IsMandatory) {
8715                                             return false;
8716                                         }
8717                                         tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8718                                     }
8719                                 }
8720                                 WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd);
8721                             } break;
8722                             case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: {
8723 #if _DEBUG || _RELEASE_INTERNAL
8724                                 const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>();
8725                                 const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8726                                 while (tokPlatform < tokPlatformEnd) {
8727                                     if (false == tokPlatform->flags.flag4IsVariableLength) {
8728                                         switch (tokPlatform->id) {
8729                                         default:
8730                                             if (tokPlatform->flags.flag3IsMandatory) {
8731                                                 return false;
8732                                             }
8733                                             break;
8734                                         case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
8735                                             dst.AuxSurf.Platform.eProductFamily = readTokValue<decltype(dst.AuxSurf.Platform.eProductFamily)>(*tokPlatform);
8736                                         } break;
8737                                         case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
8738                                             dst.AuxSurf.Platform.ePCHProductFamily = readTokValue<decltype(dst.AuxSurf.Platform.ePCHProductFamily)>(*tokPlatform);
8739                                         } break;
8740                                         case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
8741                                             dst.AuxSurf.Platform.eDisplayCoreFamily = readTokValue<decltype(dst.AuxSurf.Platform.eDisplayCoreFamily)>(*tokPlatform);
8742                                         } break;
8743                                         case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
8744                                             dst.AuxSurf.Platform.eRenderCoreFamily = readTokValue<decltype(dst.AuxSurf.Platform.eRenderCoreFamily)>(*tokPlatform);
8745                                         } break;
8746                                         case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
8747                                             dst.AuxSurf.Platform.ePlatformType = readTokValue<decltype(dst.AuxSurf.Platform.ePlatformType)>(*tokPlatform);
8748                                         } break;
8749                                         case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
8750                                             dst.AuxSurf.Platform.usDeviceID = readTokValue<decltype(dst.AuxSurf.Platform.usDeviceID)>(*tokPlatform);
8751                                         } break;
8752                                         case TOK_FBW_PLATFORM_STR__US_REV_ID: {
8753                                             dst.AuxSurf.Platform.usRevId = readTokValue<decltype(dst.AuxSurf.Platform.usRevId)>(*tokPlatform);
8754                                         } break;
8755                                         case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
8756                                             dst.AuxSurf.Platform.usDeviceID_PCH = readTokValue<decltype(dst.AuxSurf.Platform.usDeviceID_PCH)>(*tokPlatform);
8757                                         } break;
8758                                         case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
8759                                             dst.AuxSurf.Platform.usRevId_PCH = readTokValue<decltype(dst.AuxSurf.Platform.usRevId_PCH)>(*tokPlatform);
8760                                         } break;
8761                                         case TOK_FE_PLATFORM_STR__E_GTTYPE: {
8762                                             dst.AuxSurf.Platform.eGTType = readTokValue<decltype(dst.AuxSurf.Platform.eGTType)>(*tokPlatform);
8763                                         } break;
8764                                         };
8765                                         tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount;
8766                                     } else {
8767                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform);
8768                                         if (tokPlatform->flags.flag3IsMandatory) {
8769                                             return false;
8770                                         }
8771                                         tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8772                                     }
8773                                 }
8774                                 WCH_ASSERT(tokPlatform == tokPlatformEnd);
8775 #endif
8776                             } break;
8777                             case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: {
8778                                 const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>();
8779                                 const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8780                                 while (tokExistingSysMem < tokExistingSysMemEnd) {
8781                                     if (false == tokExistingSysMem->flags.flag4IsVariableLength) {
8782                                         switch (tokExistingSysMem->id) {
8783                                         default:
8784                                             if (tokExistingSysMem->flags.flag3IsMandatory) {
8785                                                 return false;
8786                                             }
8787                                             break;
8788                                         case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: {
8789                                             dst.AuxSurf.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.AuxSurf.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem);
8790                                         } break;
8791                                         case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: {
8792                                             dst.AuxSurf.ExistingSysMem.IsPageAligned = readTokValue<decltype(dst.AuxSurf.ExistingSysMem.IsPageAligned)>(*tokExistingSysMem);
8793                                         } break;
8794                                         };
8795                                         tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount;
8796                                     } else {
8797                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem);
8798                                         if (tokExistingSysMem->flags.flag3IsMandatory) {
8799                                             return false;
8800                                         }
8801                                         tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8802                                     }
8803                                 }
8804                                 WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd);
8805                             } break;
8806                             case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: {
8807 #if !(_DEBUG || _RELEASE_INTERNAL)
8808                                 const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>();
8809                                 const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8810                                 while (tok__Platform < tok__PlatformEnd) {
8811                                     if (false == tok__Platform->flags.flag4IsVariableLength) {
8812                                         switch (tok__Platform->id) {
8813                                         default:
8814                                             if (tok__Platform->flags.flag3IsMandatory) {
8815                                                 return false;
8816                                             }
8817                                             break;
8818                                         case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
8819                                             dst.AuxSurf.__Platform.eProductFamily = readTokValue<decltype(dst.AuxSurf.__Platform.eProductFamily)>(*tok__Platform);
8820                                         } break;
8821                                         case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
8822                                             dst.AuxSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.AuxSurf.__Platform.ePCHProductFamily)>(*tok__Platform);
8823                                         } break;
8824                                         case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
8825                                             dst.AuxSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.AuxSurf.__Platform.eDisplayCoreFamily)>(*tok__Platform);
8826                                         } break;
8827                                         case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
8828                                             dst.AuxSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.AuxSurf.__Platform.eRenderCoreFamily)>(*tok__Platform);
8829                                         } break;
8830                                         case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
8831                                             dst.AuxSurf.__Platform.ePlatformType = readTokValue<decltype(dst.AuxSurf.__Platform.ePlatformType)>(*tok__Platform);
8832                                         } break;
8833                                         case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
8834                                             dst.AuxSurf.__Platform.usDeviceID = readTokValue<decltype(dst.AuxSurf.__Platform.usDeviceID)>(*tok__Platform);
8835                                         } break;
8836                                         case TOK_FBW_PLATFORM_STR__US_REV_ID: {
8837                                             dst.AuxSurf.__Platform.usRevId = readTokValue<decltype(dst.AuxSurf.__Platform.usRevId)>(*tok__Platform);
8838                                         } break;
8839                                         case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
8840                                             dst.AuxSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.AuxSurf.__Platform.usDeviceID_PCH)>(*tok__Platform);
8841                                         } break;
8842                                         case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
8843                                             dst.AuxSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.AuxSurf.__Platform.usRevId_PCH)>(*tok__Platform);
8844                                         } break;
8845                                         case TOK_FE_PLATFORM_STR__E_GTTYPE: {
8846                                             dst.AuxSurf.__Platform.eGTType = readTokValue<decltype(dst.AuxSurf.__Platform.eGTType)>(*tok__Platform);
8847                                         } break;
8848                                         };
8849                                         tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount;
8850                                     } else {
8851                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform);
8852                                         if (tok__Platform->flags.flag3IsMandatory) {
8853                                             return false;
8854                                         }
8855                                         tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8856                                     }
8857                                 }
8858                                 WCH_ASSERT(tok__Platform == tok__PlatformEnd);
8859 #endif
8860                             } break;
8861                             };
8862                             tokAuxSurf = tokAuxSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
8863                         }
8864                     }
8865                     WCH_ASSERT(tokAuxSurf == tokAuxSurfEnd);
8866                 } break;
8867                 case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SEC_SURF: {
8868                     const TokenHeader *tokAuxSecSurf = varLen->getValue<TokenHeader>();
8869                     const TokenHeader *tokAuxSecSurfEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8870                     while (tokAuxSecSurf < tokAuxSecSurfEnd) {
8871                         if (false == tokAuxSecSurf->flags.flag4IsVariableLength) {
8872                             switch (tokAuxSecSurf->id) {
8873                             default:
8874                                 if (tokAuxSecSurf->flags.flag3IsMandatory) {
8875                                     return false;
8876                                 }
8877                                 break;
8878                             case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: {
8879                                 dst.AuxSecSurf.Type = readTokValue<decltype(dst.AuxSecSurf.Type)>(*tokAuxSecSurf);
8880                             } break;
8881                             case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: {
8882                                 dst.AuxSecSurf.Format = readTokValue<decltype(dst.AuxSecSurf.Format)>(*tokAuxSecSurf);
8883                             } break;
8884                             case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: {
8885                                 dst.AuxSecSurf.BitsPerPixel = readTokValue<decltype(dst.AuxSecSurf.BitsPerPixel)>(*tokAuxSecSurf);
8886                             } break;
8887                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: {
8888                                 dst.AuxSecSurf.BaseWidth = readTokValue<decltype(dst.AuxSecSurf.BaseWidth)>(*tokAuxSecSurf);
8889                             } break;
8890                             case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: {
8891                                 dst.AuxSecSurf.BaseHeight = readTokValue<decltype(dst.AuxSecSurf.BaseHeight)>(*tokAuxSecSurf);
8892                             } break;
8893                             case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: {
8894                                 dst.AuxSecSurf.Depth = readTokValue<decltype(dst.AuxSecSurf.Depth)>(*tokAuxSecSurf);
8895                             } break;
8896                             case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: {
8897                                 dst.AuxSecSurf.MaxLod = readTokValue<decltype(dst.AuxSecSurf.MaxLod)>(*tokAuxSecSurf);
8898                             } break;
8899                             case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: {
8900                                 dst.AuxSecSurf.ArraySize = readTokValue<decltype(dst.AuxSecSurf.ArraySize)>(*tokAuxSecSurf);
8901                             } break;
8902                             case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: {
8903                                 dst.AuxSecSurf.CpTag = readTokValue<decltype(dst.AuxSecSurf.CpTag)>(*tokAuxSecSurf);
8904                             } break;
8905                             case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: {
8906                                 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValue<char>();
8907                                 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValueSizeInBytes();
8908                                 if (srcSize < sizeof(dst.AuxSecSurf.MmcMode)) {
8909                                     return false;
8910                                 }
8911                                 WCH_SAFE_COPY(dst.AuxSecSurf.MmcMode, sizeof(dst.AuxSecSurf.MmcMode), srcData, sizeof(dst.AuxSecSurf.MmcMode));
8912                             } break;
8913                             case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: {
8914                                 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValue<char>();
8915                                 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValueSizeInBytes();
8916                                 if (srcSize < sizeof(dst.AuxSecSurf.MmcHint)) {
8917                                     return false;
8918                                 }
8919                                 WCH_SAFE_COPY(dst.AuxSecSurf.MmcHint, sizeof(dst.AuxSecSurf.MmcHint), srcData, sizeof(dst.AuxSecSurf.MmcHint));
8920                             } break;
8921                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: {
8922                                 dst.AuxSecSurf.Pitch = readTokValue<decltype(dst.AuxSecSurf.Pitch)>(*tokAuxSecSurf);
8923                             } break;
8924                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: {
8925                                 dst.AuxSecSurf.OverridePitch = readTokValue<decltype(dst.AuxSecSurf.OverridePitch)>(*tokAuxSecSurf);
8926                             } break;
8927                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: {
8928                                 dst.AuxSecSurf.Size = readTokValue<decltype(dst.AuxSecSurf.Size)>(*tokAuxSecSurf);
8929                             } break;
8930                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: {
8931                                 dst.AuxSecSurf.CCSize = readTokValue<decltype(dst.AuxSecSurf.CCSize)>(*tokAuxSecSurf);
8932                             } break;
8933                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: {
8934                                 dst.AuxSecSurf.UnpaddedSize = readTokValue<decltype(dst.AuxSecSurf.UnpaddedSize)>(*tokAuxSecSurf);
8935                             } break;
8936                             case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: {
8937                                 dst.AuxSecSurf.SizeReportToOS = readTokValue<decltype(dst.AuxSecSurf.SizeReportToOS)>(*tokAuxSecSurf);
8938                             } break;
8939                             case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: {
8940                                 dst.AuxSecSurf.TileMode = readTokValue<decltype(dst.AuxSecSurf.TileMode)>(*tokAuxSecSurf);
8941                             } break;
8942                             case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: {
8943                                 dst.AuxSecSurf.CCSModeAlign = readTokValue<decltype(dst.AuxSecSurf.CCSModeAlign)>(*tokAuxSecSurf);
8944                             } break;
8945                             case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: {
8946                                 dst.AuxSecSurf.LegacyFlags = readTokValue<decltype(dst.AuxSecSurf.LegacyFlags)>(*tokAuxSecSurf);
8947                             } break;
8948                             case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: {
8949                                 dst.AuxSecSurf.MaximumRenamingListLength = readTokValue<decltype(dst.AuxSecSurf.MaximumRenamingListLength)>(*tokAuxSecSurf);
8950                             } break;
8951                             };
8952                             tokAuxSecSurf = tokAuxSecSurf + 1 + tokAuxSecSurf->valueDwordCount;
8953                         } else {
8954                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAuxSecSurf);
8955                             switch (tokAuxSecSurf->id) {
8956                             default:
8957                                 if (tokAuxSecSurf->flags.flag3IsMandatory) {
8958                                     return false;
8959                                 }
8960                                 break;
8961                             case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: {
8962                                 const TokenHeader *tokFlags = varLen->getValue<TokenHeader>();
8963                                 const TokenHeader *tokFlagsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8964                                 while (tokFlags < tokFlagsEnd) {
8965                                     if (false == tokFlags->flags.flag4IsVariableLength) {
8966                                         if (tokFlags->flags.flag3IsMandatory) {
8967                                             return false;
8968                                         }
8969                                         tokFlags = tokFlags + 1 + tokFlags->valueDwordCount;
8970                                     } else {
8971                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokFlags);
8972                                         switch (tokFlags->id) {
8973                                         default:
8974                                             if (tokFlags->flags.flag3IsMandatory) {
8975                                                 return false;
8976                                             }
8977                                             break;
8978                                         case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: {
8979                                             const TokenHeader *tokGpu = varLen->getValue<TokenHeader>();
8980                                             const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
8981                                             while (tokGpu < tokGpuEnd) {
8982                                                 if (false == tokGpu->flags.flag4IsVariableLength) {
8983                                                     switch (tokGpu->id) {
8984                                                     default:
8985                                                         if (tokGpu->flags.flag3IsMandatory) {
8986                                                             return false;
8987                                                         }
8988                                                         break;
8989                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: {
8990                                                         dst.AuxSecSurf.Flags.Gpu.CameraCapture = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.CameraCapture)>(*tokGpu);
8991                                                     } break;
8992                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: {
8993                                                         dst.AuxSecSurf.Flags.Gpu.CCS = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.CCS)>(*tokGpu);
8994                                                     } break;
8995                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: {
8996                                                         dst.AuxSecSurf.Flags.Gpu.ColorDiscard = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.ColorDiscard)>(*tokGpu);
8997                                                     } break;
8998                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: {
8999                                                         dst.AuxSecSurf.Flags.Gpu.ColorSeparation = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.ColorSeparation)>(*tokGpu);
9000                                                     } break;
9001                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: {
9002                                                         dst.AuxSecSurf.Flags.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.ColorSeparationRGBX)>(*tokGpu);
9003                                                     } break;
9004                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: {
9005                                                         dst.AuxSecSurf.Flags.Gpu.Constant = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Constant)>(*tokGpu);
9006                                                     } break;
9007                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: {
9008                                                         dst.AuxSecSurf.Flags.Gpu.Depth = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Depth)>(*tokGpu);
9009                                                     } break;
9010                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: {
9011                                                         dst.AuxSecSurf.Flags.Gpu.FlipChain = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.FlipChain)>(*tokGpu);
9012                                                     } break;
9013                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: {
9014                                                         dst.AuxSecSurf.Flags.Gpu.FlipChainPreferred = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.FlipChainPreferred)>(*tokGpu);
9015                                                     } break;
9016                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: {
9017                                                         dst.AuxSecSurf.Flags.Gpu.HistoryBuffer = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.HistoryBuffer)>(*tokGpu);
9018                                                     } break;
9019                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: {
9020                                                         dst.AuxSecSurf.Flags.Gpu.HiZ = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.HiZ)>(*tokGpu);
9021                                                     } break;
9022                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: {
9023                                                         dst.AuxSecSurf.Flags.Gpu.Index = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Index)>(*tokGpu);
9024                                                     } break;
9025                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: {
9026                                                         dst.AuxSecSurf.Flags.Gpu.IndirectClearColor = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.IndirectClearColor)>(*tokGpu);
9027                                                     } break;
9028                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: {
9029                                                         dst.AuxSecSurf.Flags.Gpu.InstructionFlat = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.InstructionFlat)>(*tokGpu);
9030                                                     } break;
9031                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: {
9032                                                         dst.AuxSecSurf.Flags.Gpu.InterlacedScan = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.InterlacedScan)>(*tokGpu);
9033                                                     } break;
9034                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: {
9035                                                         dst.AuxSecSurf.Flags.Gpu.MCS = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.MCS)>(*tokGpu);
9036                                                     } break;
9037                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: {
9038                                                         dst.AuxSecSurf.Flags.Gpu.MMC = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.MMC)>(*tokGpu);
9039                                                     } break;
9040                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: {
9041                                                         dst.AuxSecSurf.Flags.Gpu.MotionComp = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.MotionComp)>(*tokGpu);
9042                                                     } break;
9043                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: {
9044                                                         dst.AuxSecSurf.Flags.Gpu.NoRestriction = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.NoRestriction)>(*tokGpu);
9045                                                     } break;
9046                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: {
9047                                                         dst.AuxSecSurf.Flags.Gpu.Overlay = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Overlay)>(*tokGpu);
9048                                                     } break;
9049                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: {
9050                                                         dst.AuxSecSurf.Flags.Gpu.Presentable = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Presentable)>(*tokGpu);
9051                                                     } break;
9052                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: {
9053                                                         dst.AuxSecSurf.Flags.Gpu.ProceduralTexture = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.ProceduralTexture)>(*tokGpu);
9054                                                     } break;
9055                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: {
9056                                                         dst.AuxSecSurf.Flags.Gpu.Query = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Query)>(*tokGpu);
9057                                                     } break;
9058                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: {
9059                                                         dst.AuxSecSurf.Flags.Gpu.RenderTarget = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.RenderTarget)>(*tokGpu);
9060                                                     } break;
9061                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: {
9062                                                         dst.AuxSecSurf.Flags.Gpu.S3d = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.S3d)>(*tokGpu);
9063                                                     } break;
9064                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: {
9065                                                         dst.AuxSecSurf.Flags.Gpu.S3dDx = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.S3dDx)>(*tokGpu);
9066                                                     } break;
9067                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: {
9068                                                         dst.AuxSecSurf.Flags.Gpu.__S3dNonPacked = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.__S3dNonPacked)>(*tokGpu);
9069                                                     } break;
9070                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: {
9071                                                         dst.AuxSecSurf.Flags.Gpu.__S3dWidi = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.__S3dWidi)>(*tokGpu);
9072                                                     } break;
9073                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: {
9074                                                         dst.AuxSecSurf.Flags.Gpu.ScratchFlat = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.ScratchFlat)>(*tokGpu);
9075                                                     } break;
9076                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: {
9077                                                         dst.AuxSecSurf.Flags.Gpu.SeparateStencil = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.SeparateStencil)>(*tokGpu);
9078                                                     } break;
9079                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: {
9080                                                         dst.AuxSecSurf.Flags.Gpu.State = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.State)>(*tokGpu);
9081                                                     } break;
9082                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: {
9083                                                         dst.AuxSecSurf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.StateDx9ConstantBuffer)>(*tokGpu);
9084                                                     } break;
9085                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: {
9086                                                         dst.AuxSecSurf.Flags.Gpu.Stream = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Stream)>(*tokGpu);
9087                                                     } break;
9088                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: {
9089                                                         dst.AuxSecSurf.Flags.Gpu.TextApi = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.TextApi)>(*tokGpu);
9090                                                     } break;
9091                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: {
9092                                                         dst.AuxSecSurf.Flags.Gpu.Texture = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Texture)>(*tokGpu);
9093                                                     } break;
9094                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: {
9095                                                         dst.AuxSecSurf.Flags.Gpu.TiledResource = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.TiledResource)>(*tokGpu);
9096                                                     } break;
9097                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: {
9098                                                         dst.AuxSecSurf.Flags.Gpu.TilePool = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.TilePool)>(*tokGpu);
9099                                                     } break;
9100                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: {
9101                                                         dst.AuxSecSurf.Flags.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.UnifiedAuxSurface)>(*tokGpu);
9102                                                     } break;
9103                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: {
9104                                                         dst.AuxSecSurf.Flags.Gpu.Vertex = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Vertex)>(*tokGpu);
9105                                                     } break;
9106                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: {
9107                                                         dst.AuxSecSurf.Flags.Gpu.Video = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.Video)>(*tokGpu);
9108                                                     } break;
9109                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: {
9110                                                         dst.AuxSecSurf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.__NonMsaaTileXCcs)>(*tokGpu);
9111                                                     } break;
9112                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: {
9113                                                         dst.AuxSecSurf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.__NonMsaaTileYCcs)>(*tokGpu);
9114                                                     } break;
9115                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: {
9116                                                         dst.AuxSecSurf.Flags.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.__MsaaTileMcs)>(*tokGpu);
9117                                                     } break;
9118                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: {
9119                                                         dst.AuxSecSurf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.__NonMsaaLinearCCS)>(*tokGpu);
9120                                                     } break;
9121                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: {
9122                                                         dst.AuxSecSurf.Flags.Gpu.__Remaining = readTokValue<decltype(dst.AuxSecSurf.Flags.Gpu.__Remaining)>(*tokGpu);
9123                                                     } break;
9124                                                     };
9125                                                     tokGpu = tokGpu + 1 + tokGpu->valueDwordCount;
9126                                                 } else {
9127                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu);
9128                                                     if (tokGpu->flags.flag3IsMandatory) {
9129                                                         return false;
9130                                                     }
9131                                                     tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9132                                                 }
9133                                             }
9134                                             WCH_ASSERT(tokGpu == tokGpuEnd);
9135                                         } break;
9136                                         case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: {
9137                                             const TokenHeader *tokInfo = varLen->getValue<TokenHeader>();
9138                                             const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9139                                             while (tokInfo < tokInfoEnd) {
9140                                                 if (false == tokInfo->flags.flag4IsVariableLength) {
9141                                                     switch (tokInfo->id) {
9142                                                     default:
9143                                                         if (tokInfo->flags.flag3IsMandatory) {
9144                                                             return false;
9145                                                         }
9146                                                         break;
9147                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: {
9148                                                         dst.AuxSecSurf.Flags.Info.AllowVirtualPadding = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.AllowVirtualPadding)>(*tokInfo);
9149                                                     } break;
9150                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: {
9151                                                         dst.AuxSecSurf.Flags.Info.BigPage = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.BigPage)>(*tokInfo);
9152                                                     } break;
9153                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: {
9154                                                         dst.AuxSecSurf.Flags.Info.Cacheable = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Cacheable)>(*tokInfo);
9155                                                     } break;
9156                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: {
9157                                                         dst.AuxSecSurf.Flags.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.ContigPhysMemoryForiDART)>(*tokInfo);
9158                                                     } break;
9159                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: {
9160                                                         dst.AuxSecSurf.Flags.Info.CornerTexelMode = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.CornerTexelMode)>(*tokInfo);
9161                                                     } break;
9162                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: {
9163                                                         dst.AuxSecSurf.Flags.Info.ExistingSysMem = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.ExistingSysMem)>(*tokInfo);
9164                                                     } break;
9165                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: {
9166                                                         dst.AuxSecSurf.Flags.Info.ForceResidency = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.ForceResidency)>(*tokInfo);
9167                                                     } break;
9168                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: {
9169                                                         dst.AuxSecSurf.Flags.Info.Gfdt = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Gfdt)>(*tokInfo);
9170                                                     } break;
9171                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: {
9172                                                         dst.AuxSecSurf.Flags.Info.GttMapType = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.GttMapType)>(*tokInfo);
9173                                                     } break;
9174                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: {
9175                                                         dst.AuxSecSurf.Flags.Info.HardwareProtected = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.HardwareProtected)>(*tokInfo);
9176                                                     } break;
9177                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: {
9178                                                         dst.AuxSecSurf.Flags.Info.KernelModeMapped = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.KernelModeMapped)>(*tokInfo);
9179                                                     } break;
9180                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: {
9181                                                         dst.AuxSecSurf.Flags.Info.LayoutBelow = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.LayoutBelow)>(*tokInfo);
9182                                                     } break;
9183                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: {
9184                                                         dst.AuxSecSurf.Flags.Info.LayoutMono = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.LayoutMono)>(*tokInfo);
9185                                                     } break;
9186                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: {
9187                                                         dst.AuxSecSurf.Flags.Info.LayoutRight = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.LayoutRight)>(*tokInfo);
9188                                                     } break;
9189                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: {
9190                                                         dst.AuxSecSurf.Flags.Info.LocalOnly = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.LocalOnly)>(*tokInfo);
9191                                                     } break;
9192                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: {
9193                                                         dst.AuxSecSurf.Flags.Info.Linear = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Linear)>(*tokInfo);
9194                                                     } break;
9195                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: {
9196                                                         dst.AuxSecSurf.Flags.Info.MediaCompressed = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.MediaCompressed)>(*tokInfo);
9197                                                     } break;
9198                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: {
9199                                                         dst.AuxSecSurf.Flags.Info.NoOptimizationPadding = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.NoOptimizationPadding)>(*tokInfo);
9200                                                     } break;
9201                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: {
9202                                                         dst.AuxSecSurf.Flags.Info.NoPhysMemory = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.NoPhysMemory)>(*tokInfo);
9203                                                     } break;
9204                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: {
9205                                                         dst.AuxSecSurf.Flags.Info.NotLockable = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.NotLockable)>(*tokInfo);
9206                                                     } break;
9207                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: {
9208                                                         dst.AuxSecSurf.Flags.Info.NonLocalOnly = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.NonLocalOnly)>(*tokInfo);
9209                                                     } break;
9210                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: {
9211                                                         dst.AuxSecSurf.Flags.Info.StdSwizzle = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.StdSwizzle)>(*tokInfo);
9212                                                     } break;
9213                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: {
9214                                                         dst.AuxSecSurf.Flags.Info.PseudoStdSwizzle = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.PseudoStdSwizzle)>(*tokInfo);
9215                                                     } break;
9216                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: {
9217                                                         dst.AuxSecSurf.Flags.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Undefined64KBSwizzle)>(*tokInfo);
9218                                                     } break;
9219                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: {
9220                                                         dst.AuxSecSurf.Flags.Info.RedecribedPlanes = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.RedecribedPlanes)>(*tokInfo);
9221                                                     } break;
9222                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: {
9223                                                         dst.AuxSecSurf.Flags.Info.RenderCompressed = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.RenderCompressed)>(*tokInfo);
9224                                                     } break;
9225                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: {
9226                                                         dst.AuxSecSurf.Flags.Info.Rotated = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Rotated)>(*tokInfo);
9227                                                     } break;
9228                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: {
9229                                                         dst.AuxSecSurf.Flags.Info.Shared = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Shared)>(*tokInfo);
9230                                                     } break;
9231                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: {
9232                                                         dst.AuxSecSurf.Flags.Info.SoftwareProtected = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.SoftwareProtected)>(*tokInfo);
9233                                                     } break;
9234                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: {
9235                                                         dst.AuxSecSurf.Flags.Info.SVM = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.SVM)>(*tokInfo);
9236                                                     } break;
9237                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: {
9238                                                         dst.AuxSecSurf.Flags.Info.Tile4 = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Tile4)>(*tokInfo);
9239                                                     } break;
9240                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: {
9241                                                         dst.AuxSecSurf.Flags.Info.Tile64 = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.Tile64)>(*tokInfo);
9242                                                     } break;
9243                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: {
9244                                                         dst.AuxSecSurf.Flags.Info.TiledW = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.TiledW)>(*tokInfo);
9245                                                     } break;
9246                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: {
9247                                                         dst.AuxSecSurf.Flags.Info.TiledX = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.TiledX)>(*tokInfo);
9248                                                     } break;
9249                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: {
9250                                                         dst.AuxSecSurf.Flags.Info.TiledY = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.TiledY)>(*tokInfo);
9251                                                     } break;
9252                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: {
9253                                                         dst.AuxSecSurf.Flags.Info.TiledYf = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.TiledYf)>(*tokInfo);
9254                                                     } break;
9255                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: {
9256                                                         dst.AuxSecSurf.Flags.Info.TiledYs = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.TiledYs)>(*tokInfo);
9257                                                     } break;
9258                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: {
9259                                                         dst.AuxSecSurf.Flags.Info.WddmProtected = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.WddmProtected)>(*tokInfo);
9260                                                     } break;
9261                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: {
9262                                                         dst.AuxSecSurf.Flags.Info.XAdapter = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.XAdapter)>(*tokInfo);
9263                                                     } break;
9264                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: {
9265                                                         dst.AuxSecSurf.Flags.Info.__PreallocatedResInfo = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.__PreallocatedResInfo)>(*tokInfo);
9266                                                     } break;
9267                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: {
9268                                                         dst.AuxSecSurf.Flags.Info.__PreWddm2SVM = readTokValue<decltype(dst.AuxSecSurf.Flags.Info.__PreWddm2SVM)>(*tokInfo);
9269                                                     } break;
9270                                                     };
9271                                                     tokInfo = tokInfo + 1 + tokInfo->valueDwordCount;
9272                                                 } else {
9273                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo);
9274                                                     if (tokInfo->flags.flag3IsMandatory) {
9275                                                         return false;
9276                                                     }
9277                                                     tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9278                                                 }
9279                                             }
9280                                             WCH_ASSERT(tokInfo == tokInfoEnd);
9281                                         } break;
9282                                         case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: {
9283                                             const TokenHeader *tokWa = varLen->getValue<TokenHeader>();
9284                                             const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9285                                             while (tokWa < tokWaEnd) {
9286                                                 if (false == tokWa->flags.flag4IsVariableLength) {
9287                                                     switch (tokWa->id) {
9288                                                     default:
9289                                                         if (tokWa->flags.flag3IsMandatory) {
9290                                                             return false;
9291                                                         }
9292                                                         break;
9293                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: {
9294                                                         dst.AuxSecSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa);
9295                                                     } break;
9296                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: {
9297                                                         dst.AuxSecSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa);
9298                                                     } break;
9299                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: {
9300                                                         dst.AuxSecSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa);
9301                                                     } break;
9302                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: {
9303                                                         dst.AuxSecSurf.Flags.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.NoBufferSamplerPadding)>(*tokWa);
9304                                                     } break;
9305                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: {
9306                                                         dst.AuxSecSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa);
9307                                                     } break;
9308                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: {
9309                                                         dst.AuxSecSurf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.CHVAstcSkipVirtualMips)>(*tokWa);
9310                                                     } break;
9311                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: {
9312                                                         dst.AuxSecSurf.Flags.Wa.DisablePackedMipTail = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.DisablePackedMipTail)>(*tokWa);
9313                                                     } break;
9314                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: {
9315                                                         dst.AuxSecSurf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.__ForceOtherHVALIGN4)>(*tokWa);
9316                                                     } break;
9317                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: {
9318                                                         dst.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor)>(*tokWa);
9319                                                     } break;
9320                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: {
9321                                                         dst.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression)>(*tokWa);
9322                                                     } break;
9323                                                     case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
9324                                                         dst.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa);
9325                                                     } break;
9326                                                     };
9327                                                     tokWa = tokWa + 1 + tokWa->valueDwordCount;
9328                                                 } else {
9329                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa);
9330                                                     if (tokWa->flags.flag3IsMandatory) {
9331                                                         return false;
9332                                                     }
9333                                                     tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9334                                                 }
9335                                             }
9336                                             WCH_ASSERT(tokWa == tokWaEnd);
9337                                         } break;
9338                                         };
9339                                         tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9340                                     }
9341                                 }
9342                                 WCH_ASSERT(tokFlags == tokFlagsEnd);
9343                             } break;
9344                             case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: {
9345                                 const TokenHeader *tokCachePolicy = varLen->getValue<TokenHeader>();
9346                                 const TokenHeader *tokCachePolicyEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9347                                 while (tokCachePolicy < tokCachePolicyEnd) {
9348                                     if (false == tokCachePolicy->flags.flag4IsVariableLength) {
9349                                         switch (tokCachePolicy->id) {
9350                                         default:
9351                                             if (tokCachePolicy->flags.flag3IsMandatory) {
9352                                                 return false;
9353                                             }
9354                                             break;
9355                                         case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: {
9356                                             dst.AuxSecSurf.CachePolicy.Usage = readTokValue<decltype(dst.AuxSecSurf.CachePolicy.Usage)>(*tokCachePolicy);
9357                                         } break;
9358                                         };
9359                                         tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount;
9360                                     } else {
9361                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCachePolicy);
9362                                         if (tokCachePolicy->flags.flag3IsMandatory) {
9363                                             return false;
9364                                         }
9365                                         tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9366                                     }
9367                                 }
9368                                 WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd);
9369                             } break;
9370                             case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: {
9371                                 const TokenHeader *tokMSAA = varLen->getValue<TokenHeader>();
9372                                 const TokenHeader *tokMSAAEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9373                                 while (tokMSAA < tokMSAAEnd) {
9374                                     if (false == tokMSAA->flags.flag4IsVariableLength) {
9375                                         switch (tokMSAA->id) {
9376                                         default:
9377                                             if (tokMSAA->flags.flag3IsMandatory) {
9378                                                 return false;
9379                                             }
9380                                             break;
9381                                         case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: {
9382                                             dst.AuxSecSurf.MSAA.SamplePattern = readTokValue<decltype(dst.AuxSecSurf.MSAA.SamplePattern)>(*tokMSAA);
9383                                         } break;
9384                                         case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: {
9385                                             dst.AuxSecSurf.MSAA.NumSamples = readTokValue<decltype(dst.AuxSecSurf.MSAA.NumSamples)>(*tokMSAA);
9386                                         } break;
9387                                         };
9388                                         tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount;
9389                                     } else {
9390                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMSAA);
9391                                         if (tokMSAA->flags.flag3IsMandatory) {
9392                                             return false;
9393                                         }
9394                                         tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9395                                     }
9396                                 }
9397                                 WCH_ASSERT(tokMSAA == tokMSAAEnd);
9398                             } break;
9399                             case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: {
9400                                 const TokenHeader *tokAlignment = varLen->getValue<TokenHeader>();
9401                                 const TokenHeader *tokAlignmentEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9402                                 while (tokAlignment < tokAlignmentEnd) {
9403                                     if (false == tokAlignment->flags.flag4IsVariableLength) {
9404                                         switch (tokAlignment->id) {
9405                                         default:
9406                                             if (tokAlignment->flags.flag3IsMandatory) {
9407                                                 return false;
9408                                             }
9409                                             break;
9410                                         case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: {
9411                                             dst.AuxSecSurf.Alignment.ArraySpacingSingleLod = readTokValue<decltype(dst.AuxSecSurf.Alignment.ArraySpacingSingleLod)>(*tokAlignment);
9412                                         } break;
9413                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: {
9414                                             dst.AuxSecSurf.Alignment.BaseAlignment = readTokValue<decltype(dst.AuxSecSurf.Alignment.BaseAlignment)>(*tokAlignment);
9415                                         } break;
9416                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: {
9417                                             dst.AuxSecSurf.Alignment.HAlign = readTokValue<decltype(dst.AuxSecSurf.Alignment.HAlign)>(*tokAlignment);
9418                                         } break;
9419                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: {
9420                                             dst.AuxSecSurf.Alignment.VAlign = readTokValue<decltype(dst.AuxSecSurf.Alignment.VAlign)>(*tokAlignment);
9421                                         } break;
9422                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: {
9423                                             dst.AuxSecSurf.Alignment.DAlign = readTokValue<decltype(dst.AuxSecSurf.Alignment.DAlign)>(*tokAlignment);
9424                                         } break;
9425                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: {
9426                                             dst.AuxSecSurf.Alignment.MipTailStartLod = readTokValue<decltype(dst.AuxSecSurf.Alignment.MipTailStartLod)>(*tokAlignment);
9427                                         } break;
9428                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: {
9429                                             dst.AuxSecSurf.Alignment.PackedMipStartLod = readTokValue<decltype(dst.AuxSecSurf.Alignment.PackedMipStartLod)>(*tokAlignment);
9430                                         } break;
9431                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: {
9432                                             dst.AuxSecSurf.Alignment.PackedMipWidth = readTokValue<decltype(dst.AuxSecSurf.Alignment.PackedMipWidth)>(*tokAlignment);
9433                                         } break;
9434                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: {
9435                                             dst.AuxSecSurf.Alignment.PackedMipHeight = readTokValue<decltype(dst.AuxSecSurf.Alignment.PackedMipHeight)>(*tokAlignment);
9436                                         } break;
9437                                         case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: {
9438                                             dst.AuxSecSurf.Alignment.QPitch = readTokValue<decltype(dst.AuxSecSurf.Alignment.QPitch)>(*tokAlignment);
9439                                         } break;
9440                                         };
9441                                         tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount;
9442                                     } else {
9443                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAlignment);
9444                                         if (tokAlignment->flags.flag3IsMandatory) {
9445                                             return false;
9446                                         }
9447                                         tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9448                                     }
9449                                 }
9450                                 WCH_ASSERT(tokAlignment == tokAlignmentEnd);
9451                             } break;
9452                             case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: {
9453                                 const TokenHeader *tokOffsetInfo = varLen->getValue<TokenHeader>();
9454                                 const TokenHeader *tokOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9455                                 while (tokOffsetInfo < tokOffsetInfoEnd) {
9456                                     if (false == tokOffsetInfo->flags.flag4IsVariableLength) {
9457                                         if (tokOffsetInfo->flags.flag3IsMandatory) {
9458                                             return false;
9459                                         }
9460                                         tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount;
9461                                     } else {
9462                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOffsetInfo);
9463                                         switch (tokOffsetInfo->id) {
9464                                         default:
9465                                             if (tokOffsetInfo->flags.flag3IsMandatory) {
9466                                                 return false;
9467                                             }
9468                                             break;
9469                                         case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: {
9470                                             const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>();
9471                                             const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9472                                             while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) {
9473                                                 if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) {
9474                                                     switch (tokTexture3DOffsetInfo->id) {
9475                                                     default:
9476                                                         if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
9477                                                             return false;
9478                                                         }
9479                                                         break;
9480                                                     case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: {
9481                                                         dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo);
9482                                                     } break;
9483                                                     case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
9484                                                         auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>();
9485                                                         auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes();
9486                                                         if (srcSize < sizeof(dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset)) {
9487                                                             return false;
9488                                                         }
9489                                                         WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset));
9490                                                     } break;
9491                                                     };
9492                                                     tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount;
9493                                                 } else {
9494                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo);
9495                                                     if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
9496                                                         return false;
9497                                                     }
9498                                                     tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9499                                                 }
9500                                             }
9501                                             WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd);
9502                                         } break;
9503                                         case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: {
9504                                             const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>();
9505                                             const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9506                                             while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) {
9507                                                 if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) {
9508                                                     switch (tokTexture2DOffsetInfo->id) {
9509                                                     default:
9510                                                         if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
9511                                                             return false;
9512                                                         }
9513                                                         break;
9514                                                     case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: {
9515                                                         dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo);
9516                                                     } break;
9517                                                     case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: {
9518                                                         dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo);
9519                                                     } break;
9520                                                     case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
9521                                                         auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>();
9522                                                         auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes();
9523                                                         if (srcSize < sizeof(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset)) {
9524                                                             return false;
9525                                                         }
9526                                                         WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset));
9527                                                     } break;
9528                                                     };
9529                                                     tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount;
9530                                                 } else {
9531                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo);
9532                                                     if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
9533                                                         return false;
9534                                                     }
9535                                                     tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9536                                                 }
9537                                             }
9538                                             WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd);
9539                                         } break;
9540                                         case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: {
9541                                             const TokenHeader *tokPlane = varLen->getValue<TokenHeader>();
9542                                             const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9543                                             while (tokPlane < tokPlaneEnd) {
9544                                                 if (false == tokPlane->flags.flag4IsVariableLength) {
9545                                                     switch (tokPlane->id) {
9546                                                     default:
9547                                                         if (tokPlane->flags.flag3IsMandatory) {
9548                                                             return false;
9549                                                         }
9550                                                         break;
9551                                                     case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: {
9552                                                         dst.AuxSecSurf.OffsetInfo.Plane.ArrayQPitch = readTokValue<decltype(dst.AuxSecSurf.OffsetInfo.Plane.ArrayQPitch)>(*tokPlane);
9553                                                     } break;
9554                                                     case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: {
9555                                                         auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
9556                                                         auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
9557                                                         if (srcSize < sizeof(dst.AuxSecSurf.OffsetInfo.Plane.X)) {
9558                                                             return false;
9559                                                         }
9560                                                         WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Plane.X, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.X), srcData, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.X));
9561                                                     } break;
9562                                                     case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: {
9563                                                         auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
9564                                                         auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
9565                                                         if (srcSize < sizeof(dst.AuxSecSurf.OffsetInfo.Plane.Y)) {
9566                                                             return false;
9567                                                         }
9568                                                         WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Plane.Y, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.Y), srcData, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.Y));
9569                                                     } break;
9570                                                     case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: {
9571                                                         dst.AuxSecSurf.OffsetInfo.Plane.NoOfPlanes = readTokValue<decltype(dst.AuxSecSurf.OffsetInfo.Plane.NoOfPlanes)>(*tokPlane);
9572                                                     } break;
9573                                                     case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: {
9574                                                         dst.AuxSecSurf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.AuxSecSurf.OffsetInfo.Plane.IsTileAlignedPlanes)>(*tokPlane);
9575                                                     } break;
9576                                                     };
9577                                                     tokPlane = tokPlane + 1 + tokPlane->valueDwordCount;
9578                                                 } else {
9579                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane);
9580                                                     switch (tokPlane->id) {
9581                                                     default:
9582                                                         if (tokPlane->flags.flag3IsMandatory) {
9583                                                             return false;
9584                                                         }
9585                                                         break;
9586                                                     case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: {
9587                                                         const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>();
9588                                                         const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9589                                                         while (tokUnAligned < tokUnAlignedEnd) {
9590                                                             if (false == tokUnAligned->flags.flag4IsVariableLength) {
9591                                                                 switch (tokUnAligned->id) {
9592                                                                 default:
9593                                                                     if (tokUnAligned->flags.flag3IsMandatory) {
9594                                                                         return false;
9595                                                                     }
9596                                                                     break;
9597                                                                 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: {
9598                                                                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>();
9599                                                                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes();
9600                                                                     if (srcSize < sizeof(dst.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height)) {
9601                                                                         return false;
9602                                                                     }
9603                                                                     WCH_SAFE_COPY(dst.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height));
9604                                                                 } break;
9605                                                                 };
9606                                                                 tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount;
9607                                                             } else {
9608                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned);
9609                                                                 if (tokUnAligned->flags.flag3IsMandatory) {
9610                                                                     return false;
9611                                                                 }
9612                                                                 tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9613                                                             }
9614                                                         }
9615                                                         WCH_ASSERT(tokUnAligned == tokUnAlignedEnd);
9616                                                     } break;
9617                                                     };
9618                                                     tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9619                                                 }
9620                                             }
9621                                             WCH_ASSERT(tokPlane == tokPlaneEnd);
9622                                         } break;
9623                                         };
9624                                         tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9625                                     }
9626                                 }
9627                                 WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd);
9628                             } break;
9629                             case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: {
9630                                 const TokenHeader *tokS3d = varLen->getValue<TokenHeader>();
9631                                 const TokenHeader *tokS3dEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9632                                 while (tokS3d < tokS3dEnd) {
9633                                     if (false == tokS3d->flags.flag4IsVariableLength) {
9634                                         switch (tokS3d->id) {
9635                                         default:
9636                                             if (tokS3d->flags.flag3IsMandatory) {
9637                                                 return false;
9638                                             }
9639                                             break;
9640                                         case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: {
9641                                             dst.AuxSecSurf.S3d.DisplayModeHeight = readTokValue<decltype(dst.AuxSecSurf.S3d.DisplayModeHeight)>(*tokS3d);
9642                                         } break;
9643                                         case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: {
9644                                             dst.AuxSecSurf.S3d.NumBlankActiveLines = readTokValue<decltype(dst.AuxSecSurf.S3d.NumBlankActiveLines)>(*tokS3d);
9645                                         } break;
9646                                         case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: {
9647                                             dst.AuxSecSurf.S3d.RFrameOffset = readTokValue<decltype(dst.AuxSecSurf.S3d.RFrameOffset)>(*tokS3d);
9648                                         } break;
9649                                         case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: {
9650                                             dst.AuxSecSurf.S3d.BlankAreaOffset = readTokValue<decltype(dst.AuxSecSurf.S3d.BlankAreaOffset)>(*tokS3d);
9651                                         } break;
9652                                         case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: {
9653                                             dst.AuxSecSurf.S3d.TallBufferHeight = readTokValue<decltype(dst.AuxSecSurf.S3d.TallBufferHeight)>(*tokS3d);
9654                                         } break;
9655                                         case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: {
9656                                             dst.AuxSecSurf.S3d.TallBufferSize = readTokValue<decltype(dst.AuxSecSurf.S3d.TallBufferSize)>(*tokS3d);
9657                                         } break;
9658                                         case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: {
9659                                             dst.AuxSecSurf.S3d.IsRFrame = readTokValue<decltype(dst.AuxSecSurf.S3d.IsRFrame)>(*tokS3d);
9660                                         } break;
9661                                         };
9662                                         tokS3d = tokS3d + 1 + tokS3d->valueDwordCount;
9663                                     } else {
9664                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokS3d);
9665                                         if (tokS3d->flags.flag3IsMandatory) {
9666                                             return false;
9667                                         }
9668                                         tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9669                                     }
9670                                 }
9671                                 WCH_ASSERT(tokS3d == tokS3dEnd);
9672                             } break;
9673                             case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: {
9674                                 const TokenHeader *tokSegmentOverride = varLen->getValue<TokenHeader>();
9675                                 const TokenHeader *tokSegmentOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9676                                 while (tokSegmentOverride < tokSegmentOverrideEnd) {
9677                                     if (false == tokSegmentOverride->flags.flag4IsVariableLength) {
9678                                         switch (tokSegmentOverride->id) {
9679                                         default:
9680                                             if (tokSegmentOverride->flags.flag3IsMandatory) {
9681                                                 return false;
9682                                             }
9683                                             break;
9684                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: {
9685                                             dst.AuxSecSurf.SegmentOverride.Seg1 = readTokValue<decltype(dst.AuxSecSurf.SegmentOverride.Seg1)>(*tokSegmentOverride);
9686                                         } break;
9687                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: {
9688                                             dst.AuxSecSurf.SegmentOverride.Evict = readTokValue<decltype(dst.AuxSecSurf.SegmentOverride.Evict)>(*tokSegmentOverride);
9689                                         } break;
9690                                         };
9691                                         tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount;
9692                                     } else {
9693                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSegmentOverride);
9694                                         if (tokSegmentOverride->flags.flag3IsMandatory) {
9695                                             return false;
9696                                         }
9697                                         tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9698                                     }
9699                                 }
9700                                 WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd);
9701                             } break;
9702                             case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: {
9703 #if _DEBUG || _RELEASE_INTERNAL
9704                                 const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>();
9705                                 const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9706                                 while (tokPlatform < tokPlatformEnd) {
9707                                     if (false == tokPlatform->flags.flag4IsVariableLength) {
9708                                         switch (tokPlatform->id) {
9709                                         default:
9710                                             if (tokPlatform->flags.flag3IsMandatory) {
9711                                                 return false;
9712                                             }
9713                                             break;
9714                                         case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
9715                                             dst.AuxSecSurf.Platform.eProductFamily = readTokValue<decltype(dst.AuxSecSurf.Platform.eProductFamily)>(*tokPlatform);
9716                                         } break;
9717                                         case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
9718                                             dst.AuxSecSurf.Platform.ePCHProductFamily = readTokValue<decltype(dst.AuxSecSurf.Platform.ePCHProductFamily)>(*tokPlatform);
9719                                         } break;
9720                                         case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
9721                                             dst.AuxSecSurf.Platform.eDisplayCoreFamily = readTokValue<decltype(dst.AuxSecSurf.Platform.eDisplayCoreFamily)>(*tokPlatform);
9722                                         } break;
9723                                         case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
9724                                             dst.AuxSecSurf.Platform.eRenderCoreFamily = readTokValue<decltype(dst.AuxSecSurf.Platform.eRenderCoreFamily)>(*tokPlatform);
9725                                         } break;
9726                                         case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
9727                                             dst.AuxSecSurf.Platform.ePlatformType = readTokValue<decltype(dst.AuxSecSurf.Platform.ePlatformType)>(*tokPlatform);
9728                                         } break;
9729                                         case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
9730                                             dst.AuxSecSurf.Platform.usDeviceID = readTokValue<decltype(dst.AuxSecSurf.Platform.usDeviceID)>(*tokPlatform);
9731                                         } break;
9732                                         case TOK_FBW_PLATFORM_STR__US_REV_ID: {
9733                                             dst.AuxSecSurf.Platform.usRevId = readTokValue<decltype(dst.AuxSecSurf.Platform.usRevId)>(*tokPlatform);
9734                                         } break;
9735                                         case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
9736                                             dst.AuxSecSurf.Platform.usDeviceID_PCH = readTokValue<decltype(dst.AuxSecSurf.Platform.usDeviceID_PCH)>(*tokPlatform);
9737                                         } break;
9738                                         case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
9739                                             dst.AuxSecSurf.Platform.usRevId_PCH = readTokValue<decltype(dst.AuxSecSurf.Platform.usRevId_PCH)>(*tokPlatform);
9740                                         } break;
9741                                         case TOK_FE_PLATFORM_STR__E_GTTYPE: {
9742                                             dst.AuxSecSurf.Platform.eGTType = readTokValue<decltype(dst.AuxSecSurf.Platform.eGTType)>(*tokPlatform);
9743                                         } break;
9744                                         };
9745                                         tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount;
9746                                     } else {
9747                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform);
9748                                         if (tokPlatform->flags.flag3IsMandatory) {
9749                                             return false;
9750                                         }
9751                                         tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9752                                     }
9753                                 }
9754                                 WCH_ASSERT(tokPlatform == tokPlatformEnd);
9755 #endif
9756                             } break;
9757                             case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: {
9758                                 const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>();
9759                                 const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9760                                 while (tokExistingSysMem < tokExistingSysMemEnd) {
9761                                     if (false == tokExistingSysMem->flags.flag4IsVariableLength) {
9762                                         switch (tokExistingSysMem->id) {
9763                                         default:
9764                                             if (tokExistingSysMem->flags.flag3IsMandatory) {
9765                                                 return false;
9766                                             }
9767                                             break;
9768                                         case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: {
9769                                             dst.AuxSecSurf.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.AuxSecSurf.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem);
9770                                         } break;
9771                                         case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: {
9772                                             dst.AuxSecSurf.ExistingSysMem.IsPageAligned = readTokValue<decltype(dst.AuxSecSurf.ExistingSysMem.IsPageAligned)>(*tokExistingSysMem);
9773                                         } break;
9774                                         };
9775                                         tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount;
9776                                     } else {
9777                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem);
9778                                         if (tokExistingSysMem->flags.flag3IsMandatory) {
9779                                             return false;
9780                                         }
9781                                         tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9782                                     }
9783                                 }
9784                                 WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd);
9785                             } break;
9786                             case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: {
9787 #if !(_DEBUG || _RELEASE_INTERNAL)
9788                                 const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>();
9789                                 const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9790                                 while (tok__Platform < tok__PlatformEnd) {
9791                                     if (false == tok__Platform->flags.flag4IsVariableLength) {
9792                                         switch (tok__Platform->id) {
9793                                         default:
9794                                             if (tok__Platform->flags.flag3IsMandatory) {
9795                                                 return false;
9796                                             }
9797                                             break;
9798                                         case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
9799                                             dst.AuxSecSurf.__Platform.eProductFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.eProductFamily)>(*tok__Platform);
9800                                         } break;
9801                                         case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
9802                                             dst.AuxSecSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.ePCHProductFamily)>(*tok__Platform);
9803                                         } break;
9804                                         case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
9805                                             dst.AuxSecSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.eDisplayCoreFamily)>(*tok__Platform);
9806                                         } break;
9807                                         case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
9808                                             dst.AuxSecSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.AuxSecSurf.__Platform.eRenderCoreFamily)>(*tok__Platform);
9809                                         } break;
9810                                         case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
9811                                             dst.AuxSecSurf.__Platform.ePlatformType = readTokValue<decltype(dst.AuxSecSurf.__Platform.ePlatformType)>(*tok__Platform);
9812                                         } break;
9813                                         case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
9814                                             dst.AuxSecSurf.__Platform.usDeviceID = readTokValue<decltype(dst.AuxSecSurf.__Platform.usDeviceID)>(*tok__Platform);
9815                                         } break;
9816                                         case TOK_FBW_PLATFORM_STR__US_REV_ID: {
9817                                             dst.AuxSecSurf.__Platform.usRevId = readTokValue<decltype(dst.AuxSecSurf.__Platform.usRevId)>(*tok__Platform);
9818                                         } break;
9819                                         case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
9820                                             dst.AuxSecSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.AuxSecSurf.__Platform.usDeviceID_PCH)>(*tok__Platform);
9821                                         } break;
9822                                         case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
9823                                             dst.AuxSecSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.AuxSecSurf.__Platform.usRevId_PCH)>(*tok__Platform);
9824                                         } break;
9825                                         case TOK_FE_PLATFORM_STR__E_GTTYPE: {
9826                                             dst.AuxSecSurf.__Platform.eGTType = readTokValue<decltype(dst.AuxSecSurf.__Platform.eGTType)>(*tok__Platform);
9827                                         } break;
9828                                         };
9829                                         tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount;
9830                                     } else {
9831                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform);
9832                                         if (tok__Platform->flags.flag3IsMandatory) {
9833                                             return false;
9834                                         }
9835                                         tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9836                                     }
9837                                 }
9838                                 WCH_ASSERT(tok__Platform == tok__PlatformEnd);
9839 #endif
9840                             } break;
9841                             };
9842                             tokAuxSecSurf = tokAuxSecSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9843                         }
9844                     }
9845                     WCH_ASSERT(tokAuxSecSurf == tokAuxSecSurfEnd);
9846                 } break;
9847                 case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__EXISTING_SYS_MEM: {
9848                     const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>();
9849                     const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9850                     while (tokExistingSysMem < tokExistingSysMemEnd) {
9851                         if (false == tokExistingSysMem->flags.flag4IsVariableLength) {
9852                             switch (tokExistingSysMem->id) {
9853                             default:
9854                                 if (tokExistingSysMem->flags.flag3IsMandatory) {
9855                                     return false;
9856                                 }
9857                                 break;
9858                             case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_EXISTING_SYS_MEM: {
9859                                 dst.ExistingSysMem.pExistingSysMem = readTokValue<decltype(dst.ExistingSysMem.pExistingSysMem)>(*tokExistingSysMem);
9860                             } break;
9861                             case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_VIRT_ADDRESS: {
9862                                 dst.ExistingSysMem.pVirtAddress = readTokValue<decltype(dst.ExistingSysMem.pVirtAddress)>(*tokExistingSysMem);
9863                             } break;
9864                             case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_GFX_ALIGNED_VIRT_ADDRESS: {
9865                                 dst.ExistingSysMem.pGfxAlignedVirtAddress = readTokValue<decltype(dst.ExistingSysMem.pGfxAlignedVirtAddress)>(*tokExistingSysMem);
9866                             } break;
9867                             case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__SIZE: {
9868                                 dst.ExistingSysMem.Size = readTokValue<decltype(dst.ExistingSysMem.Size)>(*tokExistingSysMem);
9869                             } break;
9870                             case TOK_FBC_GMM_EXISTING_SYS_MEM_REC__IS_GMM_ALLOCATED: {
9871                                 dst.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem);
9872                             } break;
9873                             };
9874                             tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount;
9875                         } else {
9876                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem);
9877                             if (tokExistingSysMem->flags.flag3IsMandatory) {
9878                                 return false;
9879                             }
9880                             tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9881                         }
9882                     }
9883                     WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd);
9884                 } break;
9885                 case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__MULTI_TILE_ARCH: {
9886                     const TokenHeader *tokMultiTileArch = varLen->getValue<TokenHeader>();
9887                     const TokenHeader *tokMultiTileArchEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9888                     while (tokMultiTileArch < tokMultiTileArchEnd) {
9889                         if (false == tokMultiTileArch->flags.flag4IsVariableLength) {
9890                             switch (tokMultiTileArch->id) {
9891                             default:
9892                                 if (tokMultiTileArch->flags.flag3IsMandatory) {
9893                                     return false;
9894                                 }
9895                                 break;
9896                             case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__ENABLE: {
9897                                 dst.MultiTileArch.Enable = readTokValue<decltype(dst.MultiTileArch.Enable)>(*tokMultiTileArch);
9898                             } break;
9899                             case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__TILE_INSTANCED: {
9900                                 dst.MultiTileArch.TileInstanced = readTokValue<decltype(dst.MultiTileArch.TileInstanced)>(*tokMultiTileArch);
9901                             } break;
9902                             case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__GPU_VA_MAPPING_SET: {
9903                                 dst.MultiTileArch.GpuVaMappingSet = readTokValue<decltype(dst.MultiTileArch.GpuVaMappingSet)>(*tokMultiTileArch);
9904                             } break;
9905                             case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_ELIGIBILITY_SET: {
9906                                 dst.MultiTileArch.LocalMemEligibilitySet = readTokValue<decltype(dst.MultiTileArch.LocalMemEligibilitySet)>(*tokMultiTileArch);
9907                             } break;
9908                             case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_PREFERRED_SET: {
9909                                 dst.MultiTileArch.LocalMemPreferredSet = readTokValue<decltype(dst.MultiTileArch.LocalMemPreferredSet)>(*tokMultiTileArch);
9910                             } break;
9911                             };
9912                             tokMultiTileArch = tokMultiTileArch + 1 + tokMultiTileArch->valueDwordCount;
9913                         } else {
9914                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMultiTileArch);
9915                             if (tokMultiTileArch->flags.flag3IsMandatory) {
9916                                 return false;
9917                             }
9918                             tokMultiTileArch = tokMultiTileArch + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9919                         }
9920                     }
9921                     WCH_ASSERT(tokMultiTileArch == tokMultiTileArchEnd);
9922                 } break;
9923                 };
9924                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
9925             }
9926         }
9927         WCH_ASSERT(tok == srcTokensEnd);
9928         return true;
9929     }
9930 };
9931 
9932 template <>
9933 struct Demarshaller<TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT> {
9934     template <typename GmmResourceInfoWinStructT>
9935     static bool demarshall(GmmResourceInfoWinStructT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
9936         const TokenHeader *tok = srcTokensBeg;
9937         while (tok < srcTokensEnd) {
9938             if (false == tok->flags.flag4IsVariableLength) {
9939                 if (tok->flags.flag3IsMandatory) {
9940                     return false;
9941                 }
9942                 tok = tok + 1 + tok->valueDwordCount;
9943             } else {
9944                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
9945                 switch (tok->id) {
9946                 default:
9947                     if (tok->flags.flag3IsMandatory) {
9948                         return false;
9949                     }
9950                     break;
9951                 case TOK_S_GMM_RESOURCE_INFO_WIN_STRUCT:
9952                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
9953                         return false;
9954                     }
9955                     break;
9956                 case TOK_FS_GMM_RESOURCE_INFO_WIN_STRUCT__GMM_RESOURCE_INFO_COMMON: {
9957                     const TokenHeader *tokGmmResourceInfoCommon = varLen->getValue<TokenHeader>();
9958                     const TokenHeader *tokGmmResourceInfoCommonEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9959                     while (tokGmmResourceInfoCommon < tokGmmResourceInfoCommonEnd) {
9960                         if (false == tokGmmResourceInfoCommon->flags.flag4IsVariableLength) {
9961                             switch (tokGmmResourceInfoCommon->id) {
9962                             default:
9963                                 if (tokGmmResourceInfoCommon->flags.flag3IsMandatory) {
9964                                     return false;
9965                                 }
9966                                 break;
9967                             case TOK_FE_GMM_RESOURCE_INFO_COMMON_STRUCT__CLIENT_TYPE: {
9968                                 dst.GmmResourceInfoCommon.ClientType = readTokValue<decltype(dst.GmmResourceInfoCommon.ClientType)>(*tokGmmResourceInfoCommon);
9969                             } break;
9970                             case TOK_FBD_GMM_RESOURCE_INFO_COMMON_STRUCT__ROTATE_INFO: {
9971                                 dst.GmmResourceInfoCommon.RotateInfo = readTokValue<decltype(dst.GmmResourceInfoCommon.RotateInfo)>(*tokGmmResourceInfoCommon);
9972                             } break;
9973                             case TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__SVM_ADDRESS: {
9974                                 dst.GmmResourceInfoCommon.SvmAddress = readTokValue<decltype(dst.GmmResourceInfoCommon.SvmAddress)>(*tokGmmResourceInfoCommon);
9975                             } break;
9976                             case TOK_FBQ_GMM_RESOURCE_INFO_COMMON_STRUCT__P_PRIVATE_DATA: {
9977                                 dst.GmmResourceInfoCommon.pPrivateData = readTokValue<decltype(dst.GmmResourceInfoCommon.pPrivateData)>(*tokGmmResourceInfoCommon);
9978                             } break;
9979                             };
9980                             tokGmmResourceInfoCommon = tokGmmResourceInfoCommon + 1 + tokGmmResourceInfoCommon->valueDwordCount;
9981                         } else {
9982                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGmmResourceInfoCommon);
9983                             switch (tokGmmResourceInfoCommon->id) {
9984                             default:
9985                                 if (tokGmmResourceInfoCommon->flags.flag3IsMandatory) {
9986                                     return false;
9987                                 }
9988                                 break;
9989                             case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__SURF: {
9990                                 const TokenHeader *tokSurf = varLen->getValue<TokenHeader>();
9991                                 const TokenHeader *tokSurfEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
9992                                 while (tokSurf < tokSurfEnd) {
9993                                     if (false == tokSurf->flags.flag4IsVariableLength) {
9994                                         switch (tokSurf->id) {
9995                                         default:
9996                                             if (tokSurf->flags.flag3IsMandatory) {
9997                                                 return false;
9998                                             }
9999                                             break;
10000                                         case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: {
10001                                             dst.GmmResourceInfoCommon.Surf.Type = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Type)>(*tokSurf);
10002                                         } break;
10003                                         case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: {
10004                                             dst.GmmResourceInfoCommon.Surf.Format = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Format)>(*tokSurf);
10005                                         } break;
10006                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: {
10007                                             dst.GmmResourceInfoCommon.Surf.BitsPerPixel = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.BitsPerPixel)>(*tokSurf);
10008                                         } break;
10009                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: {
10010                                             dst.GmmResourceInfoCommon.Surf.BaseWidth = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.BaseWidth)>(*tokSurf);
10011                                         } break;
10012                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: {
10013                                             dst.GmmResourceInfoCommon.Surf.BaseHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.BaseHeight)>(*tokSurf);
10014                                         } break;
10015                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: {
10016                                             dst.GmmResourceInfoCommon.Surf.Depth = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Depth)>(*tokSurf);
10017                                         } break;
10018                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: {
10019                                             dst.GmmResourceInfoCommon.Surf.MaxLod = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.MaxLod)>(*tokSurf);
10020                                         } break;
10021                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: {
10022                                             dst.GmmResourceInfoCommon.Surf.ArraySize = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.ArraySize)>(*tokSurf);
10023                                         } break;
10024                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: {
10025                                             dst.GmmResourceInfoCommon.Surf.CpTag = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.CpTag)>(*tokSurf);
10026                                         } break;
10027                                         case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: {
10028                                             auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValue<char>();
10029                                             auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValueSizeInBytes();
10030                                             if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.MmcMode)) {
10031                                                 return false;
10032                                             }
10033                                             WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.MmcMode, sizeof(dst.GmmResourceInfoCommon.Surf.MmcMode), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.MmcMode));
10034                                         } break;
10035                                         case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: {
10036                                             auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValue<char>();
10037                                             auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokSurf).getValueSizeInBytes();
10038                                             if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.MmcHint)) {
10039                                                 return false;
10040                                             }
10041                                             WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.MmcHint, sizeof(dst.GmmResourceInfoCommon.Surf.MmcHint), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.MmcHint));
10042                                         } break;
10043                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: {
10044                                             dst.GmmResourceInfoCommon.Surf.Pitch = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Pitch)>(*tokSurf);
10045                                         } break;
10046                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: {
10047                                             dst.GmmResourceInfoCommon.Surf.OverridePitch = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.OverridePitch)>(*tokSurf);
10048                                         } break;
10049                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: {
10050                                             dst.GmmResourceInfoCommon.Surf.Size = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Size)>(*tokSurf);
10051                                         } break;
10052                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: {
10053                                             dst.GmmResourceInfoCommon.Surf.CCSize = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.CCSize)>(*tokSurf);
10054                                         } break;
10055                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: {
10056                                             dst.GmmResourceInfoCommon.Surf.UnpaddedSize = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.UnpaddedSize)>(*tokSurf);
10057                                         } break;
10058                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: {
10059                                             dst.GmmResourceInfoCommon.Surf.SizeReportToOS = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.SizeReportToOS)>(*tokSurf);
10060                                         } break;
10061                                         case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: {
10062                                             dst.GmmResourceInfoCommon.Surf.TileMode = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.TileMode)>(*tokSurf);
10063                                         } break;
10064                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: {
10065                                             dst.GmmResourceInfoCommon.Surf.CCSModeAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.CCSModeAlign)>(*tokSurf);
10066                                         } break;
10067                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: {
10068                                             dst.GmmResourceInfoCommon.Surf.LegacyFlags = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.LegacyFlags)>(*tokSurf);
10069                                         } break;
10070                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: {
10071                                             dst.GmmResourceInfoCommon.Surf.MaximumRenamingListLength = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.MaximumRenamingListLength)>(*tokSurf);
10072                                         } break;
10073                                         };
10074                                         tokSurf = tokSurf + 1 + tokSurf->valueDwordCount;
10075                                     } else {
10076                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSurf);
10077                                         switch (tokSurf->id) {
10078                                         default:
10079                                             if (tokSurf->flags.flag3IsMandatory) {
10080                                                 return false;
10081                                             }
10082                                             break;
10083                                         case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: {
10084                                             const TokenHeader *tokFlags = varLen->getValue<TokenHeader>();
10085                                             const TokenHeader *tokFlagsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10086                                             while (tokFlags < tokFlagsEnd) {
10087                                                 if (false == tokFlags->flags.flag4IsVariableLength) {
10088                                                     if (tokFlags->flags.flag3IsMandatory) {
10089                                                         return false;
10090                                                     }
10091                                                     tokFlags = tokFlags + 1 + tokFlags->valueDwordCount;
10092                                                 } else {
10093                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokFlags);
10094                                                     switch (tokFlags->id) {
10095                                                     default:
10096                                                         if (tokFlags->flags.flag3IsMandatory) {
10097                                                             return false;
10098                                                         }
10099                                                         break;
10100                                                     case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: {
10101                                                         const TokenHeader *tokGpu = varLen->getValue<TokenHeader>();
10102                                                         const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10103                                                         while (tokGpu < tokGpuEnd) {
10104                                                             if (false == tokGpu->flags.flag4IsVariableLength) {
10105                                                                 switch (tokGpu->id) {
10106                                                                 default:
10107                                                                     if (tokGpu->flags.flag3IsMandatory) {
10108                                                                         return false;
10109                                                                     }
10110                                                                     break;
10111                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: {
10112                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.CameraCapture = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.CameraCapture)>(*tokGpu);
10113                                                                 } break;
10114                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: {
10115                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.CCS = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.CCS)>(*tokGpu);
10116                                                                 } break;
10117                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: {
10118                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorDiscard = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorDiscard)>(*tokGpu);
10119                                                                 } break;
10120                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: {
10121                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorSeparation = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorSeparation)>(*tokGpu);
10122                                                                 } break;
10123                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: {
10124                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ColorSeparationRGBX)>(*tokGpu);
10125                                                                 } break;
10126                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: {
10127                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Constant = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Constant)>(*tokGpu);
10128                                                                 } break;
10129                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: {
10130                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Depth = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Depth)>(*tokGpu);
10131                                                                 } break;
10132                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: {
10133                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.FlipChain = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.FlipChain)>(*tokGpu);
10134                                                                 } break;
10135                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: {
10136                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.FlipChainPreferred = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.FlipChainPreferred)>(*tokGpu);
10137                                                                 } break;
10138                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: {
10139                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.HistoryBuffer = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.HistoryBuffer)>(*tokGpu);
10140                                                                 } break;
10141                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: {
10142                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.HiZ = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.HiZ)>(*tokGpu);
10143                                                                 } break;
10144                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: {
10145                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Index = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Index)>(*tokGpu);
10146                                                                 } break;
10147                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: {
10148                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.IndirectClearColor = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.IndirectClearColor)>(*tokGpu);
10149                                                                 } break;
10150                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: {
10151                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.InstructionFlat = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.InstructionFlat)>(*tokGpu);
10152                                                                 } break;
10153                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: {
10154                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.InterlacedScan = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.InterlacedScan)>(*tokGpu);
10155                                                                 } break;
10156                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: {
10157                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MCS = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MCS)>(*tokGpu);
10158                                                                 } break;
10159                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: {
10160                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MMC = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MMC)>(*tokGpu);
10161                                                                 } break;
10162                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: {
10163                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MotionComp = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.MotionComp)>(*tokGpu);
10164                                                                 } break;
10165                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: {
10166                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.NoRestriction = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.NoRestriction)>(*tokGpu);
10167                                                                 } break;
10168                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: {
10169                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Overlay = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Overlay)>(*tokGpu);
10170                                                                 } break;
10171                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: {
10172                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Presentable = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Presentable)>(*tokGpu);
10173                                                                 } break;
10174                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: {
10175                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ProceduralTexture = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ProceduralTexture)>(*tokGpu);
10176                                                                 } break;
10177                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: {
10178                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Query = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Query)>(*tokGpu);
10179                                                                 } break;
10180                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: {
10181                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.RenderTarget = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.RenderTarget)>(*tokGpu);
10182                                                                 } break;
10183                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: {
10184                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.S3d = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.S3d)>(*tokGpu);
10185                                                                 } break;
10186                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: {
10187                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.S3dDx = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.S3dDx)>(*tokGpu);
10188                                                                 } break;
10189                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: {
10190                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__S3dNonPacked = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__S3dNonPacked)>(*tokGpu);
10191                                                                 } break;
10192                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: {
10193                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__S3dWidi = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__S3dWidi)>(*tokGpu);
10194                                                                 } break;
10195                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: {
10196                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ScratchFlat = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.ScratchFlat)>(*tokGpu);
10197                                                                 } break;
10198                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: {
10199                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.SeparateStencil = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.SeparateStencil)>(*tokGpu);
10200                                                                 } break;
10201                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: {
10202                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.State = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.State)>(*tokGpu);
10203                                                                 } break;
10204                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: {
10205                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.StateDx9ConstantBuffer)>(*tokGpu);
10206                                                                 } break;
10207                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: {
10208                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Stream = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Stream)>(*tokGpu);
10209                                                                 } break;
10210                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: {
10211                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TextApi = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TextApi)>(*tokGpu);
10212                                                                 } break;
10213                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: {
10214                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Texture = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Texture)>(*tokGpu);
10215                                                                 } break;
10216                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: {
10217                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TiledResource = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TiledResource)>(*tokGpu);
10218                                                                 } break;
10219                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: {
10220                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TilePool = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.TilePool)>(*tokGpu);
10221                                                                 } break;
10222                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: {
10223                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.UnifiedAuxSurface)>(*tokGpu);
10224                                                                 } break;
10225                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: {
10226                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Vertex = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Vertex)>(*tokGpu);
10227                                                                 } break;
10228                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: {
10229                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Video = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.Video)>(*tokGpu);
10230                                                                 } break;
10231                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: {
10232                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaTileXCcs)>(*tokGpu);
10233                                                                 } break;
10234                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: {
10235                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaTileYCcs)>(*tokGpu);
10236                                                                 } break;
10237                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: {
10238                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__MsaaTileMcs)>(*tokGpu);
10239                                                                 } break;
10240                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: {
10241                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__NonMsaaLinearCCS)>(*tokGpu);
10242                                                                 } break;
10243                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: {
10244                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__Remaining = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Gpu.__Remaining)>(*tokGpu);
10245                                                                 } break;
10246                                                                 };
10247                                                                 tokGpu = tokGpu + 1 + tokGpu->valueDwordCount;
10248                                                             } else {
10249                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu);
10250                                                                 if (tokGpu->flags.flag3IsMandatory) {
10251                                                                     return false;
10252                                                                 }
10253                                                                 tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10254                                                             }
10255                                                         }
10256                                                         WCH_ASSERT(tokGpu == tokGpuEnd);
10257                                                     } break;
10258                                                     case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: {
10259                                                         const TokenHeader *tokInfo = varLen->getValue<TokenHeader>();
10260                                                         const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10261                                                         while (tokInfo < tokInfoEnd) {
10262                                                             if (false == tokInfo->flags.flag4IsVariableLength) {
10263                                                                 switch (tokInfo->id) {
10264                                                                 default:
10265                                                                     if (tokInfo->flags.flag3IsMandatory) {
10266                                                                         return false;
10267                                                                     }
10268                                                                     break;
10269                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: {
10270                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.AllowVirtualPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.AllowVirtualPadding)>(*tokInfo);
10271                                                                 } break;
10272                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: {
10273                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.BigPage = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.BigPage)>(*tokInfo);
10274                                                                 } break;
10275                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: {
10276                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.Cacheable = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Cacheable)>(*tokInfo);
10277                                                                 } break;
10278                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: {
10279                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.ContigPhysMemoryForiDART)>(*tokInfo);
10280                                                                 } break;
10281                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: {
10282                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.CornerTexelMode = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.CornerTexelMode)>(*tokInfo);
10283                                                                 } break;
10284                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: {
10285                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.ExistingSysMem = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.ExistingSysMem)>(*tokInfo);
10286                                                                 } break;
10287                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: {
10288                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.ForceResidency = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.ForceResidency)>(*tokInfo);
10289                                                                 } break;
10290                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: {
10291                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.Gfdt = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Gfdt)>(*tokInfo);
10292                                                                 } break;
10293                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: {
10294                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.GttMapType = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.GttMapType)>(*tokInfo);
10295                                                                 } break;
10296                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: {
10297                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.HardwareProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.HardwareProtected)>(*tokInfo);
10298                                                                 } break;
10299                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: {
10300                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.KernelModeMapped = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.KernelModeMapped)>(*tokInfo);
10301                                                                 } break;
10302                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: {
10303                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutBelow = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutBelow)>(*tokInfo);
10304                                                                 } break;
10305                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: {
10306                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutMono = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutMono)>(*tokInfo);
10307                                                                 } break;
10308                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: {
10309                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutRight = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.LayoutRight)>(*tokInfo);
10310                                                                 } break;
10311                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: {
10312                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.LocalOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.LocalOnly)>(*tokInfo);
10313                                                                 } break;
10314                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: {
10315                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.Linear = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Linear)>(*tokInfo);
10316                                                                 } break;
10317                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: {
10318                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.MediaCompressed = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.MediaCompressed)>(*tokInfo);
10319                                                                 } break;
10320                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: {
10321                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.NoOptimizationPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.NoOptimizationPadding)>(*tokInfo);
10322                                                                 } break;
10323                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: {
10324                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.NoPhysMemory = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.NoPhysMemory)>(*tokInfo);
10325                                                                 } break;
10326                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: {
10327                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.NotLockable = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.NotLockable)>(*tokInfo);
10328                                                                 } break;
10329                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: {
10330                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.NonLocalOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.NonLocalOnly)>(*tokInfo);
10331                                                                 } break;
10332                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: {
10333                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.StdSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.StdSwizzle)>(*tokInfo);
10334                                                                 } break;
10335                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: {
10336                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.PseudoStdSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.PseudoStdSwizzle)>(*tokInfo);
10337                                                                 } break;
10338                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: {
10339                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Undefined64KBSwizzle)>(*tokInfo);
10340                                                                 } break;
10341                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: {
10342                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.RedecribedPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.RedecribedPlanes)>(*tokInfo);
10343                                                                 } break;
10344                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: {
10345                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.RenderCompressed = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.RenderCompressed)>(*tokInfo);
10346                                                                 } break;
10347                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: {
10348                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.Rotated = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Rotated)>(*tokInfo);
10349                                                                 } break;
10350                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: {
10351                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.Shared = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Shared)>(*tokInfo);
10352                                                                 } break;
10353                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: {
10354                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.SoftwareProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.SoftwareProtected)>(*tokInfo);
10355                                                                 } break;
10356                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: {
10357                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.SVM = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.SVM)>(*tokInfo);
10358                                                                 } break;
10359                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: {
10360                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.Tile4 = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Tile4)>(*tokInfo);
10361                                                                 } break;
10362                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: {
10363                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.Tile64 = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.Tile64)>(*tokInfo);
10364                                                                 } break;
10365                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: {
10366                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledW = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledW)>(*tokInfo);
10367                                                                 } break;
10368                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: {
10369                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledX = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledX)>(*tokInfo);
10370                                                                 } break;
10371                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: {
10372                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledY = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledY)>(*tokInfo);
10373                                                                 } break;
10374                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: {
10375                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledYf = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledYf)>(*tokInfo);
10376                                                                 } break;
10377                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: {
10378                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledYs = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.TiledYs)>(*tokInfo);
10379                                                                 } break;
10380                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: {
10381                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.WddmProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.WddmProtected)>(*tokInfo);
10382                                                                 } break;
10383                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: {
10384                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.XAdapter = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.XAdapter)>(*tokInfo);
10385                                                                 } break;
10386                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: {
10387                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.__PreallocatedResInfo = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.__PreallocatedResInfo)>(*tokInfo);
10388                                                                 } break;
10389                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: {
10390                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Info.__PreWddm2SVM = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Info.__PreWddm2SVM)>(*tokInfo);
10391                                                                 } break;
10392                                                                 };
10393                                                                 tokInfo = tokInfo + 1 + tokInfo->valueDwordCount;
10394                                                             } else {
10395                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo);
10396                                                                 if (tokInfo->flags.flag3IsMandatory) {
10397                                                                     return false;
10398                                                                 }
10399                                                                 tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10400                                                             }
10401                                                         }
10402                                                         WCH_ASSERT(tokInfo == tokInfoEnd);
10403                                                     } break;
10404                                                     case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: {
10405                                                         const TokenHeader *tokWa = varLen->getValue<TokenHeader>();
10406                                                         const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10407                                                         while (tokWa < tokWaEnd) {
10408                                                             if (false == tokWa->flags.flag4IsVariableLength) {
10409                                                                 switch (tokWa->id) {
10410                                                                 default:
10411                                                                     if (tokWa->flags.flag3IsMandatory) {
10412                                                                         return false;
10413                                                                     }
10414                                                                     break;
10415                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: {
10416                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa);
10417                                                                 } break;
10418                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: {
10419                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa);
10420                                                                 } break;
10421                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: {
10422                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa);
10423                                                                 } break;
10424                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: {
10425                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.NoBufferSamplerPadding)>(*tokWa);
10426                                                                 } break;
10427                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: {
10428                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa);
10429                                                                 } break;
10430                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: {
10431                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.CHVAstcSkipVirtualMips)>(*tokWa);
10432                                                                 } break;
10433                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: {
10434                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisablePackedMipTail = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisablePackedMipTail)>(*tokWa);
10435                                                                 } break;
10436                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: {
10437                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.__ForceOtherHVALIGN4)>(*tokWa);
10438                                                                 } break;
10439                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: {
10440                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsClearColor)>(*tokWa);
10441                                                                 } break;
10442                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: {
10443                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.DisableDisplayCcsCompression)>(*tokWa);
10444                                                                 } break;
10445                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
10446                                                                     dst.GmmResourceInfoCommon.Surf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa);
10447                                                                 } break;
10448                                                                 };
10449                                                                 tokWa = tokWa + 1 + tokWa->valueDwordCount;
10450                                                             } else {
10451                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa);
10452                                                                 if (tokWa->flags.flag3IsMandatory) {
10453                                                                     return false;
10454                                                                 }
10455                                                                 tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10456                                                             }
10457                                                         }
10458                                                         WCH_ASSERT(tokWa == tokWaEnd);
10459                                                     } break;
10460                                                     };
10461                                                     tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10462                                                 }
10463                                             }
10464                                             WCH_ASSERT(tokFlags == tokFlagsEnd);
10465                                         } break;
10466                                         case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: {
10467                                             const TokenHeader *tokCachePolicy = varLen->getValue<TokenHeader>();
10468                                             const TokenHeader *tokCachePolicyEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10469                                             while (tokCachePolicy < tokCachePolicyEnd) {
10470                                                 if (false == tokCachePolicy->flags.flag4IsVariableLength) {
10471                                                     switch (tokCachePolicy->id) {
10472                                                     default:
10473                                                         if (tokCachePolicy->flags.flag3IsMandatory) {
10474                                                             return false;
10475                                                         }
10476                                                         break;
10477                                                     case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: {
10478                                                         dst.GmmResourceInfoCommon.Surf.CachePolicy.Usage = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.CachePolicy.Usage)>(*tokCachePolicy);
10479                                                     } break;
10480                                                     };
10481                                                     tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount;
10482                                                 } else {
10483                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCachePolicy);
10484                                                     if (tokCachePolicy->flags.flag3IsMandatory) {
10485                                                         return false;
10486                                                     }
10487                                                     tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10488                                                 }
10489                                             }
10490                                             WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd);
10491                                         } break;
10492                                         case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: {
10493                                             const TokenHeader *tokMSAA = varLen->getValue<TokenHeader>();
10494                                             const TokenHeader *tokMSAAEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10495                                             while (tokMSAA < tokMSAAEnd) {
10496                                                 if (false == tokMSAA->flags.flag4IsVariableLength) {
10497                                                     switch (tokMSAA->id) {
10498                                                     default:
10499                                                         if (tokMSAA->flags.flag3IsMandatory) {
10500                                                             return false;
10501                                                         }
10502                                                         break;
10503                                                     case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: {
10504                                                         dst.GmmResourceInfoCommon.Surf.MSAA.SamplePattern = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.MSAA.SamplePattern)>(*tokMSAA);
10505                                                     } break;
10506                                                     case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: {
10507                                                         dst.GmmResourceInfoCommon.Surf.MSAA.NumSamples = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.MSAA.NumSamples)>(*tokMSAA);
10508                                                     } break;
10509                                                     };
10510                                                     tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount;
10511                                                 } else {
10512                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMSAA);
10513                                                     if (tokMSAA->flags.flag3IsMandatory) {
10514                                                         return false;
10515                                                     }
10516                                                     tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10517                                                 }
10518                                             }
10519                                             WCH_ASSERT(tokMSAA == tokMSAAEnd);
10520                                         } break;
10521                                         case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: {
10522                                             const TokenHeader *tokAlignment = varLen->getValue<TokenHeader>();
10523                                             const TokenHeader *tokAlignmentEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10524                                             while (tokAlignment < tokAlignmentEnd) {
10525                                                 if (false == tokAlignment->flags.flag4IsVariableLength) {
10526                                                     switch (tokAlignment->id) {
10527                                                     default:
10528                                                         if (tokAlignment->flags.flag3IsMandatory) {
10529                                                             return false;
10530                                                         }
10531                                                         break;
10532                                                     case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: {
10533                                                         dst.GmmResourceInfoCommon.Surf.Alignment.ArraySpacingSingleLod = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.ArraySpacingSingleLod)>(*tokAlignment);
10534                                                     } break;
10535                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: {
10536                                                         dst.GmmResourceInfoCommon.Surf.Alignment.BaseAlignment = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.BaseAlignment)>(*tokAlignment);
10537                                                     } break;
10538                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: {
10539                                                         dst.GmmResourceInfoCommon.Surf.Alignment.HAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.HAlign)>(*tokAlignment);
10540                                                     } break;
10541                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: {
10542                                                         dst.GmmResourceInfoCommon.Surf.Alignment.VAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.VAlign)>(*tokAlignment);
10543                                                     } break;
10544                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: {
10545                                                         dst.GmmResourceInfoCommon.Surf.Alignment.DAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.DAlign)>(*tokAlignment);
10546                                                     } break;
10547                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: {
10548                                                         dst.GmmResourceInfoCommon.Surf.Alignment.MipTailStartLod = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.MipTailStartLod)>(*tokAlignment);
10549                                                     } break;
10550                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: {
10551                                                         dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipStartLod = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipStartLod)>(*tokAlignment);
10552                                                     } break;
10553                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: {
10554                                                         dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipWidth = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipWidth)>(*tokAlignment);
10555                                                     } break;
10556                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: {
10557                                                         dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.PackedMipHeight)>(*tokAlignment);
10558                                                     } break;
10559                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: {
10560                                                         dst.GmmResourceInfoCommon.Surf.Alignment.QPitch = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Alignment.QPitch)>(*tokAlignment);
10561                                                     } break;
10562                                                     };
10563                                                     tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount;
10564                                                 } else {
10565                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAlignment);
10566                                                     if (tokAlignment->flags.flag3IsMandatory) {
10567                                                         return false;
10568                                                     }
10569                                                     tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10570                                                 }
10571                                             }
10572                                             WCH_ASSERT(tokAlignment == tokAlignmentEnd);
10573                                         } break;
10574                                         case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: {
10575                                             const TokenHeader *tokOffsetInfo = varLen->getValue<TokenHeader>();
10576                                             const TokenHeader *tokOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10577                                             while (tokOffsetInfo < tokOffsetInfoEnd) {
10578                                                 if (false == tokOffsetInfo->flags.flag4IsVariableLength) {
10579                                                     if (tokOffsetInfo->flags.flag3IsMandatory) {
10580                                                         return false;
10581                                                     }
10582                                                     tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount;
10583                                                 } else {
10584                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOffsetInfo);
10585                                                     switch (tokOffsetInfo->id) {
10586                                                     default:
10587                                                         if (tokOffsetInfo->flags.flag3IsMandatory) {
10588                                                             return false;
10589                                                         }
10590                                                         break;
10591                                                     case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: {
10592                                                         const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>();
10593                                                         const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10594                                                         while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) {
10595                                                             if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) {
10596                                                                 switch (tokTexture3DOffsetInfo->id) {
10597                                                                 default:
10598                                                                     if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
10599                                                                         return false;
10600                                                                     }
10601                                                                     break;
10602                                                                 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: {
10603                                                                     dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo);
10604                                                                 } break;
10605                                                                 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
10606                                                                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>();
10607                                                                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes();
10608                                                                     if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset)) {
10609                                                                         return false;
10610                                                                     }
10611                                                                     WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture3DOffsetInfo.Offset));
10612                                                                 } break;
10613                                                                 };
10614                                                                 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount;
10615                                                             } else {
10616                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo);
10617                                                                 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
10618                                                                     return false;
10619                                                                 }
10620                                                                 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10621                                                             }
10622                                                         }
10623                                                         WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd);
10624                                                     } break;
10625                                                     case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: {
10626                                                         const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>();
10627                                                         const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10628                                                         while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) {
10629                                                             if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) {
10630                                                                 switch (tokTexture2DOffsetInfo->id) {
10631                                                                 default:
10632                                                                     if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
10633                                                                         return false;
10634                                                                     }
10635                                                                     break;
10636                                                                 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: {
10637                                                                     dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo);
10638                                                                 } break;
10639                                                                 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: {
10640                                                                     dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo);
10641                                                                 } break;
10642                                                                 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
10643                                                                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>();
10644                                                                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes();
10645                                                                     if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset)) {
10646                                                                         return false;
10647                                                                     }
10648                                                                     WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Texture2DOffsetInfo.Offset));
10649                                                                 } break;
10650                                                                 };
10651                                                                 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount;
10652                                                             } else {
10653                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo);
10654                                                                 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
10655                                                                     return false;
10656                                                                 }
10657                                                                 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10658                                                             }
10659                                                         }
10660                                                         WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd);
10661                                                     } break;
10662                                                     case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: {
10663                                                         const TokenHeader *tokPlane = varLen->getValue<TokenHeader>();
10664                                                         const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10665                                                         while (tokPlane < tokPlaneEnd) {
10666                                                             if (false == tokPlane->flags.flag4IsVariableLength) {
10667                                                                 switch (tokPlane->id) {
10668                                                                 default:
10669                                                                     if (tokPlane->flags.flag3IsMandatory) {
10670                                                                         return false;
10671                                                                     }
10672                                                                     break;
10673                                                                 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: {
10674                                                                     dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.ArrayQPitch = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.ArrayQPitch)>(*tokPlane);
10675                                                                 } break;
10676                                                                 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: {
10677                                                                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
10678                                                                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
10679                                                                     if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X)) {
10680                                                                         return false;
10681                                                                     }
10682                                                                     WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.X));
10683                                                                 } break;
10684                                                                 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: {
10685                                                                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
10686                                                                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
10687                                                                     if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y)) {
10688                                                                         return false;
10689                                                                     }
10690                                                                     WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.Y));
10691                                                                 } break;
10692                                                                 case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: {
10693                                                                     dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.NoOfPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.NoOfPlanes)>(*tokPlane);
10694                                                                 } break;
10695                                                                 case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: {
10696                                                                     dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.IsTileAlignedPlanes)>(*tokPlane);
10697                                                                 } break;
10698                                                                 };
10699                                                                 tokPlane = tokPlane + 1 + tokPlane->valueDwordCount;
10700                                                             } else {
10701                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane);
10702                                                                 switch (tokPlane->id) {
10703                                                                 default:
10704                                                                     if (tokPlane->flags.flag3IsMandatory) {
10705                                                                         return false;
10706                                                                     }
10707                                                                     break;
10708                                                                 case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: {
10709                                                                     const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>();
10710                                                                     const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10711                                                                     while (tokUnAligned < tokUnAlignedEnd) {
10712                                                                         if (false == tokUnAligned->flags.flag4IsVariableLength) {
10713                                                                             switch (tokUnAligned->id) {
10714                                                                             default:
10715                                                                                 if (tokUnAligned->flags.flag3IsMandatory) {
10716                                                                                     return false;
10717                                                                                 }
10718                                                                                 break;
10719                                                                             case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: {
10720                                                                                 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>();
10721                                                                                 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes();
10722                                                                                 if (srcSize < sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.UnAligned.Height)) {
10723                                                                                     return false;
10724                                                                                 }
10725                                                                                 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.GmmResourceInfoCommon.Surf.OffsetInfo.Plane.UnAligned.Height));
10726                                                                             } break;
10727                                                                             };
10728                                                                             tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount;
10729                                                                         } else {
10730                                                                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned);
10731                                                                             if (tokUnAligned->flags.flag3IsMandatory) {
10732                                                                                 return false;
10733                                                                             }
10734                                                                             tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10735                                                                         }
10736                                                                     }
10737                                                                     WCH_ASSERT(tokUnAligned == tokUnAlignedEnd);
10738                                                                 } break;
10739                                                                 };
10740                                                                 tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10741                                                             }
10742                                                         }
10743                                                         WCH_ASSERT(tokPlane == tokPlaneEnd);
10744                                                     } break;
10745                                                     };
10746                                                     tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10747                                                 }
10748                                             }
10749                                             WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd);
10750                                         } break;
10751                                         case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: {
10752                                             const TokenHeader *tokS3d = varLen->getValue<TokenHeader>();
10753                                             const TokenHeader *tokS3dEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10754                                             while (tokS3d < tokS3dEnd) {
10755                                                 if (false == tokS3d->flags.flag4IsVariableLength) {
10756                                                     switch (tokS3d->id) {
10757                                                     default:
10758                                                         if (tokS3d->flags.flag3IsMandatory) {
10759                                                             return false;
10760                                                         }
10761                                                         break;
10762                                                     case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: {
10763                                                         dst.GmmResourceInfoCommon.Surf.S3d.DisplayModeHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.S3d.DisplayModeHeight)>(*tokS3d);
10764                                                     } break;
10765                                                     case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: {
10766                                                         dst.GmmResourceInfoCommon.Surf.S3d.NumBlankActiveLines = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.S3d.NumBlankActiveLines)>(*tokS3d);
10767                                                     } break;
10768                                                     case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: {
10769                                                         dst.GmmResourceInfoCommon.Surf.S3d.RFrameOffset = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.S3d.RFrameOffset)>(*tokS3d);
10770                                                     } break;
10771                                                     case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: {
10772                                                         dst.GmmResourceInfoCommon.Surf.S3d.BlankAreaOffset = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.S3d.BlankAreaOffset)>(*tokS3d);
10773                                                     } break;
10774                                                     case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: {
10775                                                         dst.GmmResourceInfoCommon.Surf.S3d.TallBufferHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.S3d.TallBufferHeight)>(*tokS3d);
10776                                                     } break;
10777                                                     case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: {
10778                                                         dst.GmmResourceInfoCommon.Surf.S3d.TallBufferSize = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.S3d.TallBufferSize)>(*tokS3d);
10779                                                     } break;
10780                                                     case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: {
10781                                                         dst.GmmResourceInfoCommon.Surf.S3d.IsRFrame = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.S3d.IsRFrame)>(*tokS3d);
10782                                                     } break;
10783                                                     };
10784                                                     tokS3d = tokS3d + 1 + tokS3d->valueDwordCount;
10785                                                 } else {
10786                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokS3d);
10787                                                     if (tokS3d->flags.flag3IsMandatory) {
10788                                                         return false;
10789                                                     }
10790                                                     tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10791                                                 }
10792                                             }
10793                                             WCH_ASSERT(tokS3d == tokS3dEnd);
10794                                         } break;
10795                                         case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: {
10796                                             const TokenHeader *tokSegmentOverride = varLen->getValue<TokenHeader>();
10797                                             const TokenHeader *tokSegmentOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10798                                             while (tokSegmentOverride < tokSegmentOverrideEnd) {
10799                                                 if (false == tokSegmentOverride->flags.flag4IsVariableLength) {
10800                                                     switch (tokSegmentOverride->id) {
10801                                                     default:
10802                                                         if (tokSegmentOverride->flags.flag3IsMandatory) {
10803                                                             return false;
10804                                                         }
10805                                                         break;
10806                                                     case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: {
10807                                                         dst.GmmResourceInfoCommon.Surf.SegmentOverride.Seg1 = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.SegmentOverride.Seg1)>(*tokSegmentOverride);
10808                                                     } break;
10809                                                     case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: {
10810                                                         dst.GmmResourceInfoCommon.Surf.SegmentOverride.Evict = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.SegmentOverride.Evict)>(*tokSegmentOverride);
10811                                                     } break;
10812                                                     };
10813                                                     tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount;
10814                                                 } else {
10815                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSegmentOverride);
10816                                                     if (tokSegmentOverride->flags.flag3IsMandatory) {
10817                                                         return false;
10818                                                     }
10819                                                     tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10820                                                 }
10821                                             }
10822                                             WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd);
10823                                         } break;
10824                                         case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: {
10825 #if _DEBUG || _RELEASE_INTERNAL
10826                                             const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>();
10827                                             const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10828                                             while (tokPlatform < tokPlatformEnd) {
10829                                                 if (false == tokPlatform->flags.flag4IsVariableLength) {
10830                                                     switch (tokPlatform->id) {
10831                                                     default:
10832                                                         if (tokPlatform->flags.flag3IsMandatory) {
10833                                                             return false;
10834                                                         }
10835                                                         break;
10836                                                     case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
10837                                                         dst.GmmResourceInfoCommon.Surf.Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.eProductFamily)>(*tokPlatform);
10838                                                     } break;
10839                                                     case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
10840                                                         dst.GmmResourceInfoCommon.Surf.Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.ePCHProductFamily)>(*tokPlatform);
10841                                                     } break;
10842                                                     case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
10843                                                         dst.GmmResourceInfoCommon.Surf.Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.eDisplayCoreFamily)>(*tokPlatform);
10844                                                     } break;
10845                                                     case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
10846                                                         dst.GmmResourceInfoCommon.Surf.Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.eRenderCoreFamily)>(*tokPlatform);
10847                                                     } break;
10848                                                     case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
10849                                                         dst.GmmResourceInfoCommon.Surf.Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.ePlatformType)>(*tokPlatform);
10850                                                     } break;
10851                                                     case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
10852                                                         dst.GmmResourceInfoCommon.Surf.Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.usDeviceID)>(*tokPlatform);
10853                                                     } break;
10854                                                     case TOK_FBW_PLATFORM_STR__US_REV_ID: {
10855                                                         dst.GmmResourceInfoCommon.Surf.Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.usRevId)>(*tokPlatform);
10856                                                     } break;
10857                                                     case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
10858                                                         dst.GmmResourceInfoCommon.Surf.Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.usDeviceID_PCH)>(*tokPlatform);
10859                                                     } break;
10860                                                     case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
10861                                                         dst.GmmResourceInfoCommon.Surf.Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.usRevId_PCH)>(*tokPlatform);
10862                                                     } break;
10863                                                     case TOK_FE_PLATFORM_STR__E_GTTYPE: {
10864                                                         dst.GmmResourceInfoCommon.Surf.Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.Platform.eGTType)>(*tokPlatform);
10865                                                     } break;
10866                                                     };
10867                                                     tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount;
10868                                                 } else {
10869                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform);
10870                                                     if (tokPlatform->flags.flag3IsMandatory) {
10871                                                         return false;
10872                                                     }
10873                                                     tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10874                                                 }
10875                                             }
10876                                             WCH_ASSERT(tokPlatform == tokPlatformEnd);
10877 #endif
10878                                         } break;
10879                                         case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: {
10880                                             const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>();
10881                                             const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10882                                             while (tokExistingSysMem < tokExistingSysMemEnd) {
10883                                                 if (false == tokExistingSysMem->flags.flag4IsVariableLength) {
10884                                                     switch (tokExistingSysMem->id) {
10885                                                     default:
10886                                                         if (tokExistingSysMem->flags.flag3IsMandatory) {
10887                                                             return false;
10888                                                         }
10889                                                         break;
10890                                                     case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: {
10891                                                         dst.GmmResourceInfoCommon.Surf.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem);
10892                                                     } break;
10893                                                     case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: {
10894                                                         dst.GmmResourceInfoCommon.Surf.ExistingSysMem.IsPageAligned = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.ExistingSysMem.IsPageAligned)>(*tokExistingSysMem);
10895                                                     } break;
10896                                                     };
10897                                                     tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount;
10898                                                 } else {
10899                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem);
10900                                                     if (tokExistingSysMem->flags.flag3IsMandatory) {
10901                                                         return false;
10902                                                     }
10903                                                     tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10904                                                 }
10905                                             }
10906                                             WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd);
10907                                         } break;
10908                                         case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: {
10909 #if !(_DEBUG || _RELEASE_INTERNAL)
10910                                             const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>();
10911                                             const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10912                                             while (tok__Platform < tok__PlatformEnd) {
10913                                                 if (false == tok__Platform->flags.flag4IsVariableLength) {
10914                                                     switch (tok__Platform->id) {
10915                                                     default:
10916                                                         if (tok__Platform->flags.flag3IsMandatory) {
10917                                                             return false;
10918                                                         }
10919                                                         break;
10920                                                     case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
10921                                                         dst.GmmResourceInfoCommon.Surf.__Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eProductFamily)>(*tok__Platform);
10922                                                     } break;
10923                                                     case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
10924                                                         dst.GmmResourceInfoCommon.Surf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.ePCHProductFamily)>(*tok__Platform);
10925                                                     } break;
10926                                                     case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
10927                                                         dst.GmmResourceInfoCommon.Surf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eDisplayCoreFamily)>(*tok__Platform);
10928                                                     } break;
10929                                                     case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
10930                                                         dst.GmmResourceInfoCommon.Surf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eRenderCoreFamily)>(*tok__Platform);
10931                                                     } break;
10932                                                     case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
10933                                                         dst.GmmResourceInfoCommon.Surf.__Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.ePlatformType)>(*tok__Platform);
10934                                                     } break;
10935                                                     case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
10936                                                         dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID)>(*tok__Platform);
10937                                                     } break;
10938                                                     case TOK_FBW_PLATFORM_STR__US_REV_ID: {
10939                                                         dst.GmmResourceInfoCommon.Surf.__Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usRevId)>(*tok__Platform);
10940                                                     } break;
10941                                                     case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
10942                                                         dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usDeviceID_PCH)>(*tok__Platform);
10943                                                     } break;
10944                                                     case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
10945                                                         dst.GmmResourceInfoCommon.Surf.__Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.usRevId_PCH)>(*tok__Platform);
10946                                                     } break;
10947                                                     case TOK_FE_PLATFORM_STR__E_GTTYPE: {
10948                                                         dst.GmmResourceInfoCommon.Surf.__Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.Surf.__Platform.eGTType)>(*tok__Platform);
10949                                                     } break;
10950                                                     };
10951                                                     tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount;
10952                                                 } else {
10953                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform);
10954                                                     if (tok__Platform->flags.flag3IsMandatory) {
10955                                                         return false;
10956                                                     }
10957                                                     tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10958                                                 }
10959                                             }
10960                                             WCH_ASSERT(tok__Platform == tok__PlatformEnd);
10961 #endif
10962                                         } break;
10963                                         };
10964                                         tokSurf = tokSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
10965                                     }
10966                                 }
10967                                 WCH_ASSERT(tokSurf == tokSurfEnd);
10968                             } break;
10969                             case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SURF: {
10970                                 const TokenHeader *tokAuxSurf = varLen->getValue<TokenHeader>();
10971                                 const TokenHeader *tokAuxSurfEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
10972                                 while (tokAuxSurf < tokAuxSurfEnd) {
10973                                     if (false == tokAuxSurf->flags.flag4IsVariableLength) {
10974                                         switch (tokAuxSurf->id) {
10975                                         default:
10976                                             if (tokAuxSurf->flags.flag3IsMandatory) {
10977                                                 return false;
10978                                             }
10979                                             break;
10980                                         case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: {
10981                                             dst.GmmResourceInfoCommon.AuxSurf.Type = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Type)>(*tokAuxSurf);
10982                                         } break;
10983                                         case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: {
10984                                             dst.GmmResourceInfoCommon.AuxSurf.Format = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Format)>(*tokAuxSurf);
10985                                         } break;
10986                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: {
10987                                             dst.GmmResourceInfoCommon.AuxSurf.BitsPerPixel = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.BitsPerPixel)>(*tokAuxSurf);
10988                                         } break;
10989                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: {
10990                                             dst.GmmResourceInfoCommon.AuxSurf.BaseWidth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.BaseWidth)>(*tokAuxSurf);
10991                                         } break;
10992                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: {
10993                                             dst.GmmResourceInfoCommon.AuxSurf.BaseHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.BaseHeight)>(*tokAuxSurf);
10994                                         } break;
10995                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: {
10996                                             dst.GmmResourceInfoCommon.AuxSurf.Depth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Depth)>(*tokAuxSurf);
10997                                         } break;
10998                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: {
10999                                             dst.GmmResourceInfoCommon.AuxSurf.MaxLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.MaxLod)>(*tokAuxSurf);
11000                                         } break;
11001                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: {
11002                                             dst.GmmResourceInfoCommon.AuxSurf.ArraySize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.ArraySize)>(*tokAuxSurf);
11003                                         } break;
11004                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: {
11005                                             dst.GmmResourceInfoCommon.AuxSurf.CpTag = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.CpTag)>(*tokAuxSurf);
11006                                         } break;
11007                                         case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: {
11008                                             auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValue<char>();
11009                                             auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValueSizeInBytes();
11010                                             if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcMode)) {
11011                                                 return false;
11012                                             }
11013                                             WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.MmcMode, sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcMode), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcMode));
11014                                         } break;
11015                                         case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: {
11016                                             auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValue<char>();
11017                                             auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSurf).getValueSizeInBytes();
11018                                             if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcHint)) {
11019                                                 return false;
11020                                             }
11021                                             WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.MmcHint, sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcHint), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.MmcHint));
11022                                         } break;
11023                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: {
11024                                             dst.GmmResourceInfoCommon.AuxSurf.Pitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Pitch)>(*tokAuxSurf);
11025                                         } break;
11026                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: {
11027                                             dst.GmmResourceInfoCommon.AuxSurf.OverridePitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.OverridePitch)>(*tokAuxSurf);
11028                                         } break;
11029                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: {
11030                                             dst.GmmResourceInfoCommon.AuxSurf.Size = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Size)>(*tokAuxSurf);
11031                                         } break;
11032                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: {
11033                                             dst.GmmResourceInfoCommon.AuxSurf.CCSize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.CCSize)>(*tokAuxSurf);
11034                                         } break;
11035                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: {
11036                                             dst.GmmResourceInfoCommon.AuxSurf.UnpaddedSize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.UnpaddedSize)>(*tokAuxSurf);
11037                                         } break;
11038                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: {
11039                                             dst.GmmResourceInfoCommon.AuxSurf.SizeReportToOS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.SizeReportToOS)>(*tokAuxSurf);
11040                                         } break;
11041                                         case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: {
11042                                             dst.GmmResourceInfoCommon.AuxSurf.TileMode = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.TileMode)>(*tokAuxSurf);
11043                                         } break;
11044                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: {
11045                                             dst.GmmResourceInfoCommon.AuxSurf.CCSModeAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.CCSModeAlign)>(*tokAuxSurf);
11046                                         } break;
11047                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: {
11048                                             dst.GmmResourceInfoCommon.AuxSurf.LegacyFlags = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.LegacyFlags)>(*tokAuxSurf);
11049                                         } break;
11050                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: {
11051                                             dst.GmmResourceInfoCommon.AuxSurf.MaximumRenamingListLength = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.MaximumRenamingListLength)>(*tokAuxSurf);
11052                                         } break;
11053                                         };
11054                                         tokAuxSurf = tokAuxSurf + 1 + tokAuxSurf->valueDwordCount;
11055                                     } else {
11056                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAuxSurf);
11057                                         switch (tokAuxSurf->id) {
11058                                         default:
11059                                             if (tokAuxSurf->flags.flag3IsMandatory) {
11060                                                 return false;
11061                                             }
11062                                             break;
11063                                         case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: {
11064                                             const TokenHeader *tokFlags = varLen->getValue<TokenHeader>();
11065                                             const TokenHeader *tokFlagsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11066                                             while (tokFlags < tokFlagsEnd) {
11067                                                 if (false == tokFlags->flags.flag4IsVariableLength) {
11068                                                     if (tokFlags->flags.flag3IsMandatory) {
11069                                                         return false;
11070                                                     }
11071                                                     tokFlags = tokFlags + 1 + tokFlags->valueDwordCount;
11072                                                 } else {
11073                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokFlags);
11074                                                     switch (tokFlags->id) {
11075                                                     default:
11076                                                         if (tokFlags->flags.flag3IsMandatory) {
11077                                                             return false;
11078                                                         }
11079                                                         break;
11080                                                     case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: {
11081                                                         const TokenHeader *tokGpu = varLen->getValue<TokenHeader>();
11082                                                         const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11083                                                         while (tokGpu < tokGpuEnd) {
11084                                                             if (false == tokGpu->flags.flag4IsVariableLength) {
11085                                                                 switch (tokGpu->id) {
11086                                                                 default:
11087                                                                     if (tokGpu->flags.flag3IsMandatory) {
11088                                                                         return false;
11089                                                                     }
11090                                                                     break;
11091                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: {
11092                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.CameraCapture = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.CameraCapture)>(*tokGpu);
11093                                                                 } break;
11094                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: {
11095                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.CCS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.CCS)>(*tokGpu);
11096                                                                 } break;
11097                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: {
11098                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorDiscard = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorDiscard)>(*tokGpu);
11099                                                                 } break;
11100                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: {
11101                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorSeparation = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorSeparation)>(*tokGpu);
11102                                                                 } break;
11103                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: {
11104                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ColorSeparationRGBX)>(*tokGpu);
11105                                                                 } break;
11106                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: {
11107                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Constant = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Constant)>(*tokGpu);
11108                                                                 } break;
11109                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: {
11110                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Depth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Depth)>(*tokGpu);
11111                                                                 } break;
11112                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: {
11113                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.FlipChain = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.FlipChain)>(*tokGpu);
11114                                                                 } break;
11115                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: {
11116                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.FlipChainPreferred = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.FlipChainPreferred)>(*tokGpu);
11117                                                                 } break;
11118                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: {
11119                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.HistoryBuffer = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.HistoryBuffer)>(*tokGpu);
11120                                                                 } break;
11121                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: {
11122                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.HiZ = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.HiZ)>(*tokGpu);
11123                                                                 } break;
11124                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: {
11125                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Index = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Index)>(*tokGpu);
11126                                                                 } break;
11127                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: {
11128                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.IndirectClearColor = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.IndirectClearColor)>(*tokGpu);
11129                                                                 } break;
11130                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: {
11131                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.InstructionFlat = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.InstructionFlat)>(*tokGpu);
11132                                                                 } break;
11133                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: {
11134                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.InterlacedScan = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.InterlacedScan)>(*tokGpu);
11135                                                                 } break;
11136                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: {
11137                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MCS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MCS)>(*tokGpu);
11138                                                                 } break;
11139                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: {
11140                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MMC = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MMC)>(*tokGpu);
11141                                                                 } break;
11142                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: {
11143                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MotionComp = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.MotionComp)>(*tokGpu);
11144                                                                 } break;
11145                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: {
11146                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.NoRestriction = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.NoRestriction)>(*tokGpu);
11147                                                                 } break;
11148                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: {
11149                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Overlay = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Overlay)>(*tokGpu);
11150                                                                 } break;
11151                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: {
11152                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Presentable = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Presentable)>(*tokGpu);
11153                                                                 } break;
11154                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: {
11155                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ProceduralTexture = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ProceduralTexture)>(*tokGpu);
11156                                                                 } break;
11157                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: {
11158                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Query = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Query)>(*tokGpu);
11159                                                                 } break;
11160                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: {
11161                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.RenderTarget = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.RenderTarget)>(*tokGpu);
11162                                                                 } break;
11163                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: {
11164                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.S3d = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.S3d)>(*tokGpu);
11165                                                                 } break;
11166                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: {
11167                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.S3dDx = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.S3dDx)>(*tokGpu);
11168                                                                 } break;
11169                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: {
11170                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__S3dNonPacked = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__S3dNonPacked)>(*tokGpu);
11171                                                                 } break;
11172                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: {
11173                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__S3dWidi = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__S3dWidi)>(*tokGpu);
11174                                                                 } break;
11175                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: {
11176                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ScratchFlat = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.ScratchFlat)>(*tokGpu);
11177                                                                 } break;
11178                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: {
11179                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.SeparateStencil = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.SeparateStencil)>(*tokGpu);
11180                                                                 } break;
11181                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: {
11182                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.State = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.State)>(*tokGpu);
11183                                                                 } break;
11184                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: {
11185                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.StateDx9ConstantBuffer)>(*tokGpu);
11186                                                                 } break;
11187                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: {
11188                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Stream = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Stream)>(*tokGpu);
11189                                                                 } break;
11190                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: {
11191                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TextApi = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TextApi)>(*tokGpu);
11192                                                                 } break;
11193                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: {
11194                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Texture = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Texture)>(*tokGpu);
11195                                                                 } break;
11196                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: {
11197                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TiledResource = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TiledResource)>(*tokGpu);
11198                                                                 } break;
11199                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: {
11200                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TilePool = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.TilePool)>(*tokGpu);
11201                                                                 } break;
11202                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: {
11203                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.UnifiedAuxSurface)>(*tokGpu);
11204                                                                 } break;
11205                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: {
11206                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Vertex = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Vertex)>(*tokGpu);
11207                                                                 } break;
11208                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: {
11209                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Video = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.Video)>(*tokGpu);
11210                                                                 } break;
11211                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: {
11212                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaTileXCcs)>(*tokGpu);
11213                                                                 } break;
11214                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: {
11215                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaTileYCcs)>(*tokGpu);
11216                                                                 } break;
11217                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: {
11218                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__MsaaTileMcs)>(*tokGpu);
11219                                                                 } break;
11220                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: {
11221                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__NonMsaaLinearCCS)>(*tokGpu);
11222                                                                 } break;
11223                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: {
11224                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__Remaining = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Gpu.__Remaining)>(*tokGpu);
11225                                                                 } break;
11226                                                                 };
11227                                                                 tokGpu = tokGpu + 1 + tokGpu->valueDwordCount;
11228                                                             } else {
11229                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu);
11230                                                                 if (tokGpu->flags.flag3IsMandatory) {
11231                                                                     return false;
11232                                                                 }
11233                                                                 tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11234                                                             }
11235                                                         }
11236                                                         WCH_ASSERT(tokGpu == tokGpuEnd);
11237                                                     } break;
11238                                                     case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: {
11239                                                         const TokenHeader *tokInfo = varLen->getValue<TokenHeader>();
11240                                                         const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11241                                                         while (tokInfo < tokInfoEnd) {
11242                                                             if (false == tokInfo->flags.flag4IsVariableLength) {
11243                                                                 switch (tokInfo->id) {
11244                                                                 default:
11245                                                                     if (tokInfo->flags.flag3IsMandatory) {
11246                                                                         return false;
11247                                                                     }
11248                                                                     break;
11249                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: {
11250                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.AllowVirtualPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.AllowVirtualPadding)>(*tokInfo);
11251                                                                 } break;
11252                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: {
11253                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.BigPage = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.BigPage)>(*tokInfo);
11254                                                                 } break;
11255                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: {
11256                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Cacheable = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Cacheable)>(*tokInfo);
11257                                                                 } break;
11258                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: {
11259                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ContigPhysMemoryForiDART)>(*tokInfo);
11260                                                                 } break;
11261                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: {
11262                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.CornerTexelMode = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.CornerTexelMode)>(*tokInfo);
11263                                                                 } break;
11264                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: {
11265                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ExistingSysMem = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ExistingSysMem)>(*tokInfo);
11266                                                                 } break;
11267                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: {
11268                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ForceResidency = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.ForceResidency)>(*tokInfo);
11269                                                                 } break;
11270                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: {
11271                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Gfdt = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Gfdt)>(*tokInfo);
11272                                                                 } break;
11273                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: {
11274                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.GttMapType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.GttMapType)>(*tokInfo);
11275                                                                 } break;
11276                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: {
11277                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.HardwareProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.HardwareProtected)>(*tokInfo);
11278                                                                 } break;
11279                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: {
11280                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.KernelModeMapped = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.KernelModeMapped)>(*tokInfo);
11281                                                                 } break;
11282                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: {
11283                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutBelow = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutBelow)>(*tokInfo);
11284                                                                 } break;
11285                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: {
11286                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutMono = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutMono)>(*tokInfo);
11287                                                                 } break;
11288                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: {
11289                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutRight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LayoutRight)>(*tokInfo);
11290                                                                 } break;
11291                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: {
11292                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LocalOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.LocalOnly)>(*tokInfo);
11293                                                                 } break;
11294                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: {
11295                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Linear = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Linear)>(*tokInfo);
11296                                                                 } break;
11297                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: {
11298                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.MediaCompressed = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.MediaCompressed)>(*tokInfo);
11299                                                                 } break;
11300                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: {
11301                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NoOptimizationPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NoOptimizationPadding)>(*tokInfo);
11302                                                                 } break;
11303                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: {
11304                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NoPhysMemory = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NoPhysMemory)>(*tokInfo);
11305                                                                 } break;
11306                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: {
11307                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NotLockable = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NotLockable)>(*tokInfo);
11308                                                                 } break;
11309                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: {
11310                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NonLocalOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.NonLocalOnly)>(*tokInfo);
11311                                                                 } break;
11312                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: {
11313                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.StdSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.StdSwizzle)>(*tokInfo);
11314                                                                 } break;
11315                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: {
11316                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.PseudoStdSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.PseudoStdSwizzle)>(*tokInfo);
11317                                                                 } break;
11318                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: {
11319                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Undefined64KBSwizzle)>(*tokInfo);
11320                                                                 } break;
11321                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: {
11322                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.RedecribedPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.RedecribedPlanes)>(*tokInfo);
11323                                                                 } break;
11324                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: {
11325                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.RenderCompressed = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.RenderCompressed)>(*tokInfo);
11326                                                                 } break;
11327                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: {
11328                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Rotated = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Rotated)>(*tokInfo);
11329                                                                 } break;
11330                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: {
11331                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Shared = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Shared)>(*tokInfo);
11332                                                                 } break;
11333                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: {
11334                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.SoftwareProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.SoftwareProtected)>(*tokInfo);
11335                                                                 } break;
11336                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: {
11337                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.SVM = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.SVM)>(*tokInfo);
11338                                                                 } break;
11339                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: {
11340                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Tile4 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Tile4)>(*tokInfo);
11341                                                                 } break;
11342                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: {
11343                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Tile64 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.Tile64)>(*tokInfo);
11344                                                                 } break;
11345                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: {
11346                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledW = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledW)>(*tokInfo);
11347                                                                 } break;
11348                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: {
11349                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledX = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledX)>(*tokInfo);
11350                                                                 } break;
11351                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: {
11352                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledY = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledY)>(*tokInfo);
11353                                                                 } break;
11354                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: {
11355                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledYf = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledYf)>(*tokInfo);
11356                                                                 } break;
11357                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: {
11358                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledYs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.TiledYs)>(*tokInfo);
11359                                                                 } break;
11360                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: {
11361                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.WddmProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.WddmProtected)>(*tokInfo);
11362                                                                 } break;
11363                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: {
11364                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.XAdapter = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.XAdapter)>(*tokInfo);
11365                                                                 } break;
11366                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: {
11367                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.__PreallocatedResInfo = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.__PreallocatedResInfo)>(*tokInfo);
11368                                                                 } break;
11369                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: {
11370                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.__PreWddm2SVM = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Info.__PreWddm2SVM)>(*tokInfo);
11371                                                                 } break;
11372                                                                 };
11373                                                                 tokInfo = tokInfo + 1 + tokInfo->valueDwordCount;
11374                                                             } else {
11375                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo);
11376                                                                 if (tokInfo->flags.flag3IsMandatory) {
11377                                                                     return false;
11378                                                                 }
11379                                                                 tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11380                                                             }
11381                                                         }
11382                                                         WCH_ASSERT(tokInfo == tokInfoEnd);
11383                                                     } break;
11384                                                     case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: {
11385                                                         const TokenHeader *tokWa = varLen->getValue<TokenHeader>();
11386                                                         const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11387                                                         while (tokWa < tokWaEnd) {
11388                                                             if (false == tokWa->flags.flag4IsVariableLength) {
11389                                                                 switch (tokWa->id) {
11390                                                                 default:
11391                                                                     if (tokWa->flags.flag3IsMandatory) {
11392                                                                         return false;
11393                                                                     }
11394                                                                     break;
11395                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: {
11396                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa);
11397                                                                 } break;
11398                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: {
11399                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa);
11400                                                                 } break;
11401                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: {
11402                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa);
11403                                                                 } break;
11404                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: {
11405                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.NoBufferSamplerPadding)>(*tokWa);
11406                                                                 } break;
11407                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: {
11408                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa);
11409                                                                 } break;
11410                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: {
11411                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.CHVAstcSkipVirtualMips)>(*tokWa);
11412                                                                 } break;
11413                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: {
11414                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisablePackedMipTail = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisablePackedMipTail)>(*tokWa);
11415                                                                 } break;
11416                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: {
11417                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.__ForceOtherHVALIGN4)>(*tokWa);
11418                                                                 } break;
11419                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: {
11420                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsClearColor)>(*tokWa);
11421                                                                 } break;
11422                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: {
11423                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.DisableDisplayCcsCompression)>(*tokWa);
11424                                                                 } break;
11425                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
11426                                                                     dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa);
11427                                                                 } break;
11428                                                                 };
11429                                                                 tokWa = tokWa + 1 + tokWa->valueDwordCount;
11430                                                             } else {
11431                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa);
11432                                                                 if (tokWa->flags.flag3IsMandatory) {
11433                                                                     return false;
11434                                                                 }
11435                                                                 tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11436                                                             }
11437                                                         }
11438                                                         WCH_ASSERT(tokWa == tokWaEnd);
11439                                                     } break;
11440                                                     };
11441                                                     tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11442                                                 }
11443                                             }
11444                                             WCH_ASSERT(tokFlags == tokFlagsEnd);
11445                                         } break;
11446                                         case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: {
11447                                             const TokenHeader *tokCachePolicy = varLen->getValue<TokenHeader>();
11448                                             const TokenHeader *tokCachePolicyEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11449                                             while (tokCachePolicy < tokCachePolicyEnd) {
11450                                                 if (false == tokCachePolicy->flags.flag4IsVariableLength) {
11451                                                     switch (tokCachePolicy->id) {
11452                                                     default:
11453                                                         if (tokCachePolicy->flags.flag3IsMandatory) {
11454                                                             return false;
11455                                                         }
11456                                                         break;
11457                                                     case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: {
11458                                                         dst.GmmResourceInfoCommon.AuxSurf.CachePolicy.Usage = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.CachePolicy.Usage)>(*tokCachePolicy);
11459                                                     } break;
11460                                                     };
11461                                                     tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount;
11462                                                 } else {
11463                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCachePolicy);
11464                                                     if (tokCachePolicy->flags.flag3IsMandatory) {
11465                                                         return false;
11466                                                     }
11467                                                     tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11468                                                 }
11469                                             }
11470                                             WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd);
11471                                         } break;
11472                                         case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: {
11473                                             const TokenHeader *tokMSAA = varLen->getValue<TokenHeader>();
11474                                             const TokenHeader *tokMSAAEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11475                                             while (tokMSAA < tokMSAAEnd) {
11476                                                 if (false == tokMSAA->flags.flag4IsVariableLength) {
11477                                                     switch (tokMSAA->id) {
11478                                                     default:
11479                                                         if (tokMSAA->flags.flag3IsMandatory) {
11480                                                             return false;
11481                                                         }
11482                                                         break;
11483                                                     case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: {
11484                                                         dst.GmmResourceInfoCommon.AuxSurf.MSAA.SamplePattern = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.MSAA.SamplePattern)>(*tokMSAA);
11485                                                     } break;
11486                                                     case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: {
11487                                                         dst.GmmResourceInfoCommon.AuxSurf.MSAA.NumSamples = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.MSAA.NumSamples)>(*tokMSAA);
11488                                                     } break;
11489                                                     };
11490                                                     tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount;
11491                                                 } else {
11492                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMSAA);
11493                                                     if (tokMSAA->flags.flag3IsMandatory) {
11494                                                         return false;
11495                                                     }
11496                                                     tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11497                                                 }
11498                                             }
11499                                             WCH_ASSERT(tokMSAA == tokMSAAEnd);
11500                                         } break;
11501                                         case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: {
11502                                             const TokenHeader *tokAlignment = varLen->getValue<TokenHeader>();
11503                                             const TokenHeader *tokAlignmentEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11504                                             while (tokAlignment < tokAlignmentEnd) {
11505                                                 if (false == tokAlignment->flags.flag4IsVariableLength) {
11506                                                     switch (tokAlignment->id) {
11507                                                     default:
11508                                                         if (tokAlignment->flags.flag3IsMandatory) {
11509                                                             return false;
11510                                                         }
11511                                                         break;
11512                                                     case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: {
11513                                                         dst.GmmResourceInfoCommon.AuxSurf.Alignment.ArraySpacingSingleLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.ArraySpacingSingleLod)>(*tokAlignment);
11514                                                     } break;
11515                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: {
11516                                                         dst.GmmResourceInfoCommon.AuxSurf.Alignment.BaseAlignment = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.BaseAlignment)>(*tokAlignment);
11517                                                     } break;
11518                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: {
11519                                                         dst.GmmResourceInfoCommon.AuxSurf.Alignment.HAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.HAlign)>(*tokAlignment);
11520                                                     } break;
11521                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: {
11522                                                         dst.GmmResourceInfoCommon.AuxSurf.Alignment.VAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.VAlign)>(*tokAlignment);
11523                                                     } break;
11524                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: {
11525                                                         dst.GmmResourceInfoCommon.AuxSurf.Alignment.DAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.DAlign)>(*tokAlignment);
11526                                                     } break;
11527                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: {
11528                                                         dst.GmmResourceInfoCommon.AuxSurf.Alignment.MipTailStartLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.MipTailStartLod)>(*tokAlignment);
11529                                                     } break;
11530                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: {
11531                                                         dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipStartLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipStartLod)>(*tokAlignment);
11532                                                     } break;
11533                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: {
11534                                                         dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipWidth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipWidth)>(*tokAlignment);
11535                                                     } break;
11536                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: {
11537                                                         dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.PackedMipHeight)>(*tokAlignment);
11538                                                     } break;
11539                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: {
11540                                                         dst.GmmResourceInfoCommon.AuxSurf.Alignment.QPitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Alignment.QPitch)>(*tokAlignment);
11541                                                     } break;
11542                                                     };
11543                                                     tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount;
11544                                                 } else {
11545                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAlignment);
11546                                                     if (tokAlignment->flags.flag3IsMandatory) {
11547                                                         return false;
11548                                                     }
11549                                                     tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11550                                                 }
11551                                             }
11552                                             WCH_ASSERT(tokAlignment == tokAlignmentEnd);
11553                                         } break;
11554                                         case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: {
11555                                             const TokenHeader *tokOffsetInfo = varLen->getValue<TokenHeader>();
11556                                             const TokenHeader *tokOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11557                                             while (tokOffsetInfo < tokOffsetInfoEnd) {
11558                                                 if (false == tokOffsetInfo->flags.flag4IsVariableLength) {
11559                                                     if (tokOffsetInfo->flags.flag3IsMandatory) {
11560                                                         return false;
11561                                                     }
11562                                                     tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount;
11563                                                 } else {
11564                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOffsetInfo);
11565                                                     switch (tokOffsetInfo->id) {
11566                                                     default:
11567                                                         if (tokOffsetInfo->flags.flag3IsMandatory) {
11568                                                             return false;
11569                                                         }
11570                                                         break;
11571                                                     case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: {
11572                                                         const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>();
11573                                                         const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11574                                                         while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) {
11575                                                             if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) {
11576                                                                 switch (tokTexture3DOffsetInfo->id) {
11577                                                                 default:
11578                                                                     if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
11579                                                                         return false;
11580                                                                     }
11581                                                                     break;
11582                                                                 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: {
11583                                                                     dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo);
11584                                                                 } break;
11585                                                                 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
11586                                                                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>();
11587                                                                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes();
11588                                                                     if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset)) {
11589                                                                         return false;
11590                                                                     }
11591                                                                     WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture3DOffsetInfo.Offset));
11592                                                                 } break;
11593                                                                 };
11594                                                                 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount;
11595                                                             } else {
11596                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo);
11597                                                                 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
11598                                                                     return false;
11599                                                                 }
11600                                                                 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11601                                                             }
11602                                                         }
11603                                                         WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd);
11604                                                     } break;
11605                                                     case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: {
11606                                                         const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>();
11607                                                         const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11608                                                         while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) {
11609                                                             if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) {
11610                                                                 switch (tokTexture2DOffsetInfo->id) {
11611                                                                 default:
11612                                                                     if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
11613                                                                         return false;
11614                                                                     }
11615                                                                     break;
11616                                                                 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: {
11617                                                                     dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo);
11618                                                                 } break;
11619                                                                 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: {
11620                                                                     dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo);
11621                                                                 } break;
11622                                                                 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
11623                                                                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>();
11624                                                                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes();
11625                                                                     if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset)) {
11626                                                                         return false;
11627                                                                     }
11628                                                                     WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Texture2DOffsetInfo.Offset));
11629                                                                 } break;
11630                                                                 };
11631                                                                 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount;
11632                                                             } else {
11633                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo);
11634                                                                 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
11635                                                                     return false;
11636                                                                 }
11637                                                                 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11638                                                             }
11639                                                         }
11640                                                         WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd);
11641                                                     } break;
11642                                                     case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: {
11643                                                         const TokenHeader *tokPlane = varLen->getValue<TokenHeader>();
11644                                                         const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11645                                                         while (tokPlane < tokPlaneEnd) {
11646                                                             if (false == tokPlane->flags.flag4IsVariableLength) {
11647                                                                 switch (tokPlane->id) {
11648                                                                 default:
11649                                                                     if (tokPlane->flags.flag3IsMandatory) {
11650                                                                         return false;
11651                                                                     }
11652                                                                     break;
11653                                                                 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: {
11654                                                                     dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.ArrayQPitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.ArrayQPitch)>(*tokPlane);
11655                                                                 } break;
11656                                                                 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: {
11657                                                                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
11658                                                                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
11659                                                                     if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X)) {
11660                                                                         return false;
11661                                                                     }
11662                                                                     WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.X));
11663                                                                 } break;
11664                                                                 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: {
11665                                                                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
11666                                                                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
11667                                                                     if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y)) {
11668                                                                         return false;
11669                                                                     }
11670                                                                     WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.Y));
11671                                                                 } break;
11672                                                                 case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: {
11673                                                                     dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.NoOfPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.NoOfPlanes)>(*tokPlane);
11674                                                                 } break;
11675                                                                 case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: {
11676                                                                     dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.IsTileAlignedPlanes)>(*tokPlane);
11677                                                                 } break;
11678                                                                 };
11679                                                                 tokPlane = tokPlane + 1 + tokPlane->valueDwordCount;
11680                                                             } else {
11681                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane);
11682                                                                 switch (tokPlane->id) {
11683                                                                 default:
11684                                                                     if (tokPlane->flags.flag3IsMandatory) {
11685                                                                         return false;
11686                                                                     }
11687                                                                     break;
11688                                                                 case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: {
11689                                                                     const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>();
11690                                                                     const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11691                                                                     while (tokUnAligned < tokUnAlignedEnd) {
11692                                                                         if (false == tokUnAligned->flags.flag4IsVariableLength) {
11693                                                                             switch (tokUnAligned->id) {
11694                                                                             default:
11695                                                                                 if (tokUnAligned->flags.flag3IsMandatory) {
11696                                                                                     return false;
11697                                                                                 }
11698                                                                                 break;
11699                                                                             case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: {
11700                                                                                 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>();
11701                                                                                 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes();
11702                                                                                 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.UnAligned.Height)) {
11703                                                                                     return false;
11704                                                                                 }
11705                                                                                 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSurf.OffsetInfo.Plane.UnAligned.Height));
11706                                                                             } break;
11707                                                                             };
11708                                                                             tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount;
11709                                                                         } else {
11710                                                                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned);
11711                                                                             if (tokUnAligned->flags.flag3IsMandatory) {
11712                                                                                 return false;
11713                                                                             }
11714                                                                             tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11715                                                                         }
11716                                                                     }
11717                                                                     WCH_ASSERT(tokUnAligned == tokUnAlignedEnd);
11718                                                                 } break;
11719                                                                 };
11720                                                                 tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11721                                                             }
11722                                                         }
11723                                                         WCH_ASSERT(tokPlane == tokPlaneEnd);
11724                                                     } break;
11725                                                     };
11726                                                     tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11727                                                 }
11728                                             }
11729                                             WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd);
11730                                         } break;
11731                                         case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: {
11732                                             const TokenHeader *tokS3d = varLen->getValue<TokenHeader>();
11733                                             const TokenHeader *tokS3dEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11734                                             while (tokS3d < tokS3dEnd) {
11735                                                 if (false == tokS3d->flags.flag4IsVariableLength) {
11736                                                     switch (tokS3d->id) {
11737                                                     default:
11738                                                         if (tokS3d->flags.flag3IsMandatory) {
11739                                                             return false;
11740                                                         }
11741                                                         break;
11742                                                     case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: {
11743                                                         dst.GmmResourceInfoCommon.AuxSurf.S3d.DisplayModeHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.S3d.DisplayModeHeight)>(*tokS3d);
11744                                                     } break;
11745                                                     case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: {
11746                                                         dst.GmmResourceInfoCommon.AuxSurf.S3d.NumBlankActiveLines = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.S3d.NumBlankActiveLines)>(*tokS3d);
11747                                                     } break;
11748                                                     case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: {
11749                                                         dst.GmmResourceInfoCommon.AuxSurf.S3d.RFrameOffset = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.S3d.RFrameOffset)>(*tokS3d);
11750                                                     } break;
11751                                                     case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: {
11752                                                         dst.GmmResourceInfoCommon.AuxSurf.S3d.BlankAreaOffset = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.S3d.BlankAreaOffset)>(*tokS3d);
11753                                                     } break;
11754                                                     case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: {
11755                                                         dst.GmmResourceInfoCommon.AuxSurf.S3d.TallBufferHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.S3d.TallBufferHeight)>(*tokS3d);
11756                                                     } break;
11757                                                     case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: {
11758                                                         dst.GmmResourceInfoCommon.AuxSurf.S3d.TallBufferSize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.S3d.TallBufferSize)>(*tokS3d);
11759                                                     } break;
11760                                                     case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: {
11761                                                         dst.GmmResourceInfoCommon.AuxSurf.S3d.IsRFrame = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.S3d.IsRFrame)>(*tokS3d);
11762                                                     } break;
11763                                                     };
11764                                                     tokS3d = tokS3d + 1 + tokS3d->valueDwordCount;
11765                                                 } else {
11766                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokS3d);
11767                                                     if (tokS3d->flags.flag3IsMandatory) {
11768                                                         return false;
11769                                                     }
11770                                                     tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11771                                                 }
11772                                             }
11773                                             WCH_ASSERT(tokS3d == tokS3dEnd);
11774                                         } break;
11775                                         case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: {
11776                                             const TokenHeader *tokSegmentOverride = varLen->getValue<TokenHeader>();
11777                                             const TokenHeader *tokSegmentOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11778                                             while (tokSegmentOverride < tokSegmentOverrideEnd) {
11779                                                 if (false == tokSegmentOverride->flags.flag4IsVariableLength) {
11780                                                     switch (tokSegmentOverride->id) {
11781                                                     default:
11782                                                         if (tokSegmentOverride->flags.flag3IsMandatory) {
11783                                                             return false;
11784                                                         }
11785                                                         break;
11786                                                     case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: {
11787                                                         dst.GmmResourceInfoCommon.AuxSurf.SegmentOverride.Seg1 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.SegmentOverride.Seg1)>(*tokSegmentOverride);
11788                                                     } break;
11789                                                     case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: {
11790                                                         dst.GmmResourceInfoCommon.AuxSurf.SegmentOverride.Evict = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.SegmentOverride.Evict)>(*tokSegmentOverride);
11791                                                     } break;
11792                                                     };
11793                                                     tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount;
11794                                                 } else {
11795                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSegmentOverride);
11796                                                     if (tokSegmentOverride->flags.flag3IsMandatory) {
11797                                                         return false;
11798                                                     }
11799                                                     tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11800                                                 }
11801                                             }
11802                                             WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd);
11803                                         } break;
11804                                         case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: {
11805 #if _DEBUG || _RELEASE_INTERNAL
11806                                             const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>();
11807                                             const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11808                                             while (tokPlatform < tokPlatformEnd) {
11809                                                 if (false == tokPlatform->flags.flag4IsVariableLength) {
11810                                                     switch (tokPlatform->id) {
11811                                                     default:
11812                                                         if (tokPlatform->flags.flag3IsMandatory) {
11813                                                             return false;
11814                                                         }
11815                                                         break;
11816                                                     case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
11817                                                         dst.GmmResourceInfoCommon.AuxSurf.Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.eProductFamily)>(*tokPlatform);
11818                                                     } break;
11819                                                     case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
11820                                                         dst.GmmResourceInfoCommon.AuxSurf.Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.ePCHProductFamily)>(*tokPlatform);
11821                                                     } break;
11822                                                     case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
11823                                                         dst.GmmResourceInfoCommon.AuxSurf.Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.eDisplayCoreFamily)>(*tokPlatform);
11824                                                     } break;
11825                                                     case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
11826                                                         dst.GmmResourceInfoCommon.AuxSurf.Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.eRenderCoreFamily)>(*tokPlatform);
11827                                                     } break;
11828                                                     case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
11829                                                         dst.GmmResourceInfoCommon.AuxSurf.Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.ePlatformType)>(*tokPlatform);
11830                                                     } break;
11831                                                     case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
11832                                                         dst.GmmResourceInfoCommon.AuxSurf.Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.usDeviceID)>(*tokPlatform);
11833                                                     } break;
11834                                                     case TOK_FBW_PLATFORM_STR__US_REV_ID: {
11835                                                         dst.GmmResourceInfoCommon.AuxSurf.Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.usRevId)>(*tokPlatform);
11836                                                     } break;
11837                                                     case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
11838                                                         dst.GmmResourceInfoCommon.AuxSurf.Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.usDeviceID_PCH)>(*tokPlatform);
11839                                                     } break;
11840                                                     case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
11841                                                         dst.GmmResourceInfoCommon.AuxSurf.Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.usRevId_PCH)>(*tokPlatform);
11842                                                     } break;
11843                                                     case TOK_FE_PLATFORM_STR__E_GTTYPE: {
11844                                                         dst.GmmResourceInfoCommon.AuxSurf.Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.Platform.eGTType)>(*tokPlatform);
11845                                                     } break;
11846                                                     };
11847                                                     tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount;
11848                                                 } else {
11849                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform);
11850                                                     if (tokPlatform->flags.flag3IsMandatory) {
11851                                                         return false;
11852                                                     }
11853                                                     tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11854                                                 }
11855                                             }
11856                                             WCH_ASSERT(tokPlatform == tokPlatformEnd);
11857 #endif
11858                                         } break;
11859                                         case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: {
11860                                             const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>();
11861                                             const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11862                                             while (tokExistingSysMem < tokExistingSysMemEnd) {
11863                                                 if (false == tokExistingSysMem->flags.flag4IsVariableLength) {
11864                                                     switch (tokExistingSysMem->id) {
11865                                                     default:
11866                                                         if (tokExistingSysMem->flags.flag3IsMandatory) {
11867                                                             return false;
11868                                                         }
11869                                                         break;
11870                                                     case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: {
11871                                                         dst.GmmResourceInfoCommon.AuxSurf.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem);
11872                                                     } break;
11873                                                     case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: {
11874                                                         dst.GmmResourceInfoCommon.AuxSurf.ExistingSysMem.IsPageAligned = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.ExistingSysMem.IsPageAligned)>(*tokExistingSysMem);
11875                                                     } break;
11876                                                     };
11877                                                     tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount;
11878                                                 } else {
11879                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem);
11880                                                     if (tokExistingSysMem->flags.flag3IsMandatory) {
11881                                                         return false;
11882                                                     }
11883                                                     tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11884                                                 }
11885                                             }
11886                                             WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd);
11887                                         } break;
11888                                         case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: {
11889 #if !(_DEBUG || _RELEASE_INTERNAL)
11890                                             const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>();
11891                                             const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11892                                             while (tok__Platform < tok__PlatformEnd) {
11893                                                 if (false == tok__Platform->flags.flag4IsVariableLength) {
11894                                                     switch (tok__Platform->id) {
11895                                                     default:
11896                                                         if (tok__Platform->flags.flag3IsMandatory) {
11897                                                             return false;
11898                                                         }
11899                                                         break;
11900                                                     case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
11901                                                         dst.GmmResourceInfoCommon.AuxSurf.__Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eProductFamily)>(*tok__Platform);
11902                                                     } break;
11903                                                     case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
11904                                                         dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePCHProductFamily)>(*tok__Platform);
11905                                                     } break;
11906                                                     case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
11907                                                         dst.GmmResourceInfoCommon.AuxSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eDisplayCoreFamily)>(*tok__Platform);
11908                                                     } break;
11909                                                     case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
11910                                                         dst.GmmResourceInfoCommon.AuxSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eRenderCoreFamily)>(*tok__Platform);
11911                                                     } break;
11912                                                     case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
11913                                                         dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.ePlatformType)>(*tok__Platform);
11914                                                     } break;
11915                                                     case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
11916                                                         dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID)>(*tok__Platform);
11917                                                     } break;
11918                                                     case TOK_FBW_PLATFORM_STR__US_REV_ID: {
11919                                                         dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId)>(*tok__Platform);
11920                                                     } break;
11921                                                     case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
11922                                                         dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usDeviceID_PCH)>(*tok__Platform);
11923                                                     } break;
11924                                                     case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
11925                                                         dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.usRevId_PCH)>(*tok__Platform);
11926                                                     } break;
11927                                                     case TOK_FE_PLATFORM_STR__E_GTTYPE: {
11928                                                         dst.GmmResourceInfoCommon.AuxSurf.__Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSurf.__Platform.eGTType)>(*tok__Platform);
11929                                                     } break;
11930                                                     };
11931                                                     tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount;
11932                                                 } else {
11933                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform);
11934                                                     if (tok__Platform->flags.flag3IsMandatory) {
11935                                                         return false;
11936                                                     }
11937                                                     tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11938                                                 }
11939                                             }
11940                                             WCH_ASSERT(tok__Platform == tok__PlatformEnd);
11941 #endif
11942                                         } break;
11943                                         };
11944                                         tokAuxSurf = tokAuxSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
11945                                     }
11946                                 }
11947                                 WCH_ASSERT(tokAuxSurf == tokAuxSurfEnd);
11948                             } break;
11949                             case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__AUX_SEC_SURF: {
11950                                 const TokenHeader *tokAuxSecSurf = varLen->getValue<TokenHeader>();
11951                                 const TokenHeader *tokAuxSecSurfEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
11952                                 while (tokAuxSecSurf < tokAuxSecSurfEnd) {
11953                                     if (false == tokAuxSecSurf->flags.flag4IsVariableLength) {
11954                                         switch (tokAuxSecSurf->id) {
11955                                         default:
11956                                             if (tokAuxSecSurf->flags.flag3IsMandatory) {
11957                                                 return false;
11958                                             }
11959                                             break;
11960                                         case TOK_FE_GMM_TEXTURE_INFO_REC__TYPE: {
11961                                             dst.GmmResourceInfoCommon.AuxSecSurf.Type = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Type)>(*tokAuxSecSurf);
11962                                         } break;
11963                                         case TOK_FE_GMM_TEXTURE_INFO_REC__FORMAT: {
11964                                             dst.GmmResourceInfoCommon.AuxSecSurf.Format = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Format)>(*tokAuxSecSurf);
11965                                         } break;
11966                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__BITS_PER_PIXEL: {
11967                                             dst.GmmResourceInfoCommon.AuxSecSurf.BitsPerPixel = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.BitsPerPixel)>(*tokAuxSecSurf);
11968                                         } break;
11969                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__BASE_WIDTH: {
11970                                             dst.GmmResourceInfoCommon.AuxSecSurf.BaseWidth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.BaseWidth)>(*tokAuxSecSurf);
11971                                         } break;
11972                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__BASE_HEIGHT: {
11973                                             dst.GmmResourceInfoCommon.AuxSecSurf.BaseHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.BaseHeight)>(*tokAuxSecSurf);
11974                                         } break;
11975                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__DEPTH: {
11976                                             dst.GmmResourceInfoCommon.AuxSecSurf.Depth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Depth)>(*tokAuxSecSurf);
11977                                         } break;
11978                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__MAX_LOD: {
11979                                             dst.GmmResourceInfoCommon.AuxSecSurf.MaxLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.MaxLod)>(*tokAuxSecSurf);
11980                                         } break;
11981                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__ARRAY_SIZE: {
11982                                             dst.GmmResourceInfoCommon.AuxSecSurf.ArraySize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.ArraySize)>(*tokAuxSecSurf);
11983                                         } break;
11984                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__CP_TAG: {
11985                                             dst.GmmResourceInfoCommon.AuxSecSurf.CpTag = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.CpTag)>(*tokAuxSecSurf);
11986                                         } break;
11987                                         case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_MODE: {
11988                                             auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValue<char>();
11989                                             auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValueSizeInBytes();
11990                                             if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcMode)) {
11991                                                 return false;
11992                                             }
11993                                             WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.MmcMode, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcMode), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcMode));
11994                                         } break;
11995                                         case TOK_FBC_GMM_TEXTURE_INFO_REC__MMC_HINT: {
11996                                             auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValue<char>();
11997                                             auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokAuxSecSurf).getValueSizeInBytes();
11998                                             if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcHint)) {
11999                                                 return false;
12000                                             }
12001                                             WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.MmcHint, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcHint), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.MmcHint));
12002                                         } break;
12003                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__PITCH: {
12004                                             dst.GmmResourceInfoCommon.AuxSecSurf.Pitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Pitch)>(*tokAuxSecSurf);
12005                                         } break;
12006                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__OVERRIDE_PITCH: {
12007                                             dst.GmmResourceInfoCommon.AuxSecSurf.OverridePitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.OverridePitch)>(*tokAuxSecSurf);
12008                                         } break;
12009                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE: {
12010                                             dst.GmmResourceInfoCommon.AuxSecSurf.Size = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Size)>(*tokAuxSecSurf);
12011                                         } break;
12012                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__CCSIZE: {
12013                                             dst.GmmResourceInfoCommon.AuxSecSurf.CCSize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.CCSize)>(*tokAuxSecSurf);
12014                                         } break;
12015                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__UNPADDED_SIZE: {
12016                                             dst.GmmResourceInfoCommon.AuxSecSurf.UnpaddedSize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.UnpaddedSize)>(*tokAuxSecSurf);
12017                                         } break;
12018                                         case TOK_FBQ_GMM_TEXTURE_INFO_REC__SIZE_REPORT_TO_OS: {
12019                                             dst.GmmResourceInfoCommon.AuxSecSurf.SizeReportToOS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.SizeReportToOS)>(*tokAuxSecSurf);
12020                                         } break;
12021                                         case TOK_FE_GMM_TEXTURE_INFO_REC__TILE_MODE: {
12022                                             dst.GmmResourceInfoCommon.AuxSecSurf.TileMode = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.TileMode)>(*tokAuxSecSurf);
12023                                         } break;
12024                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__CCSMODE_ALIGN: {
12025                                             dst.GmmResourceInfoCommon.AuxSecSurf.CCSModeAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.CCSModeAlign)>(*tokAuxSecSurf);
12026                                         } break;
12027                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__LEGACY_FLAGS: {
12028                                             dst.GmmResourceInfoCommon.AuxSecSurf.LegacyFlags = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.LegacyFlags)>(*tokAuxSecSurf);
12029                                         } break;
12030                                         case TOK_FBD_GMM_TEXTURE_INFO_REC__MAXIMUM_RENAMING_LIST_LENGTH: {
12031                                             dst.GmmResourceInfoCommon.AuxSecSurf.MaximumRenamingListLength = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.MaximumRenamingListLength)>(*tokAuxSecSurf);
12032                                         } break;
12033                                         };
12034                                         tokAuxSecSurf = tokAuxSecSurf + 1 + tokAuxSecSurf->valueDwordCount;
12035                                     } else {
12036                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAuxSecSurf);
12037                                         switch (tokAuxSecSurf->id) {
12038                                         default:
12039                                             if (tokAuxSecSurf->flags.flag3IsMandatory) {
12040                                                 return false;
12041                                             }
12042                                             break;
12043                                         case TOK_FS_GMM_TEXTURE_INFO_REC__FLAGS: {
12044                                             const TokenHeader *tokFlags = varLen->getValue<TokenHeader>();
12045                                             const TokenHeader *tokFlagsEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12046                                             while (tokFlags < tokFlagsEnd) {
12047                                                 if (false == tokFlags->flags.flag4IsVariableLength) {
12048                                                     if (tokFlags->flags.flag3IsMandatory) {
12049                                                         return false;
12050                                                     }
12051                                                     tokFlags = tokFlags + 1 + tokFlags->valueDwordCount;
12052                                                 } else {
12053                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokFlags);
12054                                                     switch (tokFlags->id) {
12055                                                     default:
12056                                                         if (tokFlags->flags.flag3IsMandatory) {
12057                                                             return false;
12058                                                         }
12059                                                         break;
12060                                                     case TOK_FS_GMM_RESOURCE_FLAG_REC__GPU: {
12061                                                         const TokenHeader *tokGpu = varLen->getValue<TokenHeader>();
12062                                                         const TokenHeader *tokGpuEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12063                                                         while (tokGpu < tokGpuEnd) {
12064                                                             if (false == tokGpu->flags.flag4IsVariableLength) {
12065                                                                 switch (tokGpu->id) {
12066                                                                 default:
12067                                                                     if (tokGpu->flags.flag3IsMandatory) {
12068                                                                         return false;
12069                                                                     }
12070                                                                     break;
12071                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CAMERA_CAPTURE: {
12072                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.CameraCapture = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.CameraCapture)>(*tokGpu);
12073                                                                 } break;
12074                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CCS: {
12075                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.CCS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.CCS)>(*tokGpu);
12076                                                                 } break;
12077                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_DISCARD: {
12078                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorDiscard = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorDiscard)>(*tokGpu);
12079                                                                 } break;
12080                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION: {
12081                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorSeparation = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorSeparation)>(*tokGpu);
12082                                                                 } break;
12083                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__COLOR_SEPARATION_RGBX: {
12084                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorSeparationRGBX = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ColorSeparationRGBX)>(*tokGpu);
12085                                                                 } break;
12086                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__CONSTANT: {
12087                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Constant = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Constant)>(*tokGpu);
12088                                                                 } break;
12089                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__DEPTH: {
12090                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Depth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Depth)>(*tokGpu);
12091                                                                 } break;
12092                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN: {
12093                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.FlipChain = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.FlipChain)>(*tokGpu);
12094                                                                 } break;
12095                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__FLIP_CHAIN_PREFERRED: {
12096                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.FlipChainPreferred = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.FlipChainPreferred)>(*tokGpu);
12097                                                                 } break;
12098                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HISTORY_BUFFER: {
12099                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.HistoryBuffer = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.HistoryBuffer)>(*tokGpu);
12100                                                                 } break;
12101                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__HI_Z: {
12102                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.HiZ = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.HiZ)>(*tokGpu);
12103                                                                 } break;
12104                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDEX: {
12105                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Index = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Index)>(*tokGpu);
12106                                                                 } break;
12107                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INDIRECT_CLEAR_COLOR: {
12108                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.IndirectClearColor = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.IndirectClearColor)>(*tokGpu);
12109                                                                 } break;
12110                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INSTRUCTION_FLAT: {
12111                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.InstructionFlat = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.InstructionFlat)>(*tokGpu);
12112                                                                 } break;
12113                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__INTERLACED_SCAN: {
12114                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.InterlacedScan = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.InterlacedScan)>(*tokGpu);
12115                                                                 } break;
12116                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MCS: {
12117                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MCS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MCS)>(*tokGpu);
12118                                                                 } break;
12119                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MMC: {
12120                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MMC = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MMC)>(*tokGpu);
12121                                                                 } break;
12122                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__MOTION_COMP: {
12123                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MotionComp = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.MotionComp)>(*tokGpu);
12124                                                                 } break;
12125                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__NO_RESTRICTION: {
12126                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.NoRestriction = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.NoRestriction)>(*tokGpu);
12127                                                                 } break;
12128                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__OVERLAY: {
12129                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Overlay = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Overlay)>(*tokGpu);
12130                                                                 } break;
12131                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PRESENTABLE: {
12132                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Presentable = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Presentable)>(*tokGpu);
12133                                                                 } break;
12134                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__PROCEDURAL_TEXTURE: {
12135                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ProceduralTexture = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ProceduralTexture)>(*tokGpu);
12136                                                                 } break;
12137                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__QUERY: {
12138                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Query = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Query)>(*tokGpu);
12139                                                                 } break;
12140                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__RENDER_TARGET: {
12141                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.RenderTarget = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.RenderTarget)>(*tokGpu);
12142                                                                 } break;
12143                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D: {
12144                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.S3d = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.S3d)>(*tokGpu);
12145                                                                 } break;
12146                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__S3D_DX: {
12147                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.S3dDx = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.S3dDx)>(*tokGpu);
12148                                                                 } break;
12149                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_NON_PACKED: {
12150                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__S3dNonPacked = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__S3dNonPacked)>(*tokGpu);
12151                                                                 } break;
12152                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____S3D_WIDI: {
12153                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__S3dWidi = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__S3dWidi)>(*tokGpu);
12154                                                                 } break;
12155                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SCRATCH_FLAT: {
12156                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ScratchFlat = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.ScratchFlat)>(*tokGpu);
12157                                                                 } break;
12158                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__SEPARATE_STENCIL: {
12159                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.SeparateStencil = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.SeparateStencil)>(*tokGpu);
12160                                                                 } break;
12161                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE: {
12162                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.State = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.State)>(*tokGpu);
12163                                                                 } break;
12164                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STATE_DX9CONSTANT_BUFFER: {
12165                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.StateDx9ConstantBuffer = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.StateDx9ConstantBuffer)>(*tokGpu);
12166                                                                 } break;
12167                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__STREAM: {
12168                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Stream = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Stream)>(*tokGpu);
12169                                                                 } break;
12170                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXT_API: {
12171                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TextApi = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TextApi)>(*tokGpu);
12172                                                                 } break;
12173                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TEXTURE: {
12174                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Texture = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Texture)>(*tokGpu);
12175                                                                 } break;
12176                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILED_RESOURCE: {
12177                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TiledResource = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TiledResource)>(*tokGpu);
12178                                                                 } break;
12179                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__TILE_POOL: {
12180                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TilePool = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.TilePool)>(*tokGpu);
12181                                                                 } break;
12182                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__UNIFIED_AUX_SURFACE: {
12183                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.UnifiedAuxSurface = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.UnifiedAuxSurface)>(*tokGpu);
12184                                                                 } break;
12185                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VERTEX: {
12186                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Vertex = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Vertex)>(*tokGpu);
12187                                                                 } break;
12188                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739__VIDEO: {
12189                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Video = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.Video)>(*tokGpu);
12190                                                                 } break;
12191                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_XCCS: {
12192                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaTileXCcs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaTileXCcs)>(*tokGpu);
12193                                                                 } break;
12194                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_TILE_YCCS: {
12195                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaTileYCcs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaTileYCcs)>(*tokGpu);
12196                                                                 } break;
12197                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____MSAA_TILE_MCS: {
12198                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__MsaaTileMcs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__MsaaTileMcs)>(*tokGpu);
12199                                                                 } break;
12200                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____NON_MSAA_LINEAR_CCS: {
12201                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaLinearCCS = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__NonMsaaLinearCCS)>(*tokGpu);
12202                                                                 } break;
12203                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS1739____REMAINING: {
12204                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__Remaining = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Gpu.__Remaining)>(*tokGpu);
12205                                                                 } break;
12206                                                                 };
12207                                                                 tokGpu = tokGpu + 1 + tokGpu->valueDwordCount;
12208                                                             } else {
12209                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokGpu);
12210                                                                 if (tokGpu->flags.flag3IsMandatory) {
12211                                                                     return false;
12212                                                                 }
12213                                                                 tokGpu = tokGpu + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12214                                                             }
12215                                                         }
12216                                                         WCH_ASSERT(tokGpu == tokGpuEnd);
12217                                                     } break;
12218                                                     case TOK_FS_GMM_RESOURCE_FLAG_REC__INFO: {
12219                                                         const TokenHeader *tokInfo = varLen->getValue<TokenHeader>();
12220                                                         const TokenHeader *tokInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12221                                                         while (tokInfo < tokInfoEnd) {
12222                                                             if (false == tokInfo->flags.flag4IsVariableLength) {
12223                                                                 switch (tokInfo->id) {
12224                                                                 default:
12225                                                                     if (tokInfo->flags.flag3IsMandatory) {
12226                                                                         return false;
12227                                                                     }
12228                                                                     break;
12229                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ALLOW_VIRTUAL_PADDING: {
12230                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.AllowVirtualPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.AllowVirtualPadding)>(*tokInfo);
12231                                                                 } break;
12232                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__BIG_PAGE: {
12233                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.BigPage = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.BigPage)>(*tokInfo);
12234                                                                 } break;
12235                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CACHEABLE: {
12236                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Cacheable = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Cacheable)>(*tokInfo);
12237                                                                 } break;
12238                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CONTIG_PHYS_MEMORY_FORI_DART: {
12239                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ContigPhysMemoryForiDART = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ContigPhysMemoryForiDART)>(*tokInfo);
12240                                                                 } break;
12241                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__CORNER_TEXEL_MODE: {
12242                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.CornerTexelMode = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.CornerTexelMode)>(*tokInfo);
12243                                                                 } break;
12244                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__EXISTING_SYS_MEM: {
12245                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ExistingSysMem = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ExistingSysMem)>(*tokInfo);
12246                                                                 } break;
12247                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__FORCE_RESIDENCY: {
12248                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ForceResidency = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.ForceResidency)>(*tokInfo);
12249                                                                 } break;
12250                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GFDT: {
12251                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Gfdt = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Gfdt)>(*tokInfo);
12252                                                                 } break;
12253                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__GTT_MAP_TYPE: {
12254                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.GttMapType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.GttMapType)>(*tokInfo);
12255                                                                 } break;
12256                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__HARDWARE_PROTECTED: {
12257                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.HardwareProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.HardwareProtected)>(*tokInfo);
12258                                                                 } break;
12259                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__KERNEL_MODE_MAPPED: {
12260                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.KernelModeMapped = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.KernelModeMapped)>(*tokInfo);
12261                                                                 } break;
12262                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_BELOW: {
12263                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutBelow = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutBelow)>(*tokInfo);
12264                                                                 } break;
12265                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_MONO: {
12266                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutMono = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutMono)>(*tokInfo);
12267                                                                 } break;
12268                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LAYOUT_RIGHT: {
12269                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutRight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LayoutRight)>(*tokInfo);
12270                                                                 } break;
12271                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LOCAL_ONLY: {
12272                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LocalOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.LocalOnly)>(*tokInfo);
12273                                                                 } break;
12274                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__LINEAR: {
12275                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Linear = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Linear)>(*tokInfo);
12276                                                                 } break;
12277                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__MEDIA_COMPRESSED: {
12278                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.MediaCompressed = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.MediaCompressed)>(*tokInfo);
12279                                                                 } break;
12280                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_OPTIMIZATION_PADDING: {
12281                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NoOptimizationPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NoOptimizationPadding)>(*tokInfo);
12282                                                                 } break;
12283                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NO_PHYS_MEMORY: {
12284                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NoPhysMemory = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NoPhysMemory)>(*tokInfo);
12285                                                                 } break;
12286                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NOT_LOCKABLE: {
12287                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NotLockable = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NotLockable)>(*tokInfo);
12288                                                                 } break;
12289                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__NON_LOCAL_ONLY: {
12290                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NonLocalOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.NonLocalOnly)>(*tokInfo);
12291                                                                 } break;
12292                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__STD_SWIZZLE: {
12293                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.StdSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.StdSwizzle)>(*tokInfo);
12294                                                                 } break;
12295                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__PSEUDO_STD_SWIZZLE: {
12296                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.PseudoStdSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.PseudoStdSwizzle)>(*tokInfo);
12297                                                                 } break;
12298                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__UNDEFINED64KBSWIZZLE: {
12299                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Undefined64KBSwizzle = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Undefined64KBSwizzle)>(*tokInfo);
12300                                                                 } break;
12301                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__REDECRIBED_PLANES: {
12302                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.RedecribedPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.RedecribedPlanes)>(*tokInfo);
12303                                                                 } break;
12304                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__RENDER_COMPRESSED: {
12305                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.RenderCompressed = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.RenderCompressed)>(*tokInfo);
12306                                                                 } break;
12307                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__ROTATED: {
12308                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Rotated = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Rotated)>(*tokInfo);
12309                                                                 } break;
12310                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SHARED: {
12311                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Shared = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Shared)>(*tokInfo);
12312                                                                 } break;
12313                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SOFTWARE_PROTECTED: {
12314                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.SoftwareProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.SoftwareProtected)>(*tokInfo);
12315                                                                 } break;
12316                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__SVM: {
12317                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.SVM = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.SVM)>(*tokInfo);
12318                                                                 } break;
12319                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE4: {
12320                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Tile4 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Tile4)>(*tokInfo);
12321                                                                 } break;
12322                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILE64: {
12323                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Tile64 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.Tile64)>(*tokInfo);
12324                                                                 } break;
12325                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_W: {
12326                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledW = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledW)>(*tokInfo);
12327                                                                 } break;
12328                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_X: {
12329                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledX = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledX)>(*tokInfo);
12330                                                                 } break;
12331                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_Y: {
12332                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledY = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledY)>(*tokInfo);
12333                                                                 } break;
12334                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YF: {
12335                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledYf = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledYf)>(*tokInfo);
12336                                                                 } break;
12337                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__TILED_YS: {
12338                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledYs = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.TiledYs)>(*tokInfo);
12339                                                                 } break;
12340                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__WDDM_PROTECTED: {
12341                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.WddmProtected = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.WddmProtected)>(*tokInfo);
12342                                                                 } break;
12343                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797__XADAPTER: {
12344                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.XAdapter = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.XAdapter)>(*tokInfo);
12345                                                                 } break;
12346                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PREALLOCATED_RES_INFO: {
12347                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.__PreallocatedResInfo = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.__PreallocatedResInfo)>(*tokInfo);
12348                                                                 } break;
12349                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS6797____PRE_WDDM2SVM: {
12350                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.__PreWddm2SVM = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Info.__PreWddm2SVM)>(*tokInfo);
12351                                                                 } break;
12352                                                                 };
12353                                                                 tokInfo = tokInfo + 1 + tokInfo->valueDwordCount;
12354                                                             } else {
12355                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokInfo);
12356                                                                 if (tokInfo->flags.flag3IsMandatory) {
12357                                                                     return false;
12358                                                                 }
12359                                                                 tokInfo = tokInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12360                                                             }
12361                                                         }
12362                                                         WCH_ASSERT(tokInfo == tokInfoEnd);
12363                                                     } break;
12364                                                     case TOK_FS_GMM_RESOURCE_FLAG_REC__WA: {
12365                                                         const TokenHeader *tokWa = varLen->getValue<TokenHeader>();
12366                                                         const TokenHeader *tokWaEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12367                                                         while (tokWa < tokWaEnd) {
12368                                                             if (false == tokWa->flags.flag4IsVariableLength) {
12369                                                                 switch (tokWa->id) {
12370                                                                 default:
12371                                                                     if (tokWa->flags.flag3IsMandatory) {
12372                                                                         return false;
12373                                                                     }
12374                                                                     break;
12375                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__GTMFX2ND_LEVEL_BATCH_RING_SIZE_ALIGN: {
12376                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.GTMfx2ndLevelBatchRingSizeAlign)>(*tokWa);
12377                                                                 } break;
12378                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_MPR_ROW_STORE32KALIGN: {
12379                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ILKNeedAvcMprRowStore32KAlign)>(*tokWa);
12380                                                                 } break;
12381                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__ILKNEED_AVC_DMV_BUFFER32KALIGN: {
12382                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.ILKNeedAvcDmvBuffer32KAlign)>(*tokWa);
12383                                                                 } break;
12384                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_BUFFER_SAMPLER_PADDING: {
12385                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.NoBufferSamplerPadding = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.NoBufferSamplerPadding)>(*tokWa);
12386                                                                 } break;
12387                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__NO_LEGACY_PLANAR_LINEAR_VIDEO_RESTRICTIONS: {
12388                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.NoLegacyPlanarLinearVideoRestrictions)>(*tokWa);
12389                                                                 } break;
12390                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__CHVASTC_SKIP_VIRTUAL_MIPS: {
12391                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.CHVAstcSkipVirtualMips = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.CHVAstcSkipVirtualMips)>(*tokWa);
12392                                                                 } break;
12393                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_PACKED_MIP_TAIL: {
12394                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisablePackedMipTail = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisablePackedMipTail)>(*tokWa);
12395                                                                 } break;
12396                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521____FORCE_OTHER_HVALIGN4: {
12397                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.__ForceOtherHVALIGN4 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.__ForceOtherHVALIGN4)>(*tokWa);
12398                                                                 } break;
12399                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_CLEAR_COLOR: {
12400                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsClearColor)>(*tokWa);
12401                                                                 } break;
12402                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__DISABLE_DISPLAY_CCS_COMPRESSION: {
12403                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.DisableDisplayCcsCompression)>(*tokWa);
12404                                                                 } break;
12405                                                                 case TOK_FBD_GMM_RESOURCE_FLAG_REC__ANONYMOUS12521__PRE_GEN12FAST_CLEAR_ONLY: {
12406                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Flags.Wa.PreGen12FastClearOnly)>(*tokWa);
12407                                                                 } break;
12408                                                                 };
12409                                                                 tokWa = tokWa + 1 + tokWa->valueDwordCount;
12410                                                             } else {
12411                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokWa);
12412                                                                 if (tokWa->flags.flag3IsMandatory) {
12413                                                                     return false;
12414                                                                 }
12415                                                                 tokWa = tokWa + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12416                                                             }
12417                                                         }
12418                                                         WCH_ASSERT(tokWa == tokWaEnd);
12419                                                     } break;
12420                                                     };
12421                                                     tokFlags = tokFlags + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12422                                                 }
12423                                             }
12424                                             WCH_ASSERT(tokFlags == tokFlagsEnd);
12425                                         } break;
12426                                         case TOK_FS_GMM_TEXTURE_INFO_REC__CACHE_POLICY: {
12427                                             const TokenHeader *tokCachePolicy = varLen->getValue<TokenHeader>();
12428                                             const TokenHeader *tokCachePolicyEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12429                                             while (tokCachePolicy < tokCachePolicyEnd) {
12430                                                 if (false == tokCachePolicy->flags.flag4IsVariableLength) {
12431                                                     switch (tokCachePolicy->id) {
12432                                                     default:
12433                                                         if (tokCachePolicy->flags.flag3IsMandatory) {
12434                                                             return false;
12435                                                         }
12436                                                         break;
12437                                                     case TOK_FE_GMM_TEXTURE_INFO_REC__ANONYMOUS4927__USAGE: {
12438                                                         dst.GmmResourceInfoCommon.AuxSecSurf.CachePolicy.Usage = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.CachePolicy.Usage)>(*tokCachePolicy);
12439                                                     } break;
12440                                                     };
12441                                                     tokCachePolicy = tokCachePolicy + 1 + tokCachePolicy->valueDwordCount;
12442                                                 } else {
12443                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokCachePolicy);
12444                                                     if (tokCachePolicy->flags.flag3IsMandatory) {
12445                                                         return false;
12446                                                     }
12447                                                     tokCachePolicy = tokCachePolicy + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12448                                                 }
12449                                             }
12450                                             WCH_ASSERT(tokCachePolicy == tokCachePolicyEnd);
12451                                         } break;
12452                                         case TOK_FS_GMM_TEXTURE_INFO_REC__MSAA: {
12453                                             const TokenHeader *tokMSAA = varLen->getValue<TokenHeader>();
12454                                             const TokenHeader *tokMSAAEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12455                                             while (tokMSAA < tokMSAAEnd) {
12456                                                 if (false == tokMSAA->flags.flag4IsVariableLength) {
12457                                                     switch (tokMSAA->id) {
12458                                                     default:
12459                                                         if (tokMSAA->flags.flag3IsMandatory) {
12460                                                             return false;
12461                                                         }
12462                                                         break;
12463                                                     case TOK_FE_GMM_RESOURCE_MSAA_INFO_REC__SAMPLE_PATTERN: {
12464                                                         dst.GmmResourceInfoCommon.AuxSecSurf.MSAA.SamplePattern = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.MSAA.SamplePattern)>(*tokMSAA);
12465                                                     } break;
12466                                                     case TOK_FBD_GMM_RESOURCE_MSAA_INFO_REC__NUM_SAMPLES: {
12467                                                         dst.GmmResourceInfoCommon.AuxSecSurf.MSAA.NumSamples = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.MSAA.NumSamples)>(*tokMSAA);
12468                                                     } break;
12469                                                     };
12470                                                     tokMSAA = tokMSAA + 1 + tokMSAA->valueDwordCount;
12471                                                 } else {
12472                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMSAA);
12473                                                     if (tokMSAA->flags.flag3IsMandatory) {
12474                                                         return false;
12475                                                     }
12476                                                     tokMSAA = tokMSAA + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12477                                                 }
12478                                             }
12479                                             WCH_ASSERT(tokMSAA == tokMSAAEnd);
12480                                         } break;
12481                                         case TOK_FS_GMM_TEXTURE_INFO_REC__ALIGNMENT: {
12482                                             const TokenHeader *tokAlignment = varLen->getValue<TokenHeader>();
12483                                             const TokenHeader *tokAlignmentEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12484                                             while (tokAlignment < tokAlignmentEnd) {
12485                                                 if (false == tokAlignment->flags.flag4IsVariableLength) {
12486                                                     switch (tokAlignment->id) {
12487                                                     default:
12488                                                         if (tokAlignment->flags.flag3IsMandatory) {
12489                                                             return false;
12490                                                         }
12491                                                         break;
12492                                                     case TOK_FBC_GMM_RESOURCE_ALIGNMENT_REC__ARRAY_SPACING_SINGLE_LOD: {
12493                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.ArraySpacingSingleLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.ArraySpacingSingleLod)>(*tokAlignment);
12494                                                     } break;
12495                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__BASE_ALIGNMENT: {
12496                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.BaseAlignment = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.BaseAlignment)>(*tokAlignment);
12497                                                     } break;
12498                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__HALIGN: {
12499                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.HAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.HAlign)>(*tokAlignment);
12500                                                     } break;
12501                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__VALIGN: {
12502                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.VAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.VAlign)>(*tokAlignment);
12503                                                     } break;
12504                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__DALIGN: {
12505                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.DAlign = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.DAlign)>(*tokAlignment);
12506                                                     } break;
12507                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__MIP_TAIL_START_LOD: {
12508                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.MipTailStartLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.MipTailStartLod)>(*tokAlignment);
12509                                                     } break;
12510                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_START_LOD: {
12511                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipStartLod = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipStartLod)>(*tokAlignment);
12512                                                     } break;
12513                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_WIDTH: {
12514                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipWidth = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipWidth)>(*tokAlignment);
12515                                                     } break;
12516                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__PACKED_MIP_HEIGHT: {
12517                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.PackedMipHeight)>(*tokAlignment);
12518                                                     } break;
12519                                                     case TOK_FBD_GMM_RESOURCE_ALIGNMENT_REC__QPITCH: {
12520                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.QPitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Alignment.QPitch)>(*tokAlignment);
12521                                                     } break;
12522                                                     };
12523                                                     tokAlignment = tokAlignment + 1 + tokAlignment->valueDwordCount;
12524                                                 } else {
12525                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokAlignment);
12526                                                     if (tokAlignment->flags.flag3IsMandatory) {
12527                                                         return false;
12528                                                     }
12529                                                     tokAlignment = tokAlignment + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12530                                                 }
12531                                             }
12532                                             WCH_ASSERT(tokAlignment == tokAlignmentEnd);
12533                                         } break;
12534                                         case TOK_FS_GMM_TEXTURE_INFO_REC__OFFSET_INFO: {
12535                                             const TokenHeader *tokOffsetInfo = varLen->getValue<TokenHeader>();
12536                                             const TokenHeader *tokOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12537                                             while (tokOffsetInfo < tokOffsetInfoEnd) {
12538                                                 if (false == tokOffsetInfo->flags.flag4IsVariableLength) {
12539                                                     if (tokOffsetInfo->flags.flag3IsMandatory) {
12540                                                         return false;
12541                                                     }
12542                                                     tokOffsetInfo = tokOffsetInfo + 1 + tokOffsetInfo->valueDwordCount;
12543                                                 } else {
12544                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokOffsetInfo);
12545                                                     switch (tokOffsetInfo->id) {
12546                                                     default:
12547                                                         if (tokOffsetInfo->flags.flag3IsMandatory) {
12548                                                             return false;
12549                                                         }
12550                                                         break;
12551                                                     case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE3DOFFSET_INFO: {
12552                                                         const TokenHeader *tokTexture3DOffsetInfo = varLen->getValue<TokenHeader>();
12553                                                         const TokenHeader *tokTexture3DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12554                                                         while (tokTexture3DOffsetInfo < tokTexture3DOffsetInfoEnd) {
12555                                                             if (false == tokTexture3DOffsetInfo->flags.flag4IsVariableLength) {
12556                                                                 switch (tokTexture3DOffsetInfo->id) {
12557                                                                 default:
12558                                                                     if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
12559                                                                         return false;
12560                                                                     }
12561                                                                     break;
12562                                                                 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__MIP0SLICE_PITCH: {
12563                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Mip0SlicePitch)>(*tokTexture3DOffsetInfo);
12564                                                                 } break;
12565                                                                 case TOK_FBQ_GMM_3D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
12566                                                                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValue<char>();
12567                                                                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture3DOffsetInfo).getValueSizeInBytes();
12568                                                                     if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset)) {
12569                                                                         return false;
12570                                                                     }
12571                                                                     WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture3DOffsetInfo.Offset));
12572                                                                 } break;
12573                                                                 };
12574                                                                 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + 1 + tokTexture3DOffsetInfo->valueDwordCount;
12575                                                             } else {
12576                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture3DOffsetInfo);
12577                                                                 if (tokTexture3DOffsetInfo->flags.flag3IsMandatory) {
12578                                                                     return false;
12579                                                                 }
12580                                                                 tokTexture3DOffsetInfo = tokTexture3DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12581                                                             }
12582                                                         }
12583                                                         WCH_ASSERT(tokTexture3DOffsetInfo == tokTexture3DOffsetInfoEnd);
12584                                                     } break;
12585                                                     case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__TEXTURE2DOFFSET_INFO: {
12586                                                         const TokenHeader *tokTexture2DOffsetInfo = varLen->getValue<TokenHeader>();
12587                                                         const TokenHeader *tokTexture2DOffsetInfoEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12588                                                         while (tokTexture2DOffsetInfo < tokTexture2DOffsetInfoEnd) {
12589                                                             if (false == tokTexture2DOffsetInfo->flags.flag4IsVariableLength) {
12590                                                                 switch (tokTexture2DOffsetInfo->id) {
12591                                                                 default:
12592                                                                     if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
12593                                                                         return false;
12594                                                                     }
12595                                                                     break;
12596                                                                 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_LOCK: {
12597                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchLock)>(*tokTexture2DOffsetInfo);
12598                                                                 } break;
12599                                                                 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__ARRAY_QPITCH_RENDER: {
12600                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.ArrayQPitchRender)>(*tokTexture2DOffsetInfo);
12601                                                                 } break;
12602                                                                 case TOK_FBQ_GMM_2D_TEXTURE_OFFSET_INFO_REC__OFFSET: {
12603                                                                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValue<char>();
12604                                                                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokTexture2DOffsetInfo).getValueSizeInBytes();
12605                                                                     if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset)) {
12606                                                                         return false;
12607                                                                     }
12608                                                                     WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Texture2DOffsetInfo.Offset));
12609                                                                 } break;
12610                                                                 };
12611                                                                 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + 1 + tokTexture2DOffsetInfo->valueDwordCount;
12612                                                             } else {
12613                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokTexture2DOffsetInfo);
12614                                                                 if (tokTexture2DOffsetInfo->flags.flag3IsMandatory) {
12615                                                                     return false;
12616                                                                 }
12617                                                                 tokTexture2DOffsetInfo = tokTexture2DOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12618                                                             }
12619                                                         }
12620                                                         WCH_ASSERT(tokTexture2DOffsetInfo == tokTexture2DOffsetInfoEnd);
12621                                                     } break;
12622                                                     case TOK_FS_GMM_OFFSET_INFO_REC__ANONYMOUS3429__PLANE: {
12623                                                         const TokenHeader *tokPlane = varLen->getValue<TokenHeader>();
12624                                                         const TokenHeader *tokPlaneEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12625                                                         while (tokPlane < tokPlaneEnd) {
12626                                                             if (false == tokPlane->flags.flag4IsVariableLength) {
12627                                                                 switch (tokPlane->id) {
12628                                                                 default:
12629                                                                     if (tokPlane->flags.flag3IsMandatory) {
12630                                                                         return false;
12631                                                                     }
12632                                                                     break;
12633                                                                 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ARRAY_QPITCH: {
12634                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.ArrayQPitch = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.ArrayQPitch)>(*tokPlane);
12635                                                                 } break;
12636                                                                 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__X: {
12637                                                                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
12638                                                                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
12639                                                                     if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X)) {
12640                                                                         return false;
12641                                                                     }
12642                                                                     WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.X));
12643                                                                 } break;
12644                                                                 case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__Y: {
12645                                                                     auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValue<char>();
12646                                                                     auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokPlane).getValueSizeInBytes();
12647                                                                     if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y)) {
12648                                                                         return false;
12649                                                                     }
12650                                                                     WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.Y));
12651                                                                 } break;
12652                                                                 case TOK_FBD_GMM_PLANAR_OFFSET_INFO_REC__NO_OF_PLANES: {
12653                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.NoOfPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.NoOfPlanes)>(*tokPlane);
12654                                                                 } break;
12655                                                                 case TOK_FBB_GMM_PLANAR_OFFSET_INFO_REC__IS_TILE_ALIGNED_PLANES: {
12656                                                                     dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.IsTileAlignedPlanes = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.IsTileAlignedPlanes)>(*tokPlane);
12657                                                                 } break;
12658                                                                 };
12659                                                                 tokPlane = tokPlane + 1 + tokPlane->valueDwordCount;
12660                                                             } else {
12661                                                                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlane);
12662                                                                 switch (tokPlane->id) {
12663                                                                 default:
12664                                                                     if (tokPlane->flags.flag3IsMandatory) {
12665                                                                         return false;
12666                                                                     }
12667                                                                     break;
12668                                                                 case TOK_FS_GMM_PLANAR_OFFSET_INFO_REC__UN_ALIGNED: {
12669                                                                     const TokenHeader *tokUnAligned = varLen->getValue<TokenHeader>();
12670                                                                     const TokenHeader *tokUnAlignedEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12671                                                                     while (tokUnAligned < tokUnAlignedEnd) {
12672                                                                         if (false == tokUnAligned->flags.flag4IsVariableLength) {
12673                                                                             switch (tokUnAligned->id) {
12674                                                                             default:
12675                                                                                 if (tokUnAligned->flags.flag3IsMandatory) {
12676                                                                                     return false;
12677                                                                                 }
12678                                                                                 break;
12679                                                                             case TOK_FBQ_GMM_PLANAR_OFFSET_INFO_REC__ANONYMOUS1851__HEIGHT: {
12680                                                                                 auto srcData = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValue<char>();
12681                                                                                 auto srcSize = reinterpret_cast<const TokenArray<1> &>(*tokUnAligned).getValueSizeInBytes();
12682                                                                                 if (srcSize < sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height)) {
12683                                                                                     return false;
12684                                                                                 }
12685                                                                                 WCH_SAFE_COPY(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height), srcData, sizeof(dst.GmmResourceInfoCommon.AuxSecSurf.OffsetInfo.Plane.UnAligned.Height));
12686                                                                             } break;
12687                                                                             };
12688                                                                             tokUnAligned = tokUnAligned + 1 + tokUnAligned->valueDwordCount;
12689                                                                         } else {
12690                                                                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokUnAligned);
12691                                                                             if (tokUnAligned->flags.flag3IsMandatory) {
12692                                                                                 return false;
12693                                                                             }
12694                                                                             tokUnAligned = tokUnAligned + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12695                                                                         }
12696                                                                     }
12697                                                                     WCH_ASSERT(tokUnAligned == tokUnAlignedEnd);
12698                                                                 } break;
12699                                                                 };
12700                                                                 tokPlane = tokPlane + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12701                                                             }
12702                                                         }
12703                                                         WCH_ASSERT(tokPlane == tokPlaneEnd);
12704                                                     } break;
12705                                                     };
12706                                                     tokOffsetInfo = tokOffsetInfo + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12707                                                 }
12708                                             }
12709                                             WCH_ASSERT(tokOffsetInfo == tokOffsetInfoEnd);
12710                                         } break;
12711                                         case TOK_FS_GMM_TEXTURE_INFO_REC__S3D: {
12712                                             const TokenHeader *tokS3d = varLen->getValue<TokenHeader>();
12713                                             const TokenHeader *tokS3dEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12714                                             while (tokS3d < tokS3dEnd) {
12715                                                 if (false == tokS3d->flags.flag4IsVariableLength) {
12716                                                     switch (tokS3d->id) {
12717                                                     default:
12718                                                         if (tokS3d->flags.flag3IsMandatory) {
12719                                                             return false;
12720                                                         }
12721                                                         break;
12722                                                     case TOK_FBD_GMM_S3D_INFO_REC__DISPLAY_MODE_HEIGHT: {
12723                                                         dst.GmmResourceInfoCommon.AuxSecSurf.S3d.DisplayModeHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.S3d.DisplayModeHeight)>(*tokS3d);
12724                                                     } break;
12725                                                     case TOK_FBD_GMM_S3D_INFO_REC__NUM_BLANK_ACTIVE_LINES: {
12726                                                         dst.GmmResourceInfoCommon.AuxSecSurf.S3d.NumBlankActiveLines = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.S3d.NumBlankActiveLines)>(*tokS3d);
12727                                                     } break;
12728                                                     case TOK_FBD_GMM_S3D_INFO_REC__RFRAME_OFFSET: {
12729                                                         dst.GmmResourceInfoCommon.AuxSecSurf.S3d.RFrameOffset = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.S3d.RFrameOffset)>(*tokS3d);
12730                                                     } break;
12731                                                     case TOK_FBD_GMM_S3D_INFO_REC__BLANK_AREA_OFFSET: {
12732                                                         dst.GmmResourceInfoCommon.AuxSecSurf.S3d.BlankAreaOffset = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.S3d.BlankAreaOffset)>(*tokS3d);
12733                                                     } break;
12734                                                     case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_HEIGHT: {
12735                                                         dst.GmmResourceInfoCommon.AuxSecSurf.S3d.TallBufferHeight = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.S3d.TallBufferHeight)>(*tokS3d);
12736                                                     } break;
12737                                                     case TOK_FBD_GMM_S3D_INFO_REC__TALL_BUFFER_SIZE: {
12738                                                         dst.GmmResourceInfoCommon.AuxSecSurf.S3d.TallBufferSize = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.S3d.TallBufferSize)>(*tokS3d);
12739                                                     } break;
12740                                                     case TOK_FBC_GMM_S3D_INFO_REC__IS_RFRAME: {
12741                                                         dst.GmmResourceInfoCommon.AuxSecSurf.S3d.IsRFrame = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.S3d.IsRFrame)>(*tokS3d);
12742                                                     } break;
12743                                                     };
12744                                                     tokS3d = tokS3d + 1 + tokS3d->valueDwordCount;
12745                                                 } else {
12746                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokS3d);
12747                                                     if (tokS3d->flags.flag3IsMandatory) {
12748                                                         return false;
12749                                                     }
12750                                                     tokS3d = tokS3d + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12751                                                 }
12752                                             }
12753                                             WCH_ASSERT(tokS3d == tokS3dEnd);
12754                                         } break;
12755                                         case TOK_FS_GMM_TEXTURE_INFO_REC__SEGMENT_OVERRIDE: {
12756                                             const TokenHeader *tokSegmentOverride = varLen->getValue<TokenHeader>();
12757                                             const TokenHeader *tokSegmentOverrideEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12758                                             while (tokSegmentOverride < tokSegmentOverrideEnd) {
12759                                                 if (false == tokSegmentOverride->flags.flag4IsVariableLength) {
12760                                                     switch (tokSegmentOverride->id) {
12761                                                     default:
12762                                                         if (tokSegmentOverride->flags.flag3IsMandatory) {
12763                                                             return false;
12764                                                         }
12765                                                         break;
12766                                                     case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__SEG1: {
12767                                                         dst.GmmResourceInfoCommon.AuxSecSurf.SegmentOverride.Seg1 = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.SegmentOverride.Seg1)>(*tokSegmentOverride);
12768                                                     } break;
12769                                                     case TOK_FBD_GMM_TEXTURE_INFO_REC__ANONYMOUS6185__EVICT: {
12770                                                         dst.GmmResourceInfoCommon.AuxSecSurf.SegmentOverride.Evict = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.SegmentOverride.Evict)>(*tokSegmentOverride);
12771                                                     } break;
12772                                                     };
12773                                                     tokSegmentOverride = tokSegmentOverride + 1 + tokSegmentOverride->valueDwordCount;
12774                                                 } else {
12775                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokSegmentOverride);
12776                                                     if (tokSegmentOverride->flags.flag3IsMandatory) {
12777                                                         return false;
12778                                                     }
12779                                                     tokSegmentOverride = tokSegmentOverride + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12780                                                 }
12781                                             }
12782                                             WCH_ASSERT(tokSegmentOverride == tokSegmentOverrideEnd);
12783                                         } break;
12784                                         case TOK_FS_GMM_TEXTURE_INFO_REC__PLATFORM: {
12785 #if _DEBUG || _RELEASE_INTERNAL
12786                                             const TokenHeader *tokPlatform = varLen->getValue<TokenHeader>();
12787                                             const TokenHeader *tokPlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12788                                             while (tokPlatform < tokPlatformEnd) {
12789                                                 if (false == tokPlatform->flags.flag4IsVariableLength) {
12790                                                     switch (tokPlatform->id) {
12791                                                     default:
12792                                                         if (tokPlatform->flags.flag3IsMandatory) {
12793                                                             return false;
12794                                                         }
12795                                                         break;
12796                                                     case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
12797                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eProductFamily)>(*tokPlatform);
12798                                                     } break;
12799                                                     case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
12800                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.ePCHProductFamily)>(*tokPlatform);
12801                                                     } break;
12802                                                     case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
12803                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eDisplayCoreFamily)>(*tokPlatform);
12804                                                     } break;
12805                                                     case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
12806                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eRenderCoreFamily)>(*tokPlatform);
12807                                                     } break;
12808                                                     case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
12809                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.ePlatformType)>(*tokPlatform);
12810                                                     } break;
12811                                                     case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
12812                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usDeviceID)>(*tokPlatform);
12813                                                     } break;
12814                                                     case TOK_FBW_PLATFORM_STR__US_REV_ID: {
12815                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usRevId)>(*tokPlatform);
12816                                                     } break;
12817                                                     case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
12818                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usDeviceID_PCH)>(*tokPlatform);
12819                                                     } break;
12820                                                     case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
12821                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.usRevId_PCH)>(*tokPlatform);
12822                                                     } break;
12823                                                     case TOK_FE_PLATFORM_STR__E_GTTYPE: {
12824                                                         dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.Platform.eGTType)>(*tokPlatform);
12825                                                     } break;
12826                                                     };
12827                                                     tokPlatform = tokPlatform + 1 + tokPlatform->valueDwordCount;
12828                                                 } else {
12829                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokPlatform);
12830                                                     if (tokPlatform->flags.flag3IsMandatory) {
12831                                                         return false;
12832                                                     }
12833                                                     tokPlatform = tokPlatform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12834                                                 }
12835                                             }
12836                                             WCH_ASSERT(tokPlatform == tokPlatformEnd);
12837 #endif
12838                                         } break;
12839                                         case TOK_FS_GMM_TEXTURE_INFO_REC__EXISTING_SYS_MEM: {
12840                                             const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>();
12841                                             const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12842                                             while (tokExistingSysMem < tokExistingSysMemEnd) {
12843                                                 if (false == tokExistingSysMem->flags.flag4IsVariableLength) {
12844                                                     switch (tokExistingSysMem->id) {
12845                                                     default:
12846                                                         if (tokExistingSysMem->flags.flag3IsMandatory) {
12847                                                             return false;
12848                                                         }
12849                                                         break;
12850                                                     case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_GMM_ALLOCATED: {
12851                                                         dst.GmmResourceInfoCommon.AuxSecSurf.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem);
12852                                                     } break;
12853                                                     case TOK_FBC_GMM_TEXTURE_INFO_REC__ANONYMOUS6590__IS_PAGE_ALIGNED: {
12854                                                         dst.GmmResourceInfoCommon.AuxSecSurf.ExistingSysMem.IsPageAligned = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.ExistingSysMem.IsPageAligned)>(*tokExistingSysMem);
12855                                                     } break;
12856                                                     };
12857                                                     tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount;
12858                                                 } else {
12859                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem);
12860                                                     if (tokExistingSysMem->flags.flag3IsMandatory) {
12861                                                         return false;
12862                                                     }
12863                                                     tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12864                                                 }
12865                                             }
12866                                             WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd);
12867                                         } break;
12868                                         case TOK_FS_GMM_TEXTURE_INFO_REC____PLATFORM: {
12869 #if !(_DEBUG || _RELEASE_INTERNAL)
12870                                             const TokenHeader *tok__Platform = varLen->getValue<TokenHeader>();
12871                                             const TokenHeader *tok__PlatformEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12872                                             while (tok__Platform < tok__PlatformEnd) {
12873                                                 if (false == tok__Platform->flags.flag4IsVariableLength) {
12874                                                     switch (tok__Platform->id) {
12875                                                     default:
12876                                                         if (tok__Platform->flags.flag3IsMandatory) {
12877                                                             return false;
12878                                                         }
12879                                                         break;
12880                                                     case TOK_FE_PLATFORM_STR__E_PRODUCT_FAMILY: {
12881                                                         dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eProductFamily)>(*tok__Platform);
12882                                                     } break;
12883                                                     case TOK_FE_PLATFORM_STR__E_PCHPRODUCT_FAMILY: {
12884                                                         dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePCHProductFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePCHProductFamily)>(*tok__Platform);
12885                                                     } break;
12886                                                     case TOK_FE_PLATFORM_STR__E_DISPLAY_CORE_FAMILY: {
12887                                                         dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eDisplayCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eDisplayCoreFamily)>(*tok__Platform);
12888                                                     } break;
12889                                                     case TOK_FE_PLATFORM_STR__E_RENDER_CORE_FAMILY: {
12890                                                         dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eRenderCoreFamily = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eRenderCoreFamily)>(*tok__Platform);
12891                                                     } break;
12892                                                     case TOK_FE_PLATFORM_STR__E_PLATFORM_TYPE: {
12893                                                         dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePlatformType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.ePlatformType)>(*tok__Platform);
12894                                                     } break;
12895                                                     case TOK_FBW_PLATFORM_STR__US_DEVICE_ID: {
12896                                                         dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID)>(*tok__Platform);
12897                                                     } break;
12898                                                     case TOK_FBW_PLATFORM_STR__US_REV_ID: {
12899                                                         dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId)>(*tok__Platform);
12900                                                     } break;
12901                                                     case TOK_FBW_PLATFORM_STR__US_DEVICE_ID_PCH: {
12902                                                         dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usDeviceID_PCH)>(*tok__Platform);
12903                                                     } break;
12904                                                     case TOK_FBW_PLATFORM_STR__US_REV_ID_PCH: {
12905                                                         dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId_PCH = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.usRevId_PCH)>(*tok__Platform);
12906                                                     } break;
12907                                                     case TOK_FE_PLATFORM_STR__E_GTTYPE: {
12908                                                         dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eGTType = readTokValue<decltype(dst.GmmResourceInfoCommon.AuxSecSurf.__Platform.eGTType)>(*tok__Platform);
12909                                                     } break;
12910                                                     };
12911                                                     tok__Platform = tok__Platform + 1 + tok__Platform->valueDwordCount;
12912                                                 } else {
12913                                                     auto varLen = reinterpret_cast<const TokenVariableLength *>(tok__Platform);
12914                                                     if (tok__Platform->flags.flag3IsMandatory) {
12915                                                         return false;
12916                                                     }
12917                                                     tok__Platform = tok__Platform + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12918                                                 }
12919                                             }
12920                                             WCH_ASSERT(tok__Platform == tok__PlatformEnd);
12921 #endif
12922                                         } break;
12923                                         };
12924                                         tokAuxSecSurf = tokAuxSecSurf + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12925                                     }
12926                                 }
12927                                 WCH_ASSERT(tokAuxSecSurf == tokAuxSecSurfEnd);
12928                             } break;
12929                             case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__EXISTING_SYS_MEM: {
12930                                 const TokenHeader *tokExistingSysMem = varLen->getValue<TokenHeader>();
12931                                 const TokenHeader *tokExistingSysMemEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12932                                 while (tokExistingSysMem < tokExistingSysMemEnd) {
12933                                     if (false == tokExistingSysMem->flags.flag4IsVariableLength) {
12934                                         switch (tokExistingSysMem->id) {
12935                                         default:
12936                                             if (tokExistingSysMem->flags.flag3IsMandatory) {
12937                                                 return false;
12938                                             }
12939                                             break;
12940                                         case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_EXISTING_SYS_MEM: {
12941                                             dst.GmmResourceInfoCommon.ExistingSysMem.pExistingSysMem = readTokValue<decltype(dst.GmmResourceInfoCommon.ExistingSysMem.pExistingSysMem)>(*tokExistingSysMem);
12942                                         } break;
12943                                         case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_VIRT_ADDRESS: {
12944                                             dst.GmmResourceInfoCommon.ExistingSysMem.pVirtAddress = readTokValue<decltype(dst.GmmResourceInfoCommon.ExistingSysMem.pVirtAddress)>(*tokExistingSysMem);
12945                                         } break;
12946                                         case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__P_GFX_ALIGNED_VIRT_ADDRESS: {
12947                                             dst.GmmResourceInfoCommon.ExistingSysMem.pGfxAlignedVirtAddress = readTokValue<decltype(dst.GmmResourceInfoCommon.ExistingSysMem.pGfxAlignedVirtAddress)>(*tokExistingSysMem);
12948                                         } break;
12949                                         case TOK_FBQ_GMM_EXISTING_SYS_MEM_REC__SIZE: {
12950                                             dst.GmmResourceInfoCommon.ExistingSysMem.Size = readTokValue<decltype(dst.GmmResourceInfoCommon.ExistingSysMem.Size)>(*tokExistingSysMem);
12951                                         } break;
12952                                         case TOK_FBC_GMM_EXISTING_SYS_MEM_REC__IS_GMM_ALLOCATED: {
12953                                             dst.GmmResourceInfoCommon.ExistingSysMem.IsGmmAllocated = readTokValue<decltype(dst.GmmResourceInfoCommon.ExistingSysMem.IsGmmAllocated)>(*tokExistingSysMem);
12954                                         } break;
12955                                         };
12956                                         tokExistingSysMem = tokExistingSysMem + 1 + tokExistingSysMem->valueDwordCount;
12957                                     } else {
12958                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokExistingSysMem);
12959                                         if (tokExistingSysMem->flags.flag3IsMandatory) {
12960                                             return false;
12961                                         }
12962                                         tokExistingSysMem = tokExistingSysMem + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
12963                                     }
12964                                 }
12965                                 WCH_ASSERT(tokExistingSysMem == tokExistingSysMemEnd);
12966                             } break;
12967                             case TOK_FS_GMM_RESOURCE_INFO_COMMON_STRUCT__MULTI_TILE_ARCH: {
12968                                 const TokenHeader *tokMultiTileArch = varLen->getValue<TokenHeader>();
12969                                 const TokenHeader *tokMultiTileArchEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
12970                                 while (tokMultiTileArch < tokMultiTileArchEnd) {
12971                                     if (false == tokMultiTileArch->flags.flag4IsVariableLength) {
12972                                         switch (tokMultiTileArch->id) {
12973                                         default:
12974                                             if (tokMultiTileArch->flags.flag3IsMandatory) {
12975                                                 return false;
12976                                             }
12977                                             break;
12978                                         case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__ENABLE: {
12979                                             dst.GmmResourceInfoCommon.MultiTileArch.Enable = readTokValue<decltype(dst.GmmResourceInfoCommon.MultiTileArch.Enable)>(*tokMultiTileArch);
12980                                         } break;
12981                                         case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__TILE_INSTANCED: {
12982                                             dst.GmmResourceInfoCommon.MultiTileArch.TileInstanced = readTokValue<decltype(dst.GmmResourceInfoCommon.MultiTileArch.TileInstanced)>(*tokMultiTileArch);
12983                                         } break;
12984                                         case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__GPU_VA_MAPPING_SET: {
12985                                             dst.GmmResourceInfoCommon.MultiTileArch.GpuVaMappingSet = readTokValue<decltype(dst.GmmResourceInfoCommon.MultiTileArch.GpuVaMappingSet)>(*tokMultiTileArch);
12986                                         } break;
12987                                         case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_ELIGIBILITY_SET: {
12988                                             dst.GmmResourceInfoCommon.MultiTileArch.LocalMemEligibilitySet = readTokValue<decltype(dst.GmmResourceInfoCommon.MultiTileArch.LocalMemEligibilitySet)>(*tokMultiTileArch);
12989                                         } break;
12990                                         case TOK_FBC_GMM_MULTI_TILE_ARCH_REC__LOCAL_MEM_PREFERRED_SET: {
12991                                             dst.GmmResourceInfoCommon.MultiTileArch.LocalMemPreferredSet = readTokValue<decltype(dst.GmmResourceInfoCommon.MultiTileArch.LocalMemPreferredSet)>(*tokMultiTileArch);
12992                                         } break;
12993                                         };
12994                                         tokMultiTileArch = tokMultiTileArch + 1 + tokMultiTileArch->valueDwordCount;
12995                                     } else {
12996                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokMultiTileArch);
12997                                         if (tokMultiTileArch->flags.flag3IsMandatory) {
12998                                             return false;
12999                                         }
13000                                         tokMultiTileArch = tokMultiTileArch + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
13001                                     }
13002                                 }
13003                                 WCH_ASSERT(tokMultiTileArch == tokMultiTileArchEnd);
13004                             } break;
13005                             };
13006                             tokGmmResourceInfoCommon = tokGmmResourceInfoCommon + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
13007                         }
13008                     }
13009                     WCH_ASSERT(tokGmmResourceInfoCommon == tokGmmResourceInfoCommonEnd);
13010                 } break;
13011                 };
13012                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
13013             }
13014         }
13015         WCH_ASSERT(tok == srcTokensEnd);
13016         return true;
13017     }
13018 };
13019 
13020 template <>
13021 struct Demarshaller<TOK_S_GFX_ESCAPE_HEADER> {
13022     template <typename GFX_ESCAPE_HEADERT>
13023     static bool demarshall(GFX_ESCAPE_HEADERT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
13024         const TokenHeader *tok = srcTokensBeg;
13025         while (tok < srcTokensEnd) {
13026             if (false == tok->flags.flag4IsVariableLength) {
13027                 switch (tok->id) {
13028                 default:
13029                     if (tok->flags.flag3IsMandatory) {
13030                         return false;
13031                     }
13032                     break;
13033                 case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__SIZE: {
13034                     dst.Size = readTokValue<decltype(dst.Size)>(*tok);
13035                 } break;
13036                 case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__CHECK_SUM: {
13037                     dst.CheckSum = readTokValue<decltype(dst.CheckSum)>(*tok);
13038                 } break;
13039                 case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__ESCAPE_CODE: {
13040                     dst.EscapeCode = readTokValue<decltype(dst.EscapeCode)>(*tok);
13041                 } break;
13042                 case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__UL_RESERVED: {
13043                     dst.ulReserved = readTokValue<decltype(dst.ulReserved)>(*tok);
13044                 } break;
13045                 case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_RESERVED1: {
13046                     dst.ulReserved1 = readTokValue<decltype(dst.ulReserved1)>(*tok);
13047                 } break;
13048                 case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_ESCAPE_VERSION: {
13049                     dst.usEscapeVersion = readTokValue<decltype(dst.usEscapeVersion)>(*tok);
13050                 } break;
13051                 case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_FILE_VERSION: {
13052                     dst.usFileVersion = readTokValue<decltype(dst.usFileVersion)>(*tok);
13053                 } break;
13054                 case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_MAJOR_ESCAPE_CODE: {
13055                     dst.ulMajorEscapeCode = readTokValue<decltype(dst.ulMajorEscapeCode)>(*tok);
13056                 } break;
13057                 case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UI_MINOR_ESCAPE_CODE: {
13058                     dst.uiMinorEscapeCode = readTokValue<decltype(dst.uiMinorEscapeCode)>(*tok);
13059                 } break;
13060                 };
13061                 tok = tok + 1 + tok->valueDwordCount;
13062             } else {
13063                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
13064                 switch (tok->id) {
13065                 default:
13066                     if (tok->flags.flag3IsMandatory) {
13067                         return false;
13068                     }
13069                     break;
13070                 case TOK_S_GFX_ESCAPE_HEADER:
13071                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
13072                         return false;
13073                     }
13074                     break;
13075                 };
13076                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
13077             }
13078         }
13079         WCH_ASSERT(tok == srcTokensEnd);
13080         return true;
13081     }
13082 };
13083 
13084 template <>
13085 struct Demarshaller<TOK_S_GTDIBASE_IN_STRUCT> {
13086     template <typename GTDIBaseInStructT>
13087     static bool demarshall(GTDIBaseInStructT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
13088         const TokenHeader *tok = srcTokensBeg;
13089         while (tok < srcTokensEnd) {
13090             if (false == tok->flags.flag4IsVariableLength) {
13091                 switch (tok->id) {
13092                 default:
13093                     if (tok->flags.flag3IsMandatory) {
13094                         return false;
13095                     }
13096                     break;
13097                 case TOK_FE_GTDIBASE_IN_STRUCT__FUNCTION: {
13098                     dst.Function = readTokValue<decltype(dst.Function)>(*tok);
13099                 } break;
13100                 };
13101                 tok = tok + 1 + tok->valueDwordCount;
13102             } else {
13103                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
13104                 switch (tok->id) {
13105                 default:
13106                     if (tok->flags.flag3IsMandatory) {
13107                         return false;
13108                     }
13109                     break;
13110                 case TOK_S_GTDIBASE_IN_STRUCT:
13111                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
13112                         return false;
13113                     }
13114                     break;
13115                 };
13116                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
13117             }
13118         }
13119         WCH_ASSERT(tok == srcTokensEnd);
13120         return true;
13121     }
13122 };
13123 
13124 template <>
13125 struct Demarshaller<TOK_S_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT> {
13126     template <typename GTDIGetGpuCpuTimestampsOutStructT>
13127     static bool demarshall(GTDIGetGpuCpuTimestampsOutStructT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
13128         const TokenHeader *tok = srcTokensBeg;
13129         while (tok < srcTokensEnd) {
13130             if (false == tok->flags.flag4IsVariableLength) {
13131                 switch (tok->id) {
13132                 default:
13133                     if (tok->flags.flag3IsMandatory) {
13134                         return false;
13135                     }
13136                     break;
13137                 case TOK_FE_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__RET_CODE: {
13138                     dst.RetCode = readTokValue<decltype(dst.RetCode)>(*tok);
13139                 } break;
13140                 case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_TICKS: {
13141                     dst.gpuPerfTicks = readTokValue<decltype(dst.gpuPerfTicks)>(*tok);
13142                 } break;
13143                 case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_TICKS: {
13144                     dst.cpuPerfTicks = readTokValue<decltype(dst.cpuPerfTicks)>(*tok);
13145                 } break;
13146                 case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_FREQ: {
13147                     dst.gpuPerfFreq = readTokValue<decltype(dst.gpuPerfFreq)>(*tok);
13148                 } break;
13149                 case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_FREQ: {
13150                     dst.cpuPerfFreq = readTokValue<decltype(dst.cpuPerfFreq)>(*tok);
13151                 } break;
13152                 };
13153                 tok = tok + 1 + tok->valueDwordCount;
13154             } else {
13155                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
13156                 switch (tok->id) {
13157                 default:
13158                     if (tok->flags.flag3IsMandatory) {
13159                         return false;
13160                     }
13161                     break;
13162                 case TOK_S_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT:
13163                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
13164                         return false;
13165                     }
13166                     break;
13167                 };
13168                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
13169             }
13170         }
13171         WCH_ASSERT(tok == srcTokensEnd);
13172         return true;
13173     }
13174 };
13175 
13176 template <>
13177 struct Demarshaller<TOK_S_TIME_STAMP_DATA_HEADER> {
13178     template <typename TimeStampDataHeaderT>
13179     static bool demarshall(TimeStampDataHeaderT &dst, const TokenHeader *srcTokensBeg, const TokenHeader *srcTokensEnd) {
13180         const TokenHeader *tok = srcTokensBeg;
13181         while (tok < srcTokensEnd) {
13182             if (false == tok->flags.flag4IsVariableLength) {
13183                 if (tok->flags.flag3IsMandatory) {
13184                     return false;
13185                 }
13186                 tok = tok + 1 + tok->valueDwordCount;
13187             } else {
13188                 auto varLen = reinterpret_cast<const TokenVariableLength *>(tok);
13189                 switch (tok->id) {
13190                 default:
13191                     if (tok->flags.flag3IsMandatory) {
13192                         return false;
13193                     }
13194                     break;
13195                 case TOK_S_TIME_STAMP_DATA_HEADER:
13196                     if (false == demarshall(dst, varLen->getValue<TokenHeader>(), varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader))) {
13197                         return false;
13198                     }
13199                     break;
13200                 case TOK_FS_TIME_STAMP_DATA_HEADER__M_HEADER: {
13201                     const TokenHeader *tokM_Header = varLen->getValue<TokenHeader>();
13202                     const TokenHeader *tokM_HeaderEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
13203                     while (tokM_Header < tokM_HeaderEnd) {
13204                         if (false == tokM_Header->flags.flag4IsVariableLength) {
13205                             switch (tokM_Header->id) {
13206                             default:
13207                                 if (tokM_Header->flags.flag3IsMandatory) {
13208                                     return false;
13209                                 }
13210                                 break;
13211                             case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__SIZE: {
13212                                 dst.m_Header.Size = readTokValue<decltype(dst.m_Header.Size)>(*tokM_Header);
13213                             } break;
13214                             case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__CHECK_SUM: {
13215                                 dst.m_Header.CheckSum = readTokValue<decltype(dst.m_Header.CheckSum)>(*tokM_Header);
13216                             } break;
13217                             case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__ESCAPE_CODE: {
13218                                 dst.m_Header.EscapeCode = readTokValue<decltype(dst.m_Header.EscapeCode)>(*tokM_Header);
13219                             } break;
13220                             case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4430__UL_RESERVED: {
13221                                 dst.m_Header.ulReserved = readTokValue<decltype(dst.m_Header.ulReserved)>(*tokM_Header);
13222                             } break;
13223                             case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_RESERVED1: {
13224                                 dst.m_Header.ulReserved1 = readTokValue<decltype(dst.m_Header.ulReserved1)>(*tokM_Header);
13225                             } break;
13226                             case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_ESCAPE_VERSION: {
13227                                 dst.m_Header.usEscapeVersion = readTokValue<decltype(dst.m_Header.usEscapeVersion)>(*tokM_Header);
13228                             } break;
13229                             case TOK_FBW_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__US_FILE_VERSION: {
13230                                 dst.m_Header.usFileVersion = readTokValue<decltype(dst.m_Header.usFileVersion)>(*tokM_Header);
13231                             } break;
13232                             case TOK_FE_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UL_MAJOR_ESCAPE_CODE: {
13233                                 dst.m_Header.ulMajorEscapeCode = readTokValue<decltype(dst.m_Header.ulMajorEscapeCode)>(*tokM_Header);
13234                             } break;
13235                             case TOK_FBD_GFX_ESCAPE_HEADER__ANONYMOUS4410__ANONYMOUS4963__UI_MINOR_ESCAPE_CODE: {
13236                                 dst.m_Header.uiMinorEscapeCode = readTokValue<decltype(dst.m_Header.uiMinorEscapeCode)>(*tokM_Header);
13237                             } break;
13238                             };
13239                             tokM_Header = tokM_Header + 1 + tokM_Header->valueDwordCount;
13240                         } else {
13241                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokM_Header);
13242                             if (tokM_Header->flags.flag3IsMandatory) {
13243                                 return false;
13244                             }
13245                             tokM_Header = tokM_Header + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
13246                         }
13247                     }
13248                     WCH_ASSERT(tokM_Header == tokM_HeaderEnd);
13249                 } break;
13250                 case TOK_FS_TIME_STAMP_DATA_HEADER__M_DATA: {
13251                     const TokenHeader *tokM_Data = varLen->getValue<TokenHeader>();
13252                     const TokenHeader *tokM_DataEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
13253                     while (tokM_Data < tokM_DataEnd) {
13254                         if (false == tokM_Data->flags.flag4IsVariableLength) {
13255                             if (tokM_Data->flags.flag3IsMandatory) {
13256                                 return false;
13257                             }
13258                             tokM_Data = tokM_Data + 1 + tokM_Data->valueDwordCount;
13259                         } else {
13260                             auto varLen = reinterpret_cast<const TokenVariableLength *>(tokM_Data);
13261                             switch (tokM_Data->id) {
13262                             default:
13263                                 if (tokM_Data->flags.flag3IsMandatory) {
13264                                     return false;
13265                                 }
13266                                 break;
13267                             case TOK_FXS_TIME_STAMP_DATA_HEADER__ANONYMOUS2466__M_IN: {
13268                                 const TokenHeader *tokM_In = varLen->getValue<TokenHeader>();
13269                                 const TokenHeader *tokM_InEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
13270                                 while (tokM_In < tokM_InEnd) {
13271                                     if (false == tokM_In->flags.flag4IsVariableLength) {
13272                                         switch (tokM_In->id) {
13273                                         default:
13274                                             if (tokM_In->flags.flag3IsMandatory) {
13275                                                 return false;
13276                                             }
13277                                             break;
13278                                         case TOK_FE_GTDIBASE_IN_STRUCT__FUNCTION: {
13279                                             dst.m_Data.m_In.Function = readTokValue<decltype(dst.m_Data.m_In.Function)>(*tokM_In);
13280                                         } break;
13281                                         };
13282                                         tokM_In = tokM_In + 1 + tokM_In->valueDwordCount;
13283                                     } else {
13284                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokM_In);
13285                                         if (tokM_In->flags.flag3IsMandatory) {
13286                                             return false;
13287                                         }
13288                                         tokM_In = tokM_In + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
13289                                     }
13290                                 }
13291                                 WCH_ASSERT(tokM_In == tokM_InEnd);
13292                             } break;
13293                             case TOK_FS_TIME_STAMP_DATA_HEADER__ANONYMOUS2466__M_OUT: {
13294                                 const TokenHeader *tokM_Out = varLen->getValue<TokenHeader>();
13295                                 const TokenHeader *tokM_OutEnd = varLen->getValue<TokenHeader>() + varLen->valueLengthInBytes / sizeof(TokenHeader);
13296                                 while (tokM_Out < tokM_OutEnd) {
13297                                     if (false == tokM_Out->flags.flag4IsVariableLength) {
13298                                         switch (tokM_Out->id) {
13299                                         default:
13300                                             if (tokM_Out->flags.flag3IsMandatory) {
13301                                                 return false;
13302                                             }
13303                                             break;
13304                                         case TOK_FE_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__RET_CODE: {
13305                                             dst.m_Data.m_Out.RetCode = readTokValue<decltype(dst.m_Data.m_Out.RetCode)>(*tokM_Out);
13306                                         } break;
13307                                         case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_TICKS: {
13308                                             dst.m_Data.m_Out.gpuPerfTicks = readTokValue<decltype(dst.m_Data.m_Out.gpuPerfTicks)>(*tokM_Out);
13309                                         } break;
13310                                         case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_TICKS: {
13311                                             dst.m_Data.m_Out.cpuPerfTicks = readTokValue<decltype(dst.m_Data.m_Out.cpuPerfTicks)>(*tokM_Out);
13312                                         } break;
13313                                         case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__GPU_PERF_FREQ: {
13314                                             dst.m_Data.m_Out.gpuPerfFreq = readTokValue<decltype(dst.m_Data.m_Out.gpuPerfFreq)>(*tokM_Out);
13315                                         } break;
13316                                         case TOK_FBQ_GTDIGET_GPU_CPU_TIMESTAMPS_OUT_STRUCT__CPU_PERF_FREQ: {
13317                                             dst.m_Data.m_Out.cpuPerfFreq = readTokValue<decltype(dst.m_Data.m_Out.cpuPerfFreq)>(*tokM_Out);
13318                                         } break;
13319                                         };
13320                                         tokM_Out = tokM_Out + 1 + tokM_Out->valueDwordCount;
13321                                     } else {
13322                                         auto varLen = reinterpret_cast<const TokenVariableLength *>(tokM_Out);
13323                                         if (tokM_Out->flags.flag3IsMandatory) {
13324                                             return false;
13325                                         }
13326                                         tokM_Out = tokM_Out + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
13327                                     }
13328                                 }
13329                                 WCH_ASSERT(tokM_Out == tokM_OutEnd);
13330                             } break;
13331                             };
13332                             tokM_Data = tokM_Data + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
13333                         }
13334                     }
13335                     WCH_ASSERT(tokM_Data == tokM_DataEnd);
13336                 } break;
13337                 };
13338                 tok = tok + sizeof(TokenVariableLength) / sizeof(uint32_t) + varLen->valuePaddedSizeInDwords;
13339             }
13340         }
13341         WCH_ASSERT(tok == srcTokensEnd);
13342         return true;
13343     }
13344 };
13345