1 
2 // GENERATED FILE DO NOT EDIT
3 // $ xsltproc TagToType.xsl Part6.xml > gdcmTagToType.h
4 
5 /*=========================================================================
6 
7   Program: GDCM (Grassroots DICOM). A DICOM library
8 
9   Copyright (c) 2006-2011 Mathieu Malaterre
10   All rights reserved.
11   See Copyright.txt or http://gdcm.sourceforge.net/Copyright.html for details.
12 
13      This software is distributed WITHOUT ANY WARRANTY; without even
14      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15      PURPOSE.  See the above copyright notice for more information.
16 
17 =========================================================================*/
18 
19 #ifndef GDCMTAGTOTYPE_H
20 #define GDCMTAGTOTYPE_H
21 
22 #include "gdcmVR.h"
23 #include "gdcmVM.h"
24 #include "gdcmStaticAssert.h"
25 
26 namespace gdcm {
27 // default template: the compiler should only pick it up when the element is private:
28 template <uint16_t group,uint16_t element> struct TagToType {
29 //GDCM_STATIC_ASSERT( group % 2 );
30 enum : long long { VRType = VR::VRALL };
31 enum { VMType = VM::VM1_n };
32 };
33 // template for group length:
34 template <uint16_t group> struct TagToType<group,0x0000> {
35 static const char* GetVRString() { return "UL"; }
36 typedef VRToType<VR::UL>::Type Type;
37 enum : long long { VRType = VR::UL };
38 enum { VMType = VM::VM1 };
39 static const char* GetVMString() { return "1"; }
40 };
41 template <> struct TagToType<0x0000,0x0000> {
42 static const char* GetVRString() { return "UL"; }
43 typedef VRToType<VR::UL>::Type Type;
44 enum : long long { VRType = VR::UL };
45 enum { VMType = VM::VM1 };
46 static const char* GetVMString() { return "1"; }
47 };
48 template <> struct TagToType<0x0000,0x0001> {
49 static const char* GetVRString() { return "UL"; }
50 typedef VRToType<VR::UL>::Type Type;
51 enum : long long { VRType = VR::UL };
52 enum { VMType = VM::VM1 };
53 static const char* GetVMString() { return "1"; }
54 };
55 template <> struct TagToType<0x0000,0x0002> {
56 static const char* GetVRString() { return "UI"; }
57 typedef VRToType<VR::UI>::Type Type;
58 enum : long long { VRType = VR::UI };
59 enum { VMType = VM::VM1 };
60 static const char* GetVMString() { return "1"; }
61 };
62 template <> struct TagToType<0x0000,0x0003> {
63 static const char* GetVRString() { return "UI"; }
64 typedef VRToType<VR::UI>::Type Type;
65 enum : long long { VRType = VR::UI };
66 enum { VMType = VM::VM1 };
67 static const char* GetVMString() { return "1"; }
68 };
69 template <> struct TagToType<0x0000,0x0010> {
70 static const char* GetVRString() { return "SH"; }
71 typedef VRToType<VR::SH>::Type Type;
72 enum : long long { VRType = VR::SH };
73 enum { VMType = VM::VM1 };
74 static const char* GetVMString() { return "1"; }
75 };
76 template <> struct TagToType<0x0000,0x0100> {
77 static const char* GetVRString() { return "US"; }
78 typedef VRToType<VR::US>::Type Type;
79 enum : long long { VRType = VR::US };
80 enum { VMType = VM::VM1 };
81 static const char* GetVMString() { return "1"; }
82 };
83 template <> struct TagToType<0x0000,0x0110> {
84 static const char* GetVRString() { return "US"; }
85 typedef VRToType<VR::US>::Type Type;
86 enum : long long { VRType = VR::US };
87 enum { VMType = VM::VM1 };
88 static const char* GetVMString() { return "1"; }
89 };
90 template <> struct TagToType<0x0000,0x0120> {
91 static const char* GetVRString() { return "US"; }
92 typedef VRToType<VR::US>::Type Type;
93 enum : long long { VRType = VR::US };
94 enum { VMType = VM::VM1 };
95 static const char* GetVMString() { return "1"; }
96 };
97 template <> struct TagToType<0x0000,0x0200> {
98 static const char* GetVRString() { return "AE"; }
99 typedef VRToType<VR::AE>::Type Type;
100 enum : long long { VRType = VR::AE };
101 enum { VMType = VM::VM1 };
102 static const char* GetVMString() { return "1"; }
103 };
104 template <> struct TagToType<0x0000,0x0300> {
105 static const char* GetVRString() { return "AE"; }
106 typedef VRToType<VR::AE>::Type Type;
107 enum : long long { VRType = VR::AE };
108 enum { VMType = VM::VM1 };
109 static const char* GetVMString() { return "1"; }
110 };
111 template <> struct TagToType<0x0000,0x0400> {
112 static const char* GetVRString() { return "AE"; }
113 typedef VRToType<VR::AE>::Type Type;
114 enum : long long { VRType = VR::AE };
115 enum { VMType = VM::VM1 };
116 static const char* GetVMString() { return "1"; }
117 };
118 template <> struct TagToType<0x0000,0x0600> {
119 static const char* GetVRString() { return "AE"; }
120 typedef VRToType<VR::AE>::Type Type;
121 enum : long long { VRType = VR::AE };
122 enum { VMType = VM::VM1 };
123 static const char* GetVMString() { return "1"; }
124 };
125 template <> struct TagToType<0x0000,0x0700> {
126 static const char* GetVRString() { return "US"; }
127 typedef VRToType<VR::US>::Type Type;
128 enum : long long { VRType = VR::US };
129 enum { VMType = VM::VM1 };
130 static const char* GetVMString() { return "1"; }
131 };
132 template <> struct TagToType<0x0000,0x0800> {
133 static const char* GetVRString() { return "US"; }
134 typedef VRToType<VR::US>::Type Type;
135 enum : long long { VRType = VR::US };
136 enum { VMType = VM::VM1 };
137 static const char* GetVMString() { return "1"; }
138 };
139 template <> struct TagToType<0x0000,0x0850> {
140 static const char* GetVRString() { return "US"; }
141 typedef VRToType<VR::US>::Type Type;
142 enum : long long { VRType = VR::US };
143 enum { VMType = VM::VM1 };
144 static const char* GetVMString() { return "1"; }
145 };
146 template <> struct TagToType<0x0000,0x0860> {
147 static const char* GetVRString() { return "US"; }
148 typedef VRToType<VR::US>::Type Type;
149 enum : long long { VRType = VR::US };
150 enum { VMType = VM::VM1 };
151 static const char* GetVMString() { return "1"; }
152 };
153 template <> struct TagToType<0x0000,0x0900> {
154 static const char* GetVRString() { return "US"; }
155 typedef VRToType<VR::US>::Type Type;
156 enum : long long { VRType = VR::US };
157 enum { VMType = VM::VM1 };
158 static const char* GetVMString() { return "1"; }
159 };
160 template <> struct TagToType<0x0000,0x0901> {
161 static const char* GetVRString() { return "AT"; }
162 typedef VRToType<VR::AT>::Type Type;
163 enum : long long { VRType = VR::AT };
164 enum { VMType = VM::VM1_n };
165 static const char* GetVMString() { return "1-n"; }
166 };
167 template <> struct TagToType<0x0000,0x0902> {
168 static const char* GetVRString() { return "LO"; }
169 typedef VRToType<VR::LO>::Type Type;
170 enum : long long { VRType = VR::LO };
171 enum { VMType = VM::VM1 };
172 static const char* GetVMString() { return "1"; }
173 };
174 template <> struct TagToType<0x0000,0x0903> {
175 static const char* GetVRString() { return "US"; }
176 typedef VRToType<VR::US>::Type Type;
177 enum : long long { VRType = VR::US };
178 enum { VMType = VM::VM1 };
179 static const char* GetVMString() { return "1"; }
180 };
181 template <> struct TagToType<0x0000,0x1000> {
182 static const char* GetVRString() { return "UI"; }
183 typedef VRToType<VR::UI>::Type Type;
184 enum : long long { VRType = VR::UI };
185 enum { VMType = VM::VM1 };
186 static const char* GetVMString() { return "1"; }
187 };
188 template <> struct TagToType<0x0000,0x1001> {
189 static const char* GetVRString() { return "UI"; }
190 typedef VRToType<VR::UI>::Type Type;
191 enum : long long { VRType = VR::UI };
192 enum { VMType = VM::VM1 };
193 static const char* GetVMString() { return "1"; }
194 };
195 template <> struct TagToType<0x0000,0x1002> {
196 static const char* GetVRString() { return "US"; }
197 typedef VRToType<VR::US>::Type Type;
198 enum : long long { VRType = VR::US };
199 enum { VMType = VM::VM1 };
200 static const char* GetVMString() { return "1"; }
201 };
202 template <> struct TagToType<0x0000,0x1005> {
203 static const char* GetVRString() { return "AT"; }
204 typedef VRToType<VR::AT>::Type Type;
205 enum : long long { VRType = VR::AT };
206 enum { VMType = VM::VM1_n };
207 static const char* GetVMString() { return "1-n"; }
208 };
209 template <> struct TagToType<0x0000,0x1008> {
210 static const char* GetVRString() { return "US"; }
211 typedef VRToType<VR::US>::Type Type;
212 enum : long long { VRType = VR::US };
213 enum { VMType = VM::VM1 };
214 static const char* GetVMString() { return "1"; }
215 };
216 template <> struct TagToType<0x0000,0x1020> {
217 static const char* GetVRString() { return "US"; }
218 typedef VRToType<VR::US>::Type Type;
219 enum : long long { VRType = VR::US };
220 enum { VMType = VM::VM1 };
221 static const char* GetVMString() { return "1"; }
222 };
223 template <> struct TagToType<0x0000,0x1021> {
224 static const char* GetVRString() { return "US"; }
225 typedef VRToType<VR::US>::Type Type;
226 enum : long long { VRType = VR::US };
227 enum { VMType = VM::VM1 };
228 static const char* GetVMString() { return "1"; }
229 };
230 template <> struct TagToType<0x0000,0x1022> {
231 static const char* GetVRString() { return "US"; }
232 typedef VRToType<VR::US>::Type Type;
233 enum : long long { VRType = VR::US };
234 enum { VMType = VM::VM1 };
235 static const char* GetVMString() { return "1"; }
236 };
237 template <> struct TagToType<0x0000,0x1023> {
238 static const char* GetVRString() { return "US"; }
239 typedef VRToType<VR::US>::Type Type;
240 enum : long long { VRType = VR::US };
241 enum { VMType = VM::VM1 };
242 static const char* GetVMString() { return "1"; }
243 };
244 template <> struct TagToType<0x0000,0x1030> {
245 static const char* GetVRString() { return "AE"; }
246 typedef VRToType<VR::AE>::Type Type;
247 enum : long long { VRType = VR::AE };
248 enum { VMType = VM::VM1 };
249 static const char* GetVMString() { return "1"; }
250 };
251 template <> struct TagToType<0x0000,0x1031> {
252 static const char* GetVRString() { return "US"; }
253 typedef VRToType<VR::US>::Type Type;
254 enum : long long { VRType = VR::US };
255 enum { VMType = VM::VM1 };
256 static const char* GetVMString() { return "1"; }
257 };
258 template <> struct TagToType<0x0000,0x4000> {
259 static const char* GetVRString() { return "LT"; }
260 typedef VRToType<VR::LT>::Type Type;
261 enum : long long { VRType = VR::LT };
262 enum { VMType = VM::VM1 };
263 static const char* GetVMString() { return "1"; }
264 };
265 template <> struct TagToType<0x0000,0x4010> {
266 static const char* GetVRString() { return "LT"; }
267 typedef VRToType<VR::LT>::Type Type;
268 enum : long long { VRType = VR::LT };
269 enum { VMType = VM::VM1 };
270 static const char* GetVMString() { return "1"; }
271 };
272 template <> struct TagToType<0x0000,0x5010> {
273 static const char* GetVRString() { return "SH"; }
274 typedef VRToType<VR::SH>::Type Type;
275 enum : long long { VRType = VR::SH };
276 enum { VMType = VM::VM1 };
277 static const char* GetVMString() { return "1"; }
278 };
279 template <> struct TagToType<0x0000,0x5020> {
280 static const char* GetVRString() { return "SH"; }
281 typedef VRToType<VR::SH>::Type Type;
282 enum : long long { VRType = VR::SH };
283 enum { VMType = VM::VM1 };
284 static const char* GetVMString() { return "1"; }
285 };
286 template <> struct TagToType<0x0000,0x5110> {
287 static const char* GetVRString() { return "LT"; }
288 typedef VRToType<VR::LT>::Type Type;
289 enum : long long { VRType = VR::LT };
290 enum { VMType = VM::VM1 };
291 static const char* GetVMString() { return "1"; }
292 };
293 template <> struct TagToType<0x0000,0x5120> {
294 static const char* GetVRString() { return "LT"; }
295 typedef VRToType<VR::LT>::Type Type;
296 enum : long long { VRType = VR::LT };
297 enum { VMType = VM::VM1 };
298 static const char* GetVMString() { return "1"; }
299 };
300 template <> struct TagToType<0x0000,0x5130> {
301 static const char* GetVRString() { return "CS"; }
302 typedef VRToType<VR::CS>::Type Type;
303 enum : long long { VRType = VR::CS };
304 enum { VMType = VM::VM1 };
305 static const char* GetVMString() { return "1"; }
306 };
307 template <> struct TagToType<0x0000,0x5140> {
308 static const char* GetVRString() { return "CS"; }
309 typedef VRToType<VR::CS>::Type Type;
310 enum : long long { VRType = VR::CS };
311 enum { VMType = VM::VM1 };
312 static const char* GetVMString() { return "1"; }
313 };
314 template <> struct TagToType<0x0000,0x5150> {
315 static const char* GetVRString() { return "CS"; }
316 typedef VRToType<VR::CS>::Type Type;
317 enum : long long { VRType = VR::CS };
318 enum { VMType = VM::VM1 };
319 static const char* GetVMString() { return "1"; }
320 };
321 template <> struct TagToType<0x0000,0x5160> {
322 static const char* GetVRString() { return "CS"; }
323 typedef VRToType<VR::CS>::Type Type;
324 enum : long long { VRType = VR::CS };
325 enum { VMType = VM::VM1 };
326 static const char* GetVMString() { return "1"; }
327 };
328 template <> struct TagToType<0x0000,0x5170> {
329 static const char* GetVRString() { return "IS"; }
330 typedef VRToType<VR::IS>::Type Type;
331 enum : long long { VRType = VR::IS };
332 enum { VMType = VM::VM1 };
333 static const char* GetVMString() { return "1"; }
334 };
335 template <> struct TagToType<0x0000,0x5180> {
336 static const char* GetVRString() { return "CS"; }
337 typedef VRToType<VR::CS>::Type Type;
338 enum : long long { VRType = VR::CS };
339 enum { VMType = VM::VM1 };
340 static const char* GetVMString() { return "1"; }
341 };
342 template <> struct TagToType<0x0000,0x5190> {
343 static const char* GetVRString() { return "CS"; }
344 typedef VRToType<VR::CS>::Type Type;
345 enum : long long { VRType = VR::CS };
346 enum { VMType = VM::VM1 };
347 static const char* GetVMString() { return "1"; }
348 };
349 template <> struct TagToType<0x0000,0x51a0> {
350 static const char* GetVRString() { return "CS"; }
351 typedef VRToType<VR::CS>::Type Type;
352 enum : long long { VRType = VR::CS };
353 enum { VMType = VM::VM1 };
354 static const char* GetVMString() { return "1"; }
355 };
356 template <> struct TagToType<0x0000,0x51b0> {
357 static const char* GetVRString() { return "US"; }
358 typedef VRToType<VR::US>::Type Type;
359 enum : long long { VRType = VR::US };
360 enum { VMType = VM::VM1_n };
361 static const char* GetVMString() { return "1-n"; }
362 };
363 template <> struct TagToType<0x0002,0x0000> {
364 static const char* GetVRString() { return "UL"; }
365 typedef VRToType<VR::UL>::Type Type;
366 enum : long long { VRType = VR::UL };
367 enum { VMType = VM::VM1 };
368 static const char* GetVMString() { return "1"; }
369 };
370 template <> struct TagToType<0x0002,0x0001> {
371 static const char* GetVRString() { return "OB"; }
372 typedef VRToType<VR::OB>::Type Type;
373 enum : long long { VRType = VR::OB };
374 enum { VMType = VM::VM1 };
375 static const char* GetVMString() { return "1"; }
376 };
377 template <> struct TagToType<0x0002,0x0002> {
378 static const char* GetVRString() { return "UI"; }
379 typedef VRToType<VR::UI>::Type Type;
380 enum : long long { VRType = VR::UI };
381 enum { VMType = VM::VM1 };
382 static const char* GetVMString() { return "1"; }
383 };
384 template <> struct TagToType<0x0002,0x0003> {
385 static const char* GetVRString() { return "UI"; }
386 typedef VRToType<VR::UI>::Type Type;
387 enum : long long { VRType = VR::UI };
388 enum { VMType = VM::VM1 };
389 static const char* GetVMString() { return "1"; }
390 };
391 template <> struct TagToType<0x0002,0x0010> {
392 static const char* GetVRString() { return "UI"; }
393 typedef VRToType<VR::UI>::Type Type;
394 enum : long long { VRType = VR::UI };
395 enum { VMType = VM::VM1 };
396 static const char* GetVMString() { return "1"; }
397 };
398 template <> struct TagToType<0x0002,0x0012> {
399 static const char* GetVRString() { return "UI"; }
400 typedef VRToType<VR::UI>::Type Type;
401 enum : long long { VRType = VR::UI };
402 enum { VMType = VM::VM1 };
403 static const char* GetVMString() { return "1"; }
404 };
405 template <> struct TagToType<0x0002,0x0013> {
406 static const char* GetVRString() { return "SH"; }
407 typedef VRToType<VR::SH>::Type Type;
408 enum : long long { VRType = VR::SH };
409 enum { VMType = VM::VM1 };
410 static const char* GetVMString() { return "1"; }
411 };
412 template <> struct TagToType<0x0002,0x0016> {
413 static const char* GetVRString() { return "AE"; }
414 typedef VRToType<VR::AE>::Type Type;
415 enum : long long { VRType = VR::AE };
416 enum { VMType = VM::VM1 };
417 static const char* GetVMString() { return "1"; }
418 };
419 template <> struct TagToType<0x0002,0x0017> {
420 static const char* GetVRString() { return "AE"; }
421 typedef VRToType<VR::AE>::Type Type;
422 enum : long long { VRType = VR::AE };
423 enum { VMType = VM::VM1 };
424 static const char* GetVMString() { return "1"; }
425 };
426 template <> struct TagToType<0x0002,0x0018> {
427 static const char* GetVRString() { return "AE"; }
428 typedef VRToType<VR::AE>::Type Type;
429 enum : long long { VRType = VR::AE };
430 enum { VMType = VM::VM1 };
431 static const char* GetVMString() { return "1"; }
432 };
433 template <> struct TagToType<0x0002,0x0100> {
434 static const char* GetVRString() { return "UI"; }
435 typedef VRToType<VR::UI>::Type Type;
436 enum : long long { VRType = VR::UI };
437 enum { VMType = VM::VM1 };
438 static const char* GetVMString() { return "1"; }
439 };
440 template <> struct TagToType<0x0002,0x0102> {
441 static const char* GetVRString() { return "OB"; }
442 typedef VRToType<VR::OB>::Type Type;
443 enum : long long { VRType = VR::OB };
444 enum { VMType = VM::VM1 };
445 static const char* GetVMString() { return "1"; }
446 };
447 template <> struct TagToType<0x0004,0x1130> {
448 static const char* GetVRString() { return "CS"; }
449 typedef VRToType<VR::CS>::Type Type;
450 enum : long long { VRType = VR::CS };
451 enum { VMType = VM::VM1 };
452 static const char* GetVMString() { return "1"; }
453 };
454 template <> struct TagToType<0x0004,0x1141> {
455 static const char* GetVRString() { return "CS"; }
456 typedef VRToType<VR::CS>::Type Type;
457 enum : long long { VRType = VR::CS };
458 enum { VMType = VM::VM1_8 };
459 static const char* GetVMString() { return "1-8"; }
460 };
461 template <> struct TagToType<0x0004,0x1142> {
462 static const char* GetVRString() { return "CS"; }
463 typedef VRToType<VR::CS>::Type Type;
464 enum : long long { VRType = VR::CS };
465 enum { VMType = VM::VM1 };
466 static const char* GetVMString() { return "1"; }
467 };
468 template <> struct TagToType<0x0004,0x1200> {
469 static const char* GetVRString() { return "UL"; }
470 typedef VRToType<VR::UL>::Type Type;
471 enum : long long { VRType = VR::UL };
472 enum { VMType = VM::VM1 };
473 static const char* GetVMString() { return "1"; }
474 };
475 template <> struct TagToType<0x0004,0x1202> {
476 static const char* GetVRString() { return "UL"; }
477 typedef VRToType<VR::UL>::Type Type;
478 enum : long long { VRType = VR::UL };
479 enum { VMType = VM::VM1 };
480 static const char* GetVMString() { return "1"; }
481 };
482 template <> struct TagToType<0x0004,0x1212> {
483 static const char* GetVRString() { return "US"; }
484 typedef VRToType<VR::US>::Type Type;
485 enum : long long { VRType = VR::US };
486 enum { VMType = VM::VM1 };
487 static const char* GetVMString() { return "1"; }
488 };
489 template <> struct TagToType<0x0004,0x1220> {
490 static const char* GetVRString() { return "SQ"; }
491 typedef VRToType<VR::SQ>::Type Type;
492 enum : long long { VRType = VR::SQ };
493 enum { VMType = VM::VM1 };
494 static const char* GetVMString() { return "1"; }
495 };
496 template <> struct TagToType<0x0004,0x1400> {
497 static const char* GetVRString() { return "UL"; }
498 typedef VRToType<VR::UL>::Type Type;
499 enum : long long { VRType = VR::UL };
500 enum { VMType = VM::VM1 };
501 static const char* GetVMString() { return "1"; }
502 };
503 template <> struct TagToType<0x0004,0x1410> {
504 static const char* GetVRString() { return "US"; }
505 typedef VRToType<VR::US>::Type Type;
506 enum : long long { VRType = VR::US };
507 enum { VMType = VM::VM1 };
508 static const char* GetVMString() { return "1"; }
509 };
510 template <> struct TagToType<0x0004,0x1420> {
511 static const char* GetVRString() { return "UL"; }
512 typedef VRToType<VR::UL>::Type Type;
513 enum : long long { VRType = VR::UL };
514 enum { VMType = VM::VM1 };
515 static const char* GetVMString() { return "1"; }
516 };
517 template <> struct TagToType<0x0004,0x1430> {
518 static const char* GetVRString() { return "CS"; }
519 typedef VRToType<VR::CS>::Type Type;
520 enum : long long { VRType = VR::CS };
521 enum { VMType = VM::VM1 };
522 static const char* GetVMString() { return "1"; }
523 };
524 template <> struct TagToType<0x0004,0x1432> {
525 static const char* GetVRString() { return "UI"; }
526 typedef VRToType<VR::UI>::Type Type;
527 enum : long long { VRType = VR::UI };
528 enum { VMType = VM::VM1 };
529 static const char* GetVMString() { return "1"; }
530 };
531 template <> struct TagToType<0x0004,0x1500> {
532 static const char* GetVRString() { return "CS"; }
533 typedef VRToType<VR::CS>::Type Type;
534 enum : long long { VRType = VR::CS };
535 enum { VMType = VM::VM1_8 };
536 static const char* GetVMString() { return "1-8"; }
537 };
538 template <> struct TagToType<0x0004,0x1504> {
539 static const char* GetVRString() { return "UL"; }
540 typedef VRToType<VR::UL>::Type Type;
541 enum : long long { VRType = VR::UL };
542 enum { VMType = VM::VM1 };
543 static const char* GetVMString() { return "1"; }
544 };
545 template <> struct TagToType<0x0004,0x1510> {
546 static const char* GetVRString() { return "UI"; }
547 typedef VRToType<VR::UI>::Type Type;
548 enum : long long { VRType = VR::UI };
549 enum { VMType = VM::VM1 };
550 static const char* GetVMString() { return "1"; }
551 };
552 template <> struct TagToType<0x0004,0x1511> {
553 static const char* GetVRString() { return "UI"; }
554 typedef VRToType<VR::UI>::Type Type;
555 enum : long long { VRType = VR::UI };
556 enum { VMType = VM::VM1 };
557 static const char* GetVMString() { return "1"; }
558 };
559 template <> struct TagToType<0x0004,0x1512> {
560 static const char* GetVRString() { return "UI"; }
561 typedef VRToType<VR::UI>::Type Type;
562 enum : long long { VRType = VR::UI };
563 enum { VMType = VM::VM1 };
564 static const char* GetVMString() { return "1"; }
565 };
566 template <> struct TagToType<0x0004,0x151a> {
567 static const char* GetVRString() { return "UI"; }
568 typedef VRToType<VR::UI>::Type Type;
569 enum : long long { VRType = VR::UI };
570 enum { VMType = VM::VM1_n };
571 static const char* GetVMString() { return "1-n"; }
572 };
573 template <> struct TagToType<0x0004,0x1600> {
574 static const char* GetVRString() { return "UL"; }
575 typedef VRToType<VR::UL>::Type Type;
576 enum : long long { VRType = VR::UL };
577 enum { VMType = VM::VM1 };
578 static const char* GetVMString() { return "1"; }
579 };
580 template <> struct TagToType<0x0008,0x0001> {
581 static const char* GetVRString() { return "UL"; }
582 typedef VRToType<VR::UL>::Type Type;
583 enum : long long { VRType = VR::UL };
584 enum { VMType = VM::VM1 };
585 static const char* GetVMString() { return "1"; }
586 };
587 template <> struct TagToType<0x0008,0x0005> {
588 static const char* GetVRString() { return "CS"; }
589 typedef VRToType<VR::CS>::Type Type;
590 enum : long long { VRType = VR::CS };
591 enum { VMType = VM::VM1_n };
592 static const char* GetVMString() { return "1-n"; }
593 };
594 template <> struct TagToType<0x0008,0x0006> {
595 static const char* GetVRString() { return "SQ"; }
596 typedef VRToType<VR::SQ>::Type Type;
597 enum : long long { VRType = VR::SQ };
598 enum { VMType = VM::VM1 };
599 static const char* GetVMString() { return "1"; }
600 };
601 template <> struct TagToType<0x0008,0x0008> {
602 static const char* GetVRString() { return "CS"; }
603 typedef VRToType<VR::CS>::Type Type;
604 enum : long long { VRType = VR::CS };
605 enum { VMType = VM::VM2_n };
606 static const char* GetVMString() { return "2-n"; }
607 };
608 template <> struct TagToType<0x0008,0x0010> {
609 static const char* GetVRString() { return "SH"; }
610 typedef VRToType<VR::SH>::Type Type;
611 enum : long long { VRType = VR::SH };
612 enum { VMType = VM::VM1 };
613 static const char* GetVMString() { return "1"; }
614 };
615 template <> struct TagToType<0x0008,0x0012> {
616 static const char* GetVRString() { return "DA"; }
617 typedef VRToType<VR::DA>::Type Type;
618 enum : long long { VRType = VR::DA };
619 enum { VMType = VM::VM1 };
620 static const char* GetVMString() { return "1"; }
621 };
622 template <> struct TagToType<0x0008,0x0013> {
623 static const char* GetVRString() { return "TM"; }
624 typedef VRToType<VR::TM>::Type Type;
625 enum : long long { VRType = VR::TM };
626 enum { VMType = VM::VM1 };
627 static const char* GetVMString() { return "1"; }
628 };
629 template <> struct TagToType<0x0008,0x0014> {
630 static const char* GetVRString() { return "UI"; }
631 typedef VRToType<VR::UI>::Type Type;
632 enum : long long { VRType = VR::UI };
633 enum { VMType = VM::VM1 };
634 static const char* GetVMString() { return "1"; }
635 };
636 template <> struct TagToType<0x0008,0x0015> {
637 static const char* GetVRString() { return "DT"; }
638 typedef VRToType<VR::DT>::Type Type;
639 enum : long long { VRType = VR::DT };
640 enum { VMType = VM::VM1 };
641 static const char* GetVMString() { return "1"; }
642 };
643 template <> struct TagToType<0x0008,0x0016> {
644 static const char* GetVRString() { return "UI"; }
645 typedef VRToType<VR::UI>::Type Type;
646 enum : long long { VRType = VR::UI };
647 enum { VMType = VM::VM1 };
648 static const char* GetVMString() { return "1"; }
649 };
650 template <> struct TagToType<0x0008,0x0018> {
651 static const char* GetVRString() { return "UI"; }
652 typedef VRToType<VR::UI>::Type Type;
653 enum : long long { VRType = VR::UI };
654 enum { VMType = VM::VM1 };
655 static const char* GetVMString() { return "1"; }
656 };
657 template <> struct TagToType<0x0008,0x001a> {
658 static const char* GetVRString() { return "UI"; }
659 typedef VRToType<VR::UI>::Type Type;
660 enum : long long { VRType = VR::UI };
661 enum { VMType = VM::VM1_n };
662 static const char* GetVMString() { return "1-n"; }
663 };
664 template <> struct TagToType<0x0008,0x001b> {
665 static const char* GetVRString() { return "UI"; }
666 typedef VRToType<VR::UI>::Type Type;
667 enum : long long { VRType = VR::UI };
668 enum { VMType = VM::VM1 };
669 static const char* GetVMString() { return "1"; }
670 };
671 template <> struct TagToType<0x0008,0x0020> {
672 static const char* GetVRString() { return "DA"; }
673 typedef VRToType<VR::DA>::Type Type;
674 enum : long long { VRType = VR::DA };
675 enum { VMType = VM::VM1 };
676 static const char* GetVMString() { return "1"; }
677 };
678 template <> struct TagToType<0x0008,0x0021> {
679 static const char* GetVRString() { return "DA"; }
680 typedef VRToType<VR::DA>::Type Type;
681 enum : long long { VRType = VR::DA };
682 enum { VMType = VM::VM1 };
683 static const char* GetVMString() { return "1"; }
684 };
685 template <> struct TagToType<0x0008,0x0022> {
686 static const char* GetVRString() { return "DA"; }
687 typedef VRToType<VR::DA>::Type Type;
688 enum : long long { VRType = VR::DA };
689 enum { VMType = VM::VM1 };
690 static const char* GetVMString() { return "1"; }
691 };
692 template <> struct TagToType<0x0008,0x0023> {
693 static const char* GetVRString() { return "DA"; }
694 typedef VRToType<VR::DA>::Type Type;
695 enum : long long { VRType = VR::DA };
696 enum { VMType = VM::VM1 };
697 static const char* GetVMString() { return "1"; }
698 };
699 template <> struct TagToType<0x0008,0x0024> {
700 static const char* GetVRString() { return "DA"; }
701 typedef VRToType<VR::DA>::Type Type;
702 enum : long long { VRType = VR::DA };
703 enum { VMType = VM::VM1 };
704 static const char* GetVMString() { return "1"; }
705 };
706 template <> struct TagToType<0x0008,0x0025> {
707 static const char* GetVRString() { return "DA"; }
708 typedef VRToType<VR::DA>::Type Type;
709 enum : long long { VRType = VR::DA };
710 enum { VMType = VM::VM1 };
711 static const char* GetVMString() { return "1"; }
712 };
713 template <> struct TagToType<0x0008,0x002a> {
714 static const char* GetVRString() { return "DT"; }
715 typedef VRToType<VR::DT>::Type Type;
716 enum : long long { VRType = VR::DT };
717 enum { VMType = VM::VM1 };
718 static const char* GetVMString() { return "1"; }
719 };
720 template <> struct TagToType<0x0008,0x0030> {
721 static const char* GetVRString() { return "TM"; }
722 typedef VRToType<VR::TM>::Type Type;
723 enum : long long { VRType = VR::TM };
724 enum { VMType = VM::VM1 };
725 static const char* GetVMString() { return "1"; }
726 };
727 template <> struct TagToType<0x0008,0x0031> {
728 static const char* GetVRString() { return "TM"; }
729 typedef VRToType<VR::TM>::Type Type;
730 enum : long long { VRType = VR::TM };
731 enum { VMType = VM::VM1 };
732 static const char* GetVMString() { return "1"; }
733 };
734 template <> struct TagToType<0x0008,0x0032> {
735 static const char* GetVRString() { return "TM"; }
736 typedef VRToType<VR::TM>::Type Type;
737 enum : long long { VRType = VR::TM };
738 enum { VMType = VM::VM1 };
739 static const char* GetVMString() { return "1"; }
740 };
741 template <> struct TagToType<0x0008,0x0033> {
742 static const char* GetVRString() { return "TM"; }
743 typedef VRToType<VR::TM>::Type Type;
744 enum : long long { VRType = VR::TM };
745 enum { VMType = VM::VM1 };
746 static const char* GetVMString() { return "1"; }
747 };
748 template <> struct TagToType<0x0008,0x0034> {
749 static const char* GetVRString() { return "TM"; }
750 typedef VRToType<VR::TM>::Type Type;
751 enum : long long { VRType = VR::TM };
752 enum { VMType = VM::VM1 };
753 static const char* GetVMString() { return "1"; }
754 };
755 template <> struct TagToType<0x0008,0x0035> {
756 static const char* GetVRString() { return "TM"; }
757 typedef VRToType<VR::TM>::Type Type;
758 enum : long long { VRType = VR::TM };
759 enum { VMType = VM::VM1 };
760 static const char* GetVMString() { return "1"; }
761 };
762 template <> struct TagToType<0x0008,0x0040> {
763 static const char* GetVRString() { return "US"; }
764 typedef VRToType<VR::US>::Type Type;
765 enum : long long { VRType = VR::US };
766 enum { VMType = VM::VM1 };
767 static const char* GetVMString() { return "1"; }
768 };
769 template <> struct TagToType<0x0008,0x0041> {
770 static const char* GetVRString() { return "LO"; }
771 typedef VRToType<VR::LO>::Type Type;
772 enum : long long { VRType = VR::LO };
773 enum { VMType = VM::VM1 };
774 static const char* GetVMString() { return "1"; }
775 };
776 template <> struct TagToType<0x0008,0x0042> {
777 static const char* GetVRString() { return "CS"; }
778 typedef VRToType<VR::CS>::Type Type;
779 enum : long long { VRType = VR::CS };
780 enum { VMType = VM::VM1 };
781 static const char* GetVMString() { return "1"; }
782 };
783 template <> struct TagToType<0x0008,0x0050> {
784 static const char* GetVRString() { return "SH"; }
785 typedef VRToType<VR::SH>::Type Type;
786 enum : long long { VRType = VR::SH };
787 enum { VMType = VM::VM1 };
788 static const char* GetVMString() { return "1"; }
789 };
790 template <> struct TagToType<0x0008,0x0051> {
791 static const char* GetVRString() { return "SQ"; }
792 typedef VRToType<VR::SQ>::Type Type;
793 enum : long long { VRType = VR::SQ };
794 enum { VMType = VM::VM1 };
795 static const char* GetVMString() { return "1"; }
796 };
797 template <> struct TagToType<0x0008,0x0052> {
798 static const char* GetVRString() { return "CS"; }
799 typedef VRToType<VR::CS>::Type Type;
800 enum : long long { VRType = VR::CS };
801 enum { VMType = VM::VM1 };
802 static const char* GetVMString() { return "1"; }
803 };
804 template <> struct TagToType<0x0008,0x0053> {
805 static const char* GetVRString() { return "CS"; }
806 typedef VRToType<VR::CS>::Type Type;
807 enum : long long { VRType = VR::CS };
808 enum { VMType = VM::VM1 };
809 static const char* GetVMString() { return "1"; }
810 };
811 template <> struct TagToType<0x0008,0x0054> {
812 static const char* GetVRString() { return "AE"; }
813 typedef VRToType<VR::AE>::Type Type;
814 enum : long long { VRType = VR::AE };
815 enum { VMType = VM::VM1_n };
816 static const char* GetVMString() { return "1-n"; }
817 };
818 template <> struct TagToType<0x0008,0x0055> {
819 static const char* GetVRString() { return "AE"; }
820 typedef VRToType<VR::AE>::Type Type;
821 enum : long long { VRType = VR::AE };
822 enum { VMType = VM::VM1 };
823 static const char* GetVMString() { return "1"; }
824 };
825 template <> struct TagToType<0x0008,0x0056> {
826 static const char* GetVRString() { return "CS"; }
827 typedef VRToType<VR::CS>::Type Type;
828 enum : long long { VRType = VR::CS };
829 enum { VMType = VM::VM1 };
830 static const char* GetVMString() { return "1"; }
831 };
832 template <> struct TagToType<0x0008,0x0058> {
833 static const char* GetVRString() { return "UI"; }
834 typedef VRToType<VR::UI>::Type Type;
835 enum : long long { VRType = VR::UI };
836 enum { VMType = VM::VM1_n };
837 static const char* GetVMString() { return "1-n"; }
838 };
839 template <> struct TagToType<0x0008,0x0060> {
840 static const char* GetVRString() { return "CS"; }
841 typedef VRToType<VR::CS>::Type Type;
842 enum : long long { VRType = VR::CS };
843 enum { VMType = VM::VM1 };
844 static const char* GetVMString() { return "1"; }
845 };
846 template <> struct TagToType<0x0008,0x0061> {
847 static const char* GetVRString() { return "CS"; }
848 typedef VRToType<VR::CS>::Type Type;
849 enum : long long { VRType = VR::CS };
850 enum { VMType = VM::VM1_n };
851 static const char* GetVMString() { return "1-n"; }
852 };
853 template <> struct TagToType<0x0008,0x0062> {
854 static const char* GetVRString() { return "UI"; }
855 typedef VRToType<VR::UI>::Type Type;
856 enum : long long { VRType = VR::UI };
857 enum { VMType = VM::VM1_n };
858 static const char* GetVMString() { return "1-n"; }
859 };
860 template <> struct TagToType<0x0008,0x0064> {
861 static const char* GetVRString() { return "CS"; }
862 typedef VRToType<VR::CS>::Type Type;
863 enum : long long { VRType = VR::CS };
864 enum { VMType = VM::VM1 };
865 static const char* GetVMString() { return "1"; }
866 };
867 template <> struct TagToType<0x0008,0x0068> {
868 static const char* GetVRString() { return "CS"; }
869 typedef VRToType<VR::CS>::Type Type;
870 enum : long long { VRType = VR::CS };
871 enum { VMType = VM::VM1 };
872 static const char* GetVMString() { return "1"; }
873 };
874 template <> struct TagToType<0x0008,0x0070> {
875 static const char* GetVRString() { return "LO"; }
876 typedef VRToType<VR::LO>::Type Type;
877 enum : long long { VRType = VR::LO };
878 enum { VMType = VM::VM1 };
879 static const char* GetVMString() { return "1"; }
880 };
881 template <> struct TagToType<0x0008,0x0080> {
882 static const char* GetVRString() { return "LO"; }
883 typedef VRToType<VR::LO>::Type Type;
884 enum : long long { VRType = VR::LO };
885 enum { VMType = VM::VM1 };
886 static const char* GetVMString() { return "1"; }
887 };
888 template <> struct TagToType<0x0008,0x0081> {
889 static const char* GetVRString() { return "ST"; }
890 typedef VRToType<VR::ST>::Type Type;
891 enum : long long { VRType = VR::ST };
892 enum { VMType = VM::VM1 };
893 static const char* GetVMString() { return "1"; }
894 };
895 template <> struct TagToType<0x0008,0x0082> {
896 static const char* GetVRString() { return "SQ"; }
897 typedef VRToType<VR::SQ>::Type Type;
898 enum : long long { VRType = VR::SQ };
899 enum { VMType = VM::VM1 };
900 static const char* GetVMString() { return "1"; }
901 };
902 template <> struct TagToType<0x0008,0x0090> {
903 static const char* GetVRString() { return "PN"; }
904 typedef VRToType<VR::PN>::Type Type;
905 enum : long long { VRType = VR::PN };
906 enum { VMType = VM::VM1 };
907 static const char* GetVMString() { return "1"; }
908 };
909 template <> struct TagToType<0x0008,0x0092> {
910 static const char* GetVRString() { return "ST"; }
911 typedef VRToType<VR::ST>::Type Type;
912 enum : long long { VRType = VR::ST };
913 enum { VMType = VM::VM1 };
914 static const char* GetVMString() { return "1"; }
915 };
916 template <> struct TagToType<0x0008,0x0094> {
917 static const char* GetVRString() { return "SH"; }
918 typedef VRToType<VR::SH>::Type Type;
919 enum : long long { VRType = VR::SH };
920 enum { VMType = VM::VM1_n };
921 static const char* GetVMString() { return "1-n"; }
922 };
923 template <> struct TagToType<0x0008,0x0096> {
924 static const char* GetVRString() { return "SQ"; }
925 typedef VRToType<VR::SQ>::Type Type;
926 enum : long long { VRType = VR::SQ };
927 enum { VMType = VM::VM1 };
928 static const char* GetVMString() { return "1"; }
929 };
930 template <> struct TagToType<0x0008,0x009c> {
931 static const char* GetVRString() { return "PN"; }
932 typedef VRToType<VR::PN>::Type Type;
933 enum : long long { VRType = VR::PN };
934 enum { VMType = VM::VM1_n };
935 static const char* GetVMString() { return "1-n"; }
936 };
937 template <> struct TagToType<0x0008,0x009d> {
938 static const char* GetVRString() { return "SQ"; }
939 typedef VRToType<VR::SQ>::Type Type;
940 enum : long long { VRType = VR::SQ };
941 enum { VMType = VM::VM1 };
942 static const char* GetVMString() { return "1"; }
943 };
944 template <> struct TagToType<0x0008,0x0100> {
945 static const char* GetVRString() { return "SH"; }
946 typedef VRToType<VR::SH>::Type Type;
947 enum : long long { VRType = VR::SH };
948 enum { VMType = VM::VM1 };
949 static const char* GetVMString() { return "1"; }
950 };
951 template <> struct TagToType<0x0008,0x0101> {
952 static const char* GetVRString() { return "LO"; }
953 typedef VRToType<VR::LO>::Type Type;
954 enum : long long { VRType = VR::LO };
955 enum { VMType = VM::VM1 };
956 static const char* GetVMString() { return "1"; }
957 };
958 template <> struct TagToType<0x0008,0x0102> {
959 static const char* GetVRString() { return "SH"; }
960 typedef VRToType<VR::SH>::Type Type;
961 enum : long long { VRType = VR::SH };
962 enum { VMType = VM::VM1 };
963 static const char* GetVMString() { return "1"; }
964 };
965 template <> struct TagToType<0x0008,0x0103> {
966 static const char* GetVRString() { return "SH"; }
967 typedef VRToType<VR::SH>::Type Type;
968 enum : long long { VRType = VR::SH };
969 enum { VMType = VM::VM1 };
970 static const char* GetVMString() { return "1"; }
971 };
972 template <> struct TagToType<0x0008,0x0104> {
973 static const char* GetVRString() { return "LO"; }
974 typedef VRToType<VR::LO>::Type Type;
975 enum : long long { VRType = VR::LO };
976 enum { VMType = VM::VM1 };
977 static const char* GetVMString() { return "1"; }
978 };
979 template <> struct TagToType<0x0008,0x0105> {
980 static const char* GetVRString() { return "CS"; }
981 typedef VRToType<VR::CS>::Type Type;
982 enum : long long { VRType = VR::CS };
983 enum { VMType = VM::VM1 };
984 static const char* GetVMString() { return "1"; }
985 };
986 template <> struct TagToType<0x0008,0x0106> {
987 static const char* GetVRString() { return "DT"; }
988 typedef VRToType<VR::DT>::Type Type;
989 enum : long long { VRType = VR::DT };
990 enum { VMType = VM::VM1 };
991 static const char* GetVMString() { return "1"; }
992 };
993 template <> struct TagToType<0x0008,0x0107> {
994 static const char* GetVRString() { return "DT"; }
995 typedef VRToType<VR::DT>::Type Type;
996 enum : long long { VRType = VR::DT };
997 enum { VMType = VM::VM1 };
998 static const char* GetVMString() { return "1"; }
999 };
1000 template <> struct TagToType<0x0008,0x0108> {
1001 static const char* GetVRString() { return "LT"; }
1002 typedef VRToType<VR::LT>::Type Type;
1003 enum : long long { VRType = VR::LT };
1004 enum { VMType = VM::VM1 };
1005 static const char* GetVMString() { return "1"; }
1006 };
1007 template <> struct TagToType<0x0008,0x010b> {
1008 static const char* GetVRString() { return "CS"; }
1009 typedef VRToType<VR::CS>::Type Type;
1010 enum : long long { VRType = VR::CS };
1011 enum { VMType = VM::VM1 };
1012 static const char* GetVMString() { return "1"; }
1013 };
1014 template <> struct TagToType<0x0008,0x010c> {
1015 static const char* GetVRString() { return "UI"; }
1016 typedef VRToType<VR::UI>::Type Type;
1017 enum : long long { VRType = VR::UI };
1018 enum { VMType = VM::VM1 };
1019 static const char* GetVMString() { return "1"; }
1020 };
1021 template <> struct TagToType<0x0008,0x010d> {
1022 static const char* GetVRString() { return "UI"; }
1023 typedef VRToType<VR::UI>::Type Type;
1024 enum : long long { VRType = VR::UI };
1025 enum { VMType = VM::VM1 };
1026 static const char* GetVMString() { return "1"; }
1027 };
1028 template <> struct TagToType<0x0008,0x010f> {
1029 static const char* GetVRString() { return "CS"; }
1030 typedef VRToType<VR::CS>::Type Type;
1031 enum : long long { VRType = VR::CS };
1032 enum { VMType = VM::VM1 };
1033 static const char* GetVMString() { return "1"; }
1034 };
1035 template <> struct TagToType<0x0008,0x0110> {
1036 static const char* GetVRString() { return "SQ"; }
1037 typedef VRToType<VR::SQ>::Type Type;
1038 enum : long long { VRType = VR::SQ };
1039 enum { VMType = VM::VM1 };
1040 static const char* GetVMString() { return "1"; }
1041 };
1042 template <> struct TagToType<0x0008,0x0112> {
1043 static const char* GetVRString() { return "LO"; }
1044 typedef VRToType<VR::LO>::Type Type;
1045 enum : long long { VRType = VR::LO };
1046 enum { VMType = VM::VM1 };
1047 static const char* GetVMString() { return "1"; }
1048 };
1049 template <> struct TagToType<0x0008,0x0114> {
1050 static const char* GetVRString() { return "ST"; }
1051 typedef VRToType<VR::ST>::Type Type;
1052 enum : long long { VRType = VR::ST };
1053 enum { VMType = VM::VM1 };
1054 static const char* GetVMString() { return "1"; }
1055 };
1056 template <> struct TagToType<0x0008,0x0115> {
1057 static const char* GetVRString() { return "ST"; }
1058 typedef VRToType<VR::ST>::Type Type;
1059 enum : long long { VRType = VR::ST };
1060 enum { VMType = VM::VM1 };
1061 static const char* GetVMString() { return "1"; }
1062 };
1063 template <> struct TagToType<0x0008,0x0116> {
1064 static const char* GetVRString() { return "ST"; }
1065 typedef VRToType<VR::ST>::Type Type;
1066 enum : long long { VRType = VR::ST };
1067 enum { VMType = VM::VM1 };
1068 static const char* GetVMString() { return "1"; }
1069 };
1070 template <> struct TagToType<0x0008,0x0117> {
1071 static const char* GetVRString() { return "UI"; }
1072 typedef VRToType<VR::UI>::Type Type;
1073 enum : long long { VRType = VR::UI };
1074 enum { VMType = VM::VM1 };
1075 static const char* GetVMString() { return "1"; }
1076 };
1077 template <> struct TagToType<0x0008,0x0118> {
1078 static const char* GetVRString() { return "UI"; }
1079 typedef VRToType<VR::UI>::Type Type;
1080 enum : long long { VRType = VR::UI };
1081 enum { VMType = VM::VM1 };
1082 static const char* GetVMString() { return "1"; }
1083 };
1084 template <> struct TagToType<0x0008,0x0119> {
1085 static const char* GetVRString() { return "UC"; }
1086 typedef VRToType<VR::UC>::Type Type;
1087 enum : long long { VRType = VR::UC };
1088 enum { VMType = VM::VM1 };
1089 static const char* GetVMString() { return "1"; }
1090 };
1091 template <> struct TagToType<0x0008,0x0120> {
1092 static const char* GetVRString() { return "UR"; }
1093 typedef VRToType<VR::UR>::Type Type;
1094 enum : long long { VRType = VR::UR };
1095 enum { VMType = VM::VM1 };
1096 static const char* GetVMString() { return "1"; }
1097 };
1098 template <> struct TagToType<0x0008,0x0121> {
1099 static const char* GetVRString() { return "SQ"; }
1100 typedef VRToType<VR::SQ>::Type Type;
1101 enum : long long { VRType = VR::SQ };
1102 enum { VMType = VM::VM1 };
1103 static const char* GetVMString() { return "1"; }
1104 };
1105 template <> struct TagToType<0x0008,0x0122> {
1106 static const char* GetVRString() { return "LO"; }
1107 typedef VRToType<VR::LO>::Type Type;
1108 enum : long long { VRType = VR::LO };
1109 enum { VMType = VM::VM1 };
1110 static const char* GetVMString() { return "1"; }
1111 };
1112 template <> struct TagToType<0x0008,0x0123> {
1113 static const char* GetVRString() { return "SQ"; }
1114 typedef VRToType<VR::SQ>::Type Type;
1115 enum : long long { VRType = VR::SQ };
1116 enum { VMType = VM::VM1 };
1117 static const char* GetVMString() { return "1"; }
1118 };
1119 template <> struct TagToType<0x0008,0x0124> {
1120 static const char* GetVRString() { return "SQ"; }
1121 typedef VRToType<VR::SQ>::Type Type;
1122 enum : long long { VRType = VR::SQ };
1123 enum { VMType = VM::VM1 };
1124 static const char* GetVMString() { return "1"; }
1125 };
1126 template <> struct TagToType<0x0008,0x0201> {
1127 static const char* GetVRString() { return "SH"; }
1128 typedef VRToType<VR::SH>::Type Type;
1129 enum : long long { VRType = VR::SH };
1130 enum { VMType = VM::VM1 };
1131 static const char* GetVMString() { return "1"; }
1132 };
1133 template <> struct TagToType<0x0008,0x0220> {
1134 static const char* GetVRString() { return "SQ"; }
1135 typedef VRToType<VR::SQ>::Type Type;
1136 enum : long long { VRType = VR::SQ };
1137 enum { VMType = VM::VM1 };
1138 static const char* GetVMString() { return "1"; }
1139 };
1140 template <> struct TagToType<0x0008,0x0221> {
1141 static const char* GetVRString() { return "CS"; }
1142 typedef VRToType<VR::CS>::Type Type;
1143 enum : long long { VRType = VR::CS };
1144 enum { VMType = VM::VM1 };
1145 static const char* GetVMString() { return "1"; }
1146 };
1147 template <> struct TagToType<0x0008,0x0222> {
1148 static const char* GetVRString() { return "LO"; }
1149 typedef VRToType<VR::LO>::Type Type;
1150 enum : long long { VRType = VR::LO };
1151 enum { VMType = VM::VM1 };
1152 static const char* GetVMString() { return "1"; }
1153 };
1154 template <> struct TagToType<0x0008,0x0300> {
1155 static const char* GetVRString() { return "SQ"; }
1156 typedef VRToType<VR::SQ>::Type Type;
1157 enum : long long { VRType = VR::SQ };
1158 enum { VMType = VM::VM1 };
1159 static const char* GetVMString() { return "1"; }
1160 };
1161 template <> struct TagToType<0x0008,0x0301> {
1162 static const char* GetVRString() { return "US"; }
1163 typedef VRToType<VR::US>::Type Type;
1164 enum : long long { VRType = VR::US };
1165 enum { VMType = VM::VM1 };
1166 static const char* GetVMString() { return "1"; }
1167 };
1168 template <> struct TagToType<0x0008,0x0302> {
1169 static const char* GetVRString() { return "LO"; }
1170 typedef VRToType<VR::LO>::Type Type;
1171 enum : long long { VRType = VR::LO };
1172 enum { VMType = VM::VM1 };
1173 static const char* GetVMString() { return "1"; }
1174 };
1175 template <> struct TagToType<0x0008,0x0303> {
1176 static const char* GetVRString() { return "CS"; }
1177 typedef VRToType<VR::CS>::Type Type;
1178 enum : long long { VRType = VR::CS };
1179 enum { VMType = VM::VM1 };
1180 static const char* GetVMString() { return "1"; }
1181 };
1182 template <> struct TagToType<0x0008,0x0304> {
1183 static const char* GetVRString() { return "US"; }
1184 typedef VRToType<VR::US>::Type Type;
1185 enum : long long { VRType = VR::US };
1186 enum { VMType = VM::VM1_n };
1187 static const char* GetVMString() { return "1-n"; }
1188 };
1189 template <> struct TagToType<0x0008,0x0305> {
1190 static const char* GetVRString() { return "SQ"; }
1191 typedef VRToType<VR::SQ>::Type Type;
1192 enum : long long { VRType = VR::SQ };
1193 enum { VMType = VM::VM1 };
1194 static const char* GetVMString() { return "1"; }
1195 };
1196 template <> struct TagToType<0x0008,0x0306> {
1197 static const char* GetVRString() { return "US"; }
1198 typedef VRToType<VR::US>::Type Type;
1199 enum : long long { VRType = VR::US };
1200 enum { VMType = VM::VM1_n };
1201 static const char* GetVMString() { return "1-n"; }
1202 };
1203 template <> struct TagToType<0x0008,0x0307> {
1204 static const char* GetVRString() { return "CS"; }
1205 typedef VRToType<VR::CS>::Type Type;
1206 enum : long long { VRType = VR::CS };
1207 enum { VMType = VM::VM1 };
1208 static const char* GetVMString() { return "1"; }
1209 };
1210 template <> struct TagToType<0x0008,0x0308> {
1211 static const char* GetVRString() { return "US"; }
1212 typedef VRToType<VR::US>::Type Type;
1213 enum : long long { VRType = VR::US };
1214 enum { VMType = VM::VM1 };
1215 static const char* GetVMString() { return "1"; }
1216 };
1217 template <> struct TagToType<0x0008,0x0309> {
1218 static const char* GetVRString() { return "UL"; }
1219 typedef VRToType<VR::UL>::Type Type;
1220 enum : long long { VRType = VR::UL };
1221 enum { VMType = VM::VM1_3 };
1222 static const char* GetVMString() { return "1-3"; }
1223 };
1224 template <> struct TagToType<0x0008,0x030a> {
1225 static const char* GetVRString() { return "CS"; }
1226 typedef VRToType<VR::CS>::Type Type;
1227 enum : long long { VRType = VR::CS };
1228 enum { VMType = VM::VM1 };
1229 static const char* GetVMString() { return "1"; }
1230 };
1231 template <> struct TagToType<0x0008,0x030b> {
1232 static const char* GetVRString() { return "UL"; }
1233 typedef VRToType<VR::UL>::Type Type;
1234 enum : long long { VRType = VR::UL };
1235 enum { VMType = VM::VM1_2 };
1236 static const char* GetVMString() { return "1-2"; }
1237 };
1238 template <> struct TagToType<0x0008,0x030c> {
1239 static const char* GetVRString() { return "UC"; }
1240 typedef VRToType<VR::UC>::Type Type;
1241 enum : long long { VRType = VR::UC };
1242 enum { VMType = VM::VM1 };
1243 static const char* GetVMString() { return "1"; }
1244 };
1245 template <> struct TagToType<0x0008,0x030d> {
1246 static const char* GetVRString() { return "UC"; }
1247 typedef VRToType<VR::UC>::Type Type;
1248 enum : long long { VRType = VR::UC };
1249 enum { VMType = VM::VM1 };
1250 static const char* GetVMString() { return "1"; }
1251 };
1252 template <> struct TagToType<0x0008,0x030e> {
1253 static const char* GetVRString() { return "UT"; }
1254 typedef VRToType<VR::UT>::Type Type;
1255 enum : long long { VRType = VR::UT };
1256 enum { VMType = VM::VM1 };
1257 static const char* GetVMString() { return "1"; }
1258 };
1259 template <> struct TagToType<0x0008,0x030f> {
1260 static const char* GetVRString() { return "UT"; }
1261 typedef VRToType<VR::UT>::Type Type;
1262 enum : long long { VRType = VR::UT };
1263 enum { VMType = VM::VM1 };
1264 static const char* GetVMString() { return "1"; }
1265 };
1266 template <> struct TagToType<0x0008,0x0310> {
1267 static const char* GetVRString() { return "SQ"; }
1268 typedef VRToType<VR::SQ>::Type Type;
1269 enum : long long { VRType = VR::SQ };
1270 enum { VMType = VM::VM1 };
1271 static const char* GetVMString() { return "1"; }
1272 };
1273 template <> struct TagToType<0x0008,0x1000> {
1274 static const char* GetVRString() { return "AE"; }
1275 typedef VRToType<VR::AE>::Type Type;
1276 enum : long long { VRType = VR::AE };
1277 enum { VMType = VM::VM1 };
1278 static const char* GetVMString() { return "1"; }
1279 };
1280 template <> struct TagToType<0x0008,0x1010> {
1281 static const char* GetVRString() { return "SH"; }
1282 typedef VRToType<VR::SH>::Type Type;
1283 enum : long long { VRType = VR::SH };
1284 enum { VMType = VM::VM1 };
1285 static const char* GetVMString() { return "1"; }
1286 };
1287 template <> struct TagToType<0x0008,0x1030> {
1288 static const char* GetVRString() { return "LO"; }
1289 typedef VRToType<VR::LO>::Type Type;
1290 enum : long long { VRType = VR::LO };
1291 enum { VMType = VM::VM1 };
1292 static const char* GetVMString() { return "1"; }
1293 };
1294 template <> struct TagToType<0x0008,0x1032> {
1295 static const char* GetVRString() { return "SQ"; }
1296 typedef VRToType<VR::SQ>::Type Type;
1297 enum : long long { VRType = VR::SQ };
1298 enum { VMType = VM::VM1 };
1299 static const char* GetVMString() { return "1"; }
1300 };
1301 template <> struct TagToType<0x0008,0x103e> {
1302 static const char* GetVRString() { return "LO"; }
1303 typedef VRToType<VR::LO>::Type Type;
1304 enum : long long { VRType = VR::LO };
1305 enum { VMType = VM::VM1 };
1306 static const char* GetVMString() { return "1"; }
1307 };
1308 template <> struct TagToType<0x0008,0x103f> {
1309 static const char* GetVRString() { return "SQ"; }
1310 typedef VRToType<VR::SQ>::Type Type;
1311 enum : long long { VRType = VR::SQ };
1312 enum { VMType = VM::VM1 };
1313 static const char* GetVMString() { return "1"; }
1314 };
1315 template <> struct TagToType<0x0008,0x1040> {
1316 static const char* GetVRString() { return "LO"; }
1317 typedef VRToType<VR::LO>::Type Type;
1318 enum : long long { VRType = VR::LO };
1319 enum { VMType = VM::VM1 };
1320 static const char* GetVMString() { return "1"; }
1321 };
1322 template <> struct TagToType<0x0008,0x1048> {
1323 static const char* GetVRString() { return "PN"; }
1324 typedef VRToType<VR::PN>::Type Type;
1325 enum : long long { VRType = VR::PN };
1326 enum { VMType = VM::VM1_n };
1327 static const char* GetVMString() { return "1-n"; }
1328 };
1329 template <> struct TagToType<0x0008,0x1049> {
1330 static const char* GetVRString() { return "SQ"; }
1331 typedef VRToType<VR::SQ>::Type Type;
1332 enum : long long { VRType = VR::SQ };
1333 enum { VMType = VM::VM1 };
1334 static const char* GetVMString() { return "1"; }
1335 };
1336 template <> struct TagToType<0x0008,0x1050> {
1337 static const char* GetVRString() { return "PN"; }
1338 typedef VRToType<VR::PN>::Type Type;
1339 enum : long long { VRType = VR::PN };
1340 enum { VMType = VM::VM1_n };
1341 static const char* GetVMString() { return "1-n"; }
1342 };
1343 template <> struct TagToType<0x0008,0x1052> {
1344 static const char* GetVRString() { return "SQ"; }
1345 typedef VRToType<VR::SQ>::Type Type;
1346 enum : long long { VRType = VR::SQ };
1347 enum { VMType = VM::VM1 };
1348 static const char* GetVMString() { return "1"; }
1349 };
1350 template <> struct TagToType<0x0008,0x1060> {
1351 static const char* GetVRString() { return "PN"; }
1352 typedef VRToType<VR::PN>::Type Type;
1353 enum : long long { VRType = VR::PN };
1354 enum { VMType = VM::VM1_n };
1355 static const char* GetVMString() { return "1-n"; }
1356 };
1357 template <> struct TagToType<0x0008,0x1062> {
1358 static const char* GetVRString() { return "SQ"; }
1359 typedef VRToType<VR::SQ>::Type Type;
1360 enum : long long { VRType = VR::SQ };
1361 enum { VMType = VM::VM1 };
1362 static const char* GetVMString() { return "1"; }
1363 };
1364 template <> struct TagToType<0x0008,0x1070> {
1365 static const char* GetVRString() { return "PN"; }
1366 typedef VRToType<VR::PN>::Type Type;
1367 enum : long long { VRType = VR::PN };
1368 enum { VMType = VM::VM1_n };
1369 static const char* GetVMString() { return "1-n"; }
1370 };
1371 template <> struct TagToType<0x0008,0x1072> {
1372 static const char* GetVRString() { return "SQ"; }
1373 typedef VRToType<VR::SQ>::Type Type;
1374 enum : long long { VRType = VR::SQ };
1375 enum { VMType = VM::VM1 };
1376 static const char* GetVMString() { return "1"; }
1377 };
1378 template <> struct TagToType<0x0008,0x1080> {
1379 static const char* GetVRString() { return "LO"; }
1380 typedef VRToType<VR::LO>::Type Type;
1381 enum : long long { VRType = VR::LO };
1382 enum { VMType = VM::VM1_n };
1383 static const char* GetVMString() { return "1-n"; }
1384 };
1385 template <> struct TagToType<0x0008,0x1084> {
1386 static const char* GetVRString() { return "SQ"; }
1387 typedef VRToType<VR::SQ>::Type Type;
1388 enum : long long { VRType = VR::SQ };
1389 enum { VMType = VM::VM1 };
1390 static const char* GetVMString() { return "1"; }
1391 };
1392 template <> struct TagToType<0x0008,0x1090> {
1393 static const char* GetVRString() { return "LO"; }
1394 typedef VRToType<VR::LO>::Type Type;
1395 enum : long long { VRType = VR::LO };
1396 enum { VMType = VM::VM1 };
1397 static const char* GetVMString() { return "1"; }
1398 };
1399 template <> struct TagToType<0x0008,0x1100> {
1400 static const char* GetVRString() { return "SQ"; }
1401 typedef VRToType<VR::SQ>::Type Type;
1402 enum : long long { VRType = VR::SQ };
1403 enum { VMType = VM::VM1 };
1404 static const char* GetVMString() { return "1"; }
1405 };
1406 template <> struct TagToType<0x0008,0x1110> {
1407 static const char* GetVRString() { return "SQ"; }
1408 typedef VRToType<VR::SQ>::Type Type;
1409 enum : long long { VRType = VR::SQ };
1410 enum { VMType = VM::VM1 };
1411 static const char* GetVMString() { return "1"; }
1412 };
1413 template <> struct TagToType<0x0008,0x1111> {
1414 static const char* GetVRString() { return "SQ"; }
1415 typedef VRToType<VR::SQ>::Type Type;
1416 enum : long long { VRType = VR::SQ };
1417 enum { VMType = VM::VM1 };
1418 static const char* GetVMString() { return "1"; }
1419 };
1420 template <> struct TagToType<0x0008,0x1115> {
1421 static const char* GetVRString() { return "SQ"; }
1422 typedef VRToType<VR::SQ>::Type Type;
1423 enum : long long { VRType = VR::SQ };
1424 enum { VMType = VM::VM1 };
1425 static const char* GetVMString() { return "1"; }
1426 };
1427 template <> struct TagToType<0x0008,0x1120> {
1428 static const char* GetVRString() { return "SQ"; }
1429 typedef VRToType<VR::SQ>::Type Type;
1430 enum : long long { VRType = VR::SQ };
1431 enum { VMType = VM::VM1 };
1432 static const char* GetVMString() { return "1"; }
1433 };
1434 template <> struct TagToType<0x0008,0x1125> {
1435 static const char* GetVRString() { return "SQ"; }
1436 typedef VRToType<VR::SQ>::Type Type;
1437 enum : long long { VRType = VR::SQ };
1438 enum { VMType = VM::VM1 };
1439 static const char* GetVMString() { return "1"; }
1440 };
1441 template <> struct TagToType<0x0008,0x1130> {
1442 static const char* GetVRString() { return "SQ"; }
1443 typedef VRToType<VR::SQ>::Type Type;
1444 enum : long long { VRType = VR::SQ };
1445 enum { VMType = VM::VM1 };
1446 static const char* GetVMString() { return "1"; }
1447 };
1448 template <> struct TagToType<0x0008,0x1134> {
1449 static const char* GetVRString() { return "SQ"; }
1450 typedef VRToType<VR::SQ>::Type Type;
1451 enum : long long { VRType = VR::SQ };
1452 enum { VMType = VM::VM1 };
1453 static const char* GetVMString() { return "1"; }
1454 };
1455 template <> struct TagToType<0x0008,0x113a> {
1456 static const char* GetVRString() { return "SQ"; }
1457 typedef VRToType<VR::SQ>::Type Type;
1458 enum : long long { VRType = VR::SQ };
1459 enum { VMType = VM::VM1 };
1460 static const char* GetVMString() { return "1"; }
1461 };
1462 template <> struct TagToType<0x0008,0x1140> {
1463 static const char* GetVRString() { return "SQ"; }
1464 typedef VRToType<VR::SQ>::Type Type;
1465 enum : long long { VRType = VR::SQ };
1466 enum { VMType = VM::VM1 };
1467 static const char* GetVMString() { return "1"; }
1468 };
1469 template <> struct TagToType<0x0008,0x1145> {
1470 static const char* GetVRString() { return "SQ"; }
1471 typedef VRToType<VR::SQ>::Type Type;
1472 enum : long long { VRType = VR::SQ };
1473 enum { VMType = VM::VM1 };
1474 static const char* GetVMString() { return "1"; }
1475 };
1476 template <> struct TagToType<0x0008,0x114a> {
1477 static const char* GetVRString() { return "SQ"; }
1478 typedef VRToType<VR::SQ>::Type Type;
1479 enum : long long { VRType = VR::SQ };
1480 enum { VMType = VM::VM1 };
1481 static const char* GetVMString() { return "1"; }
1482 };
1483 template <> struct TagToType<0x0008,0x114b> {
1484 static const char* GetVRString() { return "SQ"; }
1485 typedef VRToType<VR::SQ>::Type Type;
1486 enum : long long { VRType = VR::SQ };
1487 enum { VMType = VM::VM1 };
1488 static const char* GetVMString() { return "1"; }
1489 };
1490 template <> struct TagToType<0x0008,0x1150> {
1491 static const char* GetVRString() { return "UI"; }
1492 typedef VRToType<VR::UI>::Type Type;
1493 enum : long long { VRType = VR::UI };
1494 enum { VMType = VM::VM1 };
1495 static const char* GetVMString() { return "1"; }
1496 };
1497 template <> struct TagToType<0x0008,0x1155> {
1498 static const char* GetVRString() { return "UI"; }
1499 typedef VRToType<VR::UI>::Type Type;
1500 enum : long long { VRType = VR::UI };
1501 enum { VMType = VM::VM1 };
1502 static const char* GetVMString() { return "1"; }
1503 };
1504 template <> struct TagToType<0x0008,0x115a> {
1505 static const char* GetVRString() { return "UI"; }
1506 typedef VRToType<VR::UI>::Type Type;
1507 enum : long long { VRType = VR::UI };
1508 enum { VMType = VM::VM1_n };
1509 static const char* GetVMString() { return "1-n"; }
1510 };
1511 template <> struct TagToType<0x0008,0x1160> {
1512 static const char* GetVRString() { return "IS"; }
1513 typedef VRToType<VR::IS>::Type Type;
1514 enum : long long { VRType = VR::IS };
1515 enum { VMType = VM::VM1_n };
1516 static const char* GetVMString() { return "1-n"; }
1517 };
1518 template <> struct TagToType<0x0008,0x1161> {
1519 static const char* GetVRString() { return "UL"; }
1520 typedef VRToType<VR::UL>::Type Type;
1521 enum : long long { VRType = VR::UL };
1522 enum { VMType = VM::VM1_n };
1523 static const char* GetVMString() { return "1-n"; }
1524 };
1525 template <> struct TagToType<0x0008,0x1162> {
1526 static const char* GetVRString() { return "UL"; }
1527 typedef VRToType<VR::UL>::Type Type;
1528 enum : long long { VRType = VR::UL };
1529 enum { VMType = VM::VM3_3n };
1530 static const char* GetVMString() { return "3-3n"; }
1531 };
1532 template <> struct TagToType<0x0008,0x1163> {
1533 static const char* GetVRString() { return "FD"; }
1534 typedef VRToType<VR::FD>::Type Type;
1535 enum : long long { VRType = VR::FD };
1536 enum { VMType = VM::VM2 };
1537 static const char* GetVMString() { return "2"; }
1538 };
1539 template <> struct TagToType<0x0008,0x1164> {
1540 static const char* GetVRString() { return "SQ"; }
1541 typedef VRToType<VR::SQ>::Type Type;
1542 enum : long long { VRType = VR::SQ };
1543 enum { VMType = VM::VM1 };
1544 static const char* GetVMString() { return "1"; }
1545 };
1546 template <> struct TagToType<0x0008,0x1167> {
1547 static const char* GetVRString() { return "UI"; }
1548 typedef VRToType<VR::UI>::Type Type;
1549 enum : long long { VRType = VR::UI };
1550 enum { VMType = VM::VM1 };
1551 static const char* GetVMString() { return "1"; }
1552 };
1553 template <> struct TagToType<0x0008,0x1190> {
1554 static const char* GetVRString() { return "UR"; }
1555 typedef VRToType<VR::UR>::Type Type;
1556 enum : long long { VRType = VR::UR };
1557 enum { VMType = VM::VM1 };
1558 static const char* GetVMString() { return "1"; }
1559 };
1560 template <> struct TagToType<0x0008,0x1195> {
1561 static const char* GetVRString() { return "UI"; }
1562 typedef VRToType<VR::UI>::Type Type;
1563 enum : long long { VRType = VR::UI };
1564 enum { VMType = VM::VM1 };
1565 static const char* GetVMString() { return "1"; }
1566 };
1567 template <> struct TagToType<0x0008,0x1196> {
1568 static const char* GetVRString() { return "US"; }
1569 typedef VRToType<VR::US>::Type Type;
1570 enum : long long { VRType = VR::US };
1571 enum { VMType = VM::VM1 };
1572 static const char* GetVMString() { return "1"; }
1573 };
1574 template <> struct TagToType<0x0008,0x1197> {
1575 static const char* GetVRString() { return "US"; }
1576 typedef VRToType<VR::US>::Type Type;
1577 enum : long long { VRType = VR::US };
1578 enum { VMType = VM::VM1 };
1579 static const char* GetVMString() { return "1"; }
1580 };
1581 template <> struct TagToType<0x0008,0x1198> {
1582 static const char* GetVRString() { return "SQ"; }
1583 typedef VRToType<VR::SQ>::Type Type;
1584 enum : long long { VRType = VR::SQ };
1585 enum { VMType = VM::VM1 };
1586 static const char* GetVMString() { return "1"; }
1587 };
1588 template <> struct TagToType<0x0008,0x1199> {
1589 static const char* GetVRString() { return "SQ"; }
1590 typedef VRToType<VR::SQ>::Type Type;
1591 enum : long long { VRType = VR::SQ };
1592 enum { VMType = VM::VM1 };
1593 static const char* GetVMString() { return "1"; }
1594 };
1595 template <> struct TagToType<0x0008,0x119a> {
1596 static const char* GetVRString() { return "SQ"; }
1597 typedef VRToType<VR::SQ>::Type Type;
1598 enum : long long { VRType = VR::SQ };
1599 enum { VMType = VM::VM1 };
1600 static const char* GetVMString() { return "1"; }
1601 };
1602 template <> struct TagToType<0x0008,0x1200> {
1603 static const char* GetVRString() { return "SQ"; }
1604 typedef VRToType<VR::SQ>::Type Type;
1605 enum : long long { VRType = VR::SQ };
1606 enum { VMType = VM::VM1 };
1607 static const char* GetVMString() { return "1"; }
1608 };
1609 template <> struct TagToType<0x0008,0x1250> {
1610 static const char* GetVRString() { return "SQ"; }
1611 typedef VRToType<VR::SQ>::Type Type;
1612 enum : long long { VRType = VR::SQ };
1613 enum { VMType = VM::VM1 };
1614 static const char* GetVMString() { return "1"; }
1615 };
1616 template <> struct TagToType<0x0008,0x2110> {
1617 static const char* GetVRString() { return "CS"; }
1618 typedef VRToType<VR::CS>::Type Type;
1619 enum : long long { VRType = VR::CS };
1620 enum { VMType = VM::VM1 };
1621 static const char* GetVMString() { return "1"; }
1622 };
1623 template <> struct TagToType<0x0008,0x2111> {
1624 static const char* GetVRString() { return "ST"; }
1625 typedef VRToType<VR::ST>::Type Type;
1626 enum : long long { VRType = VR::ST };
1627 enum { VMType = VM::VM1 };
1628 static const char* GetVMString() { return "1"; }
1629 };
1630 template <> struct TagToType<0x0008,0x2112> {
1631 static const char* GetVRString() { return "SQ"; }
1632 typedef VRToType<VR::SQ>::Type Type;
1633 enum : long long { VRType = VR::SQ };
1634 enum { VMType = VM::VM1 };
1635 static const char* GetVMString() { return "1"; }
1636 };
1637 template <> struct TagToType<0x0008,0x2120> {
1638 static const char* GetVRString() { return "SH"; }
1639 typedef VRToType<VR::SH>::Type Type;
1640 enum : long long { VRType = VR::SH };
1641 enum { VMType = VM::VM1 };
1642 static const char* GetVMString() { return "1"; }
1643 };
1644 template <> struct TagToType<0x0008,0x2122> {
1645 static const char* GetVRString() { return "IS"; }
1646 typedef VRToType<VR::IS>::Type Type;
1647 enum : long long { VRType = VR::IS };
1648 enum { VMType = VM::VM1 };
1649 static const char* GetVMString() { return "1"; }
1650 };
1651 template <> struct TagToType<0x0008,0x2124> {
1652 static const char* GetVRString() { return "IS"; }
1653 typedef VRToType<VR::IS>::Type Type;
1654 enum : long long { VRType = VR::IS };
1655 enum { VMType = VM::VM1 };
1656 static const char* GetVMString() { return "1"; }
1657 };
1658 template <> struct TagToType<0x0008,0x2127> {
1659 static const char* GetVRString() { return "SH"; }
1660 typedef VRToType<VR::SH>::Type Type;
1661 enum : long long { VRType = VR::SH };
1662 enum { VMType = VM::VM1 };
1663 static const char* GetVMString() { return "1"; }
1664 };
1665 template <> struct TagToType<0x0008,0x2128> {
1666 static const char* GetVRString() { return "IS"; }
1667 typedef VRToType<VR::IS>::Type Type;
1668 enum : long long { VRType = VR::IS };
1669 enum { VMType = VM::VM1 };
1670 static const char* GetVMString() { return "1"; }
1671 };
1672 template <> struct TagToType<0x0008,0x2129> {
1673 static const char* GetVRString() { return "IS"; }
1674 typedef VRToType<VR::IS>::Type Type;
1675 enum : long long { VRType = VR::IS };
1676 enum { VMType = VM::VM1 };
1677 static const char* GetVMString() { return "1"; }
1678 };
1679 template <> struct TagToType<0x0008,0x212a> {
1680 static const char* GetVRString() { return "IS"; }
1681 typedef VRToType<VR::IS>::Type Type;
1682 enum : long long { VRType = VR::IS };
1683 enum { VMType = VM::VM1 };
1684 static const char* GetVMString() { return "1"; }
1685 };
1686 template <> struct TagToType<0x0008,0x2130> {
1687 static const char* GetVRString() { return "DS"; }
1688 typedef VRToType<VR::DS>::Type Type;
1689 enum : long long { VRType = VR::DS };
1690 enum { VMType = VM::VM1_n };
1691 static const char* GetVMString() { return "1-n"; }
1692 };
1693 template <> struct TagToType<0x0008,0x2132> {
1694 static const char* GetVRString() { return "LO"; }
1695 typedef VRToType<VR::LO>::Type Type;
1696 enum : long long { VRType = VR::LO };
1697 enum { VMType = VM::VM1_n };
1698 static const char* GetVMString() { return "1-n"; }
1699 };
1700 template <> struct TagToType<0x0008,0x2133> {
1701 static const char* GetVRString() { return "SQ"; }
1702 typedef VRToType<VR::SQ>::Type Type;
1703 enum : long long { VRType = VR::SQ };
1704 enum { VMType = VM::VM1 };
1705 static const char* GetVMString() { return "1"; }
1706 };
1707 template <> struct TagToType<0x0008,0x2134> {
1708 static const char* GetVRString() { return "FD"; }
1709 typedef VRToType<VR::FD>::Type Type;
1710 enum : long long { VRType = VR::FD };
1711 enum { VMType = VM::VM1 };
1712 static const char* GetVMString() { return "1"; }
1713 };
1714 template <> struct TagToType<0x0008,0x2135> {
1715 static const char* GetVRString() { return "SQ"; }
1716 typedef VRToType<VR::SQ>::Type Type;
1717 enum : long long { VRType = VR::SQ };
1718 enum { VMType = VM::VM1 };
1719 static const char* GetVMString() { return "1"; }
1720 };
1721 template <> struct TagToType<0x0008,0x2142> {
1722 static const char* GetVRString() { return "IS"; }
1723 typedef VRToType<VR::IS>::Type Type;
1724 enum : long long { VRType = VR::IS };
1725 enum { VMType = VM::VM1 };
1726 static const char* GetVMString() { return "1"; }
1727 };
1728 template <> struct TagToType<0x0008,0x2143> {
1729 static const char* GetVRString() { return "IS"; }
1730 typedef VRToType<VR::IS>::Type Type;
1731 enum : long long { VRType = VR::IS };
1732 enum { VMType = VM::VM1 };
1733 static const char* GetVMString() { return "1"; }
1734 };
1735 template <> struct TagToType<0x0008,0x2144> {
1736 static const char* GetVRString() { return "IS"; }
1737 typedef VRToType<VR::IS>::Type Type;
1738 enum : long long { VRType = VR::IS };
1739 enum { VMType = VM::VM1 };
1740 static const char* GetVMString() { return "1"; }
1741 };
1742 template <> struct TagToType<0x0008,0x2200> {
1743 static const char* GetVRString() { return "CS"; }
1744 typedef VRToType<VR::CS>::Type Type;
1745 enum : long long { VRType = VR::CS };
1746 enum { VMType = VM::VM1 };
1747 static const char* GetVMString() { return "1"; }
1748 };
1749 template <> struct TagToType<0x0008,0x2204> {
1750 static const char* GetVRString() { return "CS"; }
1751 typedef VRToType<VR::CS>::Type Type;
1752 enum : long long { VRType = VR::CS };
1753 enum { VMType = VM::VM1 };
1754 static const char* GetVMString() { return "1"; }
1755 };
1756 template <> struct TagToType<0x0008,0x2208> {
1757 static const char* GetVRString() { return "CS"; }
1758 typedef VRToType<VR::CS>::Type Type;
1759 enum : long long { VRType = VR::CS };
1760 enum { VMType = VM::VM1 };
1761 static const char* GetVMString() { return "1"; }
1762 };
1763 template <> struct TagToType<0x0008,0x2218> {
1764 static const char* GetVRString() { return "SQ"; }
1765 typedef VRToType<VR::SQ>::Type Type;
1766 enum : long long { VRType = VR::SQ };
1767 enum { VMType = VM::VM1 };
1768 static const char* GetVMString() { return "1"; }
1769 };
1770 template <> struct TagToType<0x0008,0x2220> {
1771 static const char* GetVRString() { return "SQ"; }
1772 typedef VRToType<VR::SQ>::Type Type;
1773 enum : long long { VRType = VR::SQ };
1774 enum { VMType = VM::VM1 };
1775 static const char* GetVMString() { return "1"; }
1776 };
1777 template <> struct TagToType<0x0008,0x2228> {
1778 static const char* GetVRString() { return "SQ"; }
1779 typedef VRToType<VR::SQ>::Type Type;
1780 enum : long long { VRType = VR::SQ };
1781 enum { VMType = VM::VM1 };
1782 static const char* GetVMString() { return "1"; }
1783 };
1784 template <> struct TagToType<0x0008,0x2229> {
1785 static const char* GetVRString() { return "SQ"; }
1786 typedef VRToType<VR::SQ>::Type Type;
1787 enum : long long { VRType = VR::SQ };
1788 enum { VMType = VM::VM1 };
1789 static const char* GetVMString() { return "1"; }
1790 };
1791 template <> struct TagToType<0x0008,0x2230> {
1792 static const char* GetVRString() { return "SQ"; }
1793 typedef VRToType<VR::SQ>::Type Type;
1794 enum : long long { VRType = VR::SQ };
1795 enum { VMType = VM::VM1 };
1796 static const char* GetVMString() { return "1"; }
1797 };
1798 template <> struct TagToType<0x0008,0x2240> {
1799 static const char* GetVRString() { return "SQ"; }
1800 typedef VRToType<VR::SQ>::Type Type;
1801 enum : long long { VRType = VR::SQ };
1802 enum { VMType = VM::VM1 };
1803 static const char* GetVMString() { return "1"; }
1804 };
1805 template <> struct TagToType<0x0008,0x2242> {
1806 static const char* GetVRString() { return "SQ"; }
1807 typedef VRToType<VR::SQ>::Type Type;
1808 enum : long long { VRType = VR::SQ };
1809 enum { VMType = VM::VM1 };
1810 static const char* GetVMString() { return "1"; }
1811 };
1812 template <> struct TagToType<0x0008,0x2244> {
1813 static const char* GetVRString() { return "SQ"; }
1814 typedef VRToType<VR::SQ>::Type Type;
1815 enum : long long { VRType = VR::SQ };
1816 enum { VMType = VM::VM1 };
1817 static const char* GetVMString() { return "1"; }
1818 };
1819 template <> struct TagToType<0x0008,0x2246> {
1820 static const char* GetVRString() { return "SQ"; }
1821 typedef VRToType<VR::SQ>::Type Type;
1822 enum : long long { VRType = VR::SQ };
1823 enum { VMType = VM::VM1 };
1824 static const char* GetVMString() { return "1"; }
1825 };
1826 template <> struct TagToType<0x0008,0x2251> {
1827 static const char* GetVRString() { return "SQ"; }
1828 typedef VRToType<VR::SQ>::Type Type;
1829 enum : long long { VRType = VR::SQ };
1830 enum { VMType = VM::VM1 };
1831 static const char* GetVMString() { return "1"; }
1832 };
1833 template <> struct TagToType<0x0008,0x2253> {
1834 static const char* GetVRString() { return "SQ"; }
1835 typedef VRToType<VR::SQ>::Type Type;
1836 enum : long long { VRType = VR::SQ };
1837 enum { VMType = VM::VM1 };
1838 static const char* GetVMString() { return "1"; }
1839 };
1840 template <> struct TagToType<0x0008,0x2255> {
1841 static const char* GetVRString() { return "SQ"; }
1842 typedef VRToType<VR::SQ>::Type Type;
1843 enum : long long { VRType = VR::SQ };
1844 enum { VMType = VM::VM1 };
1845 static const char* GetVMString() { return "1"; }
1846 };
1847 template <> struct TagToType<0x0008,0x2256> {
1848 static const char* GetVRString() { return "ST"; }
1849 typedef VRToType<VR::ST>::Type Type;
1850 enum : long long { VRType = VR::ST };
1851 enum { VMType = VM::VM1 };
1852 static const char* GetVMString() { return "1"; }
1853 };
1854 template <> struct TagToType<0x0008,0x2257> {
1855 static const char* GetVRString() { return "SQ"; }
1856 typedef VRToType<VR::SQ>::Type Type;
1857 enum : long long { VRType = VR::SQ };
1858 enum { VMType = VM::VM1 };
1859 static const char* GetVMString() { return "1"; }
1860 };
1861 template <> struct TagToType<0x0008,0x2258> {
1862 static const char* GetVRString() { return "ST"; }
1863 typedef VRToType<VR::ST>::Type Type;
1864 enum : long long { VRType = VR::ST };
1865 enum { VMType = VM::VM1 };
1866 static const char* GetVMString() { return "1"; }
1867 };
1868 template <> struct TagToType<0x0008,0x2259> {
1869 static const char* GetVRString() { return "SQ"; }
1870 typedef VRToType<VR::SQ>::Type Type;
1871 enum : long long { VRType = VR::SQ };
1872 enum { VMType = VM::VM1 };
1873 static const char* GetVMString() { return "1"; }
1874 };
1875 template <> struct TagToType<0x0008,0x225a> {
1876 static const char* GetVRString() { return "SQ"; }
1877 typedef VRToType<VR::SQ>::Type Type;
1878 enum : long long { VRType = VR::SQ };
1879 enum { VMType = VM::VM1 };
1880 static const char* GetVMString() { return "1"; }
1881 };
1882 template <> struct TagToType<0x0008,0x225c> {
1883 static const char* GetVRString() { return "SQ"; }
1884 typedef VRToType<VR::SQ>::Type Type;
1885 enum : long long { VRType = VR::SQ };
1886 enum { VMType = VM::VM1 };
1887 static const char* GetVMString() { return "1"; }
1888 };
1889 template <> struct TagToType<0x0008,0x3001> {
1890 static const char* GetVRString() { return "SQ"; }
1891 typedef VRToType<VR::SQ>::Type Type;
1892 enum : long long { VRType = VR::SQ };
1893 enum { VMType = VM::VM1 };
1894 static const char* GetVMString() { return "1"; }
1895 };
1896 template <> struct TagToType<0x0008,0x3010> {
1897 static const char* GetVRString() { return "UI"; }
1898 typedef VRToType<VR::UI>::Type Type;
1899 enum : long long { VRType = VR::UI };
1900 enum { VMType = VM::VM1_n };
1901 static const char* GetVMString() { return "1-n"; }
1902 };
1903 template <> struct TagToType<0x0008,0x3011> {
1904 static const char* GetVRString() { return "SQ"; }
1905 typedef VRToType<VR::SQ>::Type Type;
1906 enum : long long { VRType = VR::SQ };
1907 enum { VMType = VM::VM1 };
1908 static const char* GetVMString() { return "1"; }
1909 };
1910 template <> struct TagToType<0x0008,0x3012> {
1911 static const char* GetVRString() { return "UI"; }
1912 typedef VRToType<VR::UI>::Type Type;
1913 enum : long long { VRType = VR::UI };
1914 enum { VMType = VM::VM1 };
1915 static const char* GetVMString() { return "1"; }
1916 };
1917 template <> struct TagToType<0x0008,0x4000> {
1918 static const char* GetVRString() { return "LT"; }
1919 typedef VRToType<VR::LT>::Type Type;
1920 enum : long long { VRType = VR::LT };
1921 enum { VMType = VM::VM1 };
1922 static const char* GetVMString() { return "1"; }
1923 };
1924 template <> struct TagToType<0x0008,0x9007> {
1925 static const char* GetVRString() { return "CS"; }
1926 typedef VRToType<VR::CS>::Type Type;
1927 enum : long long { VRType = VR::CS };
1928 enum { VMType = VM::VM4 };
1929 static const char* GetVMString() { return "4"; }
1930 };
1931 template <> struct TagToType<0x0008,0x9092> {
1932 static const char* GetVRString() { return "SQ"; }
1933 typedef VRToType<VR::SQ>::Type Type;
1934 enum : long long { VRType = VR::SQ };
1935 enum { VMType = VM::VM1 };
1936 static const char* GetVMString() { return "1"; }
1937 };
1938 template <> struct TagToType<0x0008,0x9121> {
1939 static const char* GetVRString() { return "SQ"; }
1940 typedef VRToType<VR::SQ>::Type Type;
1941 enum : long long { VRType = VR::SQ };
1942 enum { VMType = VM::VM1 };
1943 static const char* GetVMString() { return "1"; }
1944 };
1945 template <> struct TagToType<0x0008,0x9123> {
1946 static const char* GetVRString() { return "UI"; }
1947 typedef VRToType<VR::UI>::Type Type;
1948 enum : long long { VRType = VR::UI };
1949 enum { VMType = VM::VM1 };
1950 static const char* GetVMString() { return "1"; }
1951 };
1952 template <> struct TagToType<0x0008,0x9124> {
1953 static const char* GetVRString() { return "SQ"; }
1954 typedef VRToType<VR::SQ>::Type Type;
1955 enum : long long { VRType = VR::SQ };
1956 enum { VMType = VM::VM1 };
1957 static const char* GetVMString() { return "1"; }
1958 };
1959 template <> struct TagToType<0x0008,0x9154> {
1960 static const char* GetVRString() { return "SQ"; }
1961 typedef VRToType<VR::SQ>::Type Type;
1962 enum : long long { VRType = VR::SQ };
1963 enum { VMType = VM::VM1 };
1964 static const char* GetVMString() { return "1"; }
1965 };
1966 template <> struct TagToType<0x0008,0x9205> {
1967 static const char* GetVRString() { return "CS"; }
1968 typedef VRToType<VR::CS>::Type Type;
1969 enum : long long { VRType = VR::CS };
1970 enum { VMType = VM::VM1 };
1971 static const char* GetVMString() { return "1"; }
1972 };
1973 template <> struct TagToType<0x0008,0x9206> {
1974 static const char* GetVRString() { return "CS"; }
1975 typedef VRToType<VR::CS>::Type Type;
1976 enum : long long { VRType = VR::CS };
1977 enum { VMType = VM::VM1 };
1978 static const char* GetVMString() { return "1"; }
1979 };
1980 template <> struct TagToType<0x0008,0x9207> {
1981 static const char* GetVRString() { return "CS"; }
1982 typedef VRToType<VR::CS>::Type Type;
1983 enum : long long { VRType = VR::CS };
1984 enum { VMType = VM::VM1 };
1985 static const char* GetVMString() { return "1"; }
1986 };
1987 template <> struct TagToType<0x0008,0x9208> {
1988 static const char* GetVRString() { return "CS"; }
1989 typedef VRToType<VR::CS>::Type Type;
1990 enum : long long { VRType = VR::CS };
1991 enum { VMType = VM::VM1 };
1992 static const char* GetVMString() { return "1"; }
1993 };
1994 template <> struct TagToType<0x0008,0x9209> {
1995 static const char* GetVRString() { return "CS"; }
1996 typedef VRToType<VR::CS>::Type Type;
1997 enum : long long { VRType = VR::CS };
1998 enum { VMType = VM::VM1 };
1999 static const char* GetVMString() { return "1"; }
2000 };
2001 template <> struct TagToType<0x0008,0x9215> {
2002 static const char* GetVRString() { return "SQ"; }
2003 typedef VRToType<VR::SQ>::Type Type;
2004 enum : long long { VRType = VR::SQ };
2005 enum { VMType = VM::VM1 };
2006 static const char* GetVMString() { return "1"; }
2007 };
2008 template <> struct TagToType<0x0008,0x9237> {
2009 static const char* GetVRString() { return "SQ"; }
2010 typedef VRToType<VR::SQ>::Type Type;
2011 enum : long long { VRType = VR::SQ };
2012 enum { VMType = VM::VM1 };
2013 static const char* GetVMString() { return "1"; }
2014 };
2015 template <> struct TagToType<0x0008,0x9410> {
2016 static const char* GetVRString() { return "SQ"; }
2017 typedef VRToType<VR::SQ>::Type Type;
2018 enum : long long { VRType = VR::SQ };
2019 enum { VMType = VM::VM1 };
2020 static const char* GetVMString() { return "1"; }
2021 };
2022 template <> struct TagToType<0x0008,0x9458> {
2023 static const char* GetVRString() { return "SQ"; }
2024 typedef VRToType<VR::SQ>::Type Type;
2025 enum : long long { VRType = VR::SQ };
2026 enum { VMType = VM::VM1 };
2027 static const char* GetVMString() { return "1"; }
2028 };
2029 template <> struct TagToType<0x0008,0x9459> {
2030 static const char* GetVRString() { return "FL"; }
2031 typedef VRToType<VR::FL>::Type Type;
2032 enum : long long { VRType = VR::FL };
2033 enum { VMType = VM::VM1 };
2034 static const char* GetVMString() { return "1"; }
2035 };
2036 template <> struct TagToType<0x0008,0x9460> {
2037 static const char* GetVRString() { return "CS"; }
2038 typedef VRToType<VR::CS>::Type Type;
2039 enum : long long { VRType = VR::CS };
2040 enum { VMType = VM::VM1 };
2041 static const char* GetVMString() { return "1"; }
2042 };
2043 template <> struct TagToType<0x0010,0x0010> {
2044 static const char* GetVRString() { return "PN"; }
2045 typedef VRToType<VR::PN>::Type Type;
2046 enum : long long { VRType = VR::PN };
2047 enum { VMType = VM::VM1 };
2048 static const char* GetVMString() { return "1"; }
2049 };
2050 template <> struct TagToType<0x0010,0x0020> {
2051 static const char* GetVRString() { return "LO"; }
2052 typedef VRToType<VR::LO>::Type Type;
2053 enum : long long { VRType = VR::LO };
2054 enum { VMType = VM::VM1 };
2055 static const char* GetVMString() { return "1"; }
2056 };
2057 template <> struct TagToType<0x0010,0x0021> {
2058 static const char* GetVRString() { return "LO"; }
2059 typedef VRToType<VR::LO>::Type Type;
2060 enum : long long { VRType = VR::LO };
2061 enum { VMType = VM::VM1 };
2062 static const char* GetVMString() { return "1"; }
2063 };
2064 template <> struct TagToType<0x0010,0x0022> {
2065 static const char* GetVRString() { return "CS"; }
2066 typedef VRToType<VR::CS>::Type Type;
2067 enum : long long { VRType = VR::CS };
2068 enum { VMType = VM::VM1 };
2069 static const char* GetVMString() { return "1"; }
2070 };
2071 template <> struct TagToType<0x0010,0x0024> {
2072 static const char* GetVRString() { return "SQ"; }
2073 typedef VRToType<VR::SQ>::Type Type;
2074 enum : long long { VRType = VR::SQ };
2075 enum { VMType = VM::VM1 };
2076 static const char* GetVMString() { return "1"; }
2077 };
2078 template <> struct TagToType<0x0010,0x0026> {
2079 static const char* GetVRString() { return "SQ"; }
2080 typedef VRToType<VR::SQ>::Type Type;
2081 enum : long long { VRType = VR::SQ };
2082 enum { VMType = VM::VM1 };
2083 static const char* GetVMString() { return "1"; }
2084 };
2085 template <> struct TagToType<0x0010,0x0027> {
2086 static const char* GetVRString() { return "SQ"; }
2087 typedef VRToType<VR::SQ>::Type Type;
2088 enum : long long { VRType = VR::SQ };
2089 enum { VMType = VM::VM1 };
2090 static const char* GetVMString() { return "1"; }
2091 };
2092 template <> struct TagToType<0x0010,0x0028> {
2093 static const char* GetVRString() { return "US"; }
2094 typedef VRToType<VR::US>::Type Type;
2095 enum : long long { VRType = VR::US };
2096 enum { VMType = VM::VM3 };
2097 static const char* GetVMString() { return "3"; }
2098 };
2099 template <> struct TagToType<0x0010,0x0030> {
2100 static const char* GetVRString() { return "DA"; }
2101 typedef VRToType<VR::DA>::Type Type;
2102 enum : long long { VRType = VR::DA };
2103 enum { VMType = VM::VM1 };
2104 static const char* GetVMString() { return "1"; }
2105 };
2106 template <> struct TagToType<0x0010,0x0032> {
2107 static const char* GetVRString() { return "TM"; }
2108 typedef VRToType<VR::TM>::Type Type;
2109 enum : long long { VRType = VR::TM };
2110 enum { VMType = VM::VM1 };
2111 static const char* GetVMString() { return "1"; }
2112 };
2113 template <> struct TagToType<0x0010,0x0033> {
2114 static const char* GetVRString() { return "LO"; }
2115 typedef VRToType<VR::LO>::Type Type;
2116 enum : long long { VRType = VR::LO };
2117 enum { VMType = VM::VM1 };
2118 static const char* GetVMString() { return "1"; }
2119 };
2120 template <> struct TagToType<0x0010,0x0034> {
2121 static const char* GetVRString() { return "LO"; }
2122 typedef VRToType<VR::LO>::Type Type;
2123 enum : long long { VRType = VR::LO };
2124 enum { VMType = VM::VM1 };
2125 static const char* GetVMString() { return "1"; }
2126 };
2127 template <> struct TagToType<0x0010,0x0035> {
2128 static const char* GetVRString() { return "CS"; }
2129 typedef VRToType<VR::CS>::Type Type;
2130 enum : long long { VRType = VR::CS };
2131 enum { VMType = VM::VM1 };
2132 static const char* GetVMString() { return "1"; }
2133 };
2134 template <> struct TagToType<0x0010,0x0040> {
2135 static const char* GetVRString() { return "CS"; }
2136 typedef VRToType<VR::CS>::Type Type;
2137 enum : long long { VRType = VR::CS };
2138 enum { VMType = VM::VM1 };
2139 static const char* GetVMString() { return "1"; }
2140 };
2141 template <> struct TagToType<0x0010,0x0050> {
2142 static const char* GetVRString() { return "SQ"; }
2143 typedef VRToType<VR::SQ>::Type Type;
2144 enum : long long { VRType = VR::SQ };
2145 enum { VMType = VM::VM1 };
2146 static const char* GetVMString() { return "1"; }
2147 };
2148 template <> struct TagToType<0x0010,0x0101> {
2149 static const char* GetVRString() { return "SQ"; }
2150 typedef VRToType<VR::SQ>::Type Type;
2151 enum : long long { VRType = VR::SQ };
2152 enum { VMType = VM::VM1 };
2153 static const char* GetVMString() { return "1"; }
2154 };
2155 template <> struct TagToType<0x0010,0x0102> {
2156 static const char* GetVRString() { return "SQ"; }
2157 typedef VRToType<VR::SQ>::Type Type;
2158 enum : long long { VRType = VR::SQ };
2159 enum { VMType = VM::VM1 };
2160 static const char* GetVMString() { return "1"; }
2161 };
2162 template <> struct TagToType<0x0010,0x0200> {
2163 static const char* GetVRString() { return "CS"; }
2164 typedef VRToType<VR::CS>::Type Type;
2165 enum : long long { VRType = VR::CS };
2166 enum { VMType = VM::VM1 };
2167 static const char* GetVMString() { return "1"; }
2168 };
2169 template <> struct TagToType<0x0010,0x0201> {
2170 static const char* GetVRString() { return "SQ"; }
2171 typedef VRToType<VR::SQ>::Type Type;
2172 enum : long long { VRType = VR::SQ };
2173 enum { VMType = VM::VM1 };
2174 static const char* GetVMString() { return "1"; }
2175 };
2176 template <> struct TagToType<0x0010,0x0212> {
2177 static const char* GetVRString() { return "UC"; }
2178 typedef VRToType<VR::UC>::Type Type;
2179 enum : long long { VRType = VR::UC };
2180 enum { VMType = VM::VM1 };
2181 static const char* GetVMString() { return "1"; }
2182 };
2183 template <> struct TagToType<0x0010,0x0213> {
2184 static const char* GetVRString() { return "LO"; }
2185 typedef VRToType<VR::LO>::Type Type;
2186 enum : long long { VRType = VR::LO };
2187 enum { VMType = VM::VM1 };
2188 static const char* GetVMString() { return "1"; }
2189 };
2190 template <> struct TagToType<0x0010,0x0214> {
2191 static const char* GetVRString() { return "LO"; }
2192 typedef VRToType<VR::LO>::Type Type;
2193 enum : long long { VRType = VR::LO };
2194 enum { VMType = VM::VM1 };
2195 static const char* GetVMString() { return "1"; }
2196 };
2197 template <> struct TagToType<0x0010,0x0215> {
2198 static const char* GetVRString() { return "SQ"; }
2199 typedef VRToType<VR::SQ>::Type Type;
2200 enum : long long { VRType = VR::SQ };
2201 enum { VMType = VM::VM1 };
2202 static const char* GetVMString() { return "1"; }
2203 };
2204 template <> struct TagToType<0x0010,0x0216> {
2205 static const char* GetVRString() { return "SQ"; }
2206 typedef VRToType<VR::SQ>::Type Type;
2207 enum : long long { VRType = VR::SQ };
2208 enum { VMType = VM::VM1 };
2209 static const char* GetVMString() { return "1"; }
2210 };
2211 template <> struct TagToType<0x0010,0x0217> {
2212 static const char* GetVRString() { return "LO"; }
2213 typedef VRToType<VR::LO>::Type Type;
2214 enum : long long { VRType = VR::LO };
2215 enum { VMType = VM::VM1 };
2216 static const char* GetVMString() { return "1"; }
2217 };
2218 template <> struct TagToType<0x0010,0x0218> {
2219 static const char* GetVRString() { return "UT"; }
2220 typedef VRToType<VR::UT>::Type Type;
2221 enum : long long { VRType = VR::UT };
2222 enum { VMType = VM::VM1 };
2223 static const char* GetVMString() { return "1"; }
2224 };
2225 template <> struct TagToType<0x0010,0x0219> {
2226 static const char* GetVRString() { return "SQ"; }
2227 typedef VRToType<VR::SQ>::Type Type;
2228 enum : long long { VRType = VR::SQ };
2229 enum { VMType = VM::VM1 };
2230 static const char* GetVMString() { return "1"; }
2231 };
2232 template <> struct TagToType<0x0010,0x1000> {
2233 static const char* GetVRString() { return "LO"; }
2234 typedef VRToType<VR::LO>::Type Type;
2235 enum : long long { VRType = VR::LO };
2236 enum { VMType = VM::VM1_n };
2237 static const char* GetVMString() { return "1-n"; }
2238 };
2239 template <> struct TagToType<0x0010,0x1001> {
2240 static const char* GetVRString() { return "PN"; }
2241 typedef VRToType<VR::PN>::Type Type;
2242 enum : long long { VRType = VR::PN };
2243 enum { VMType = VM::VM1_n };
2244 static const char* GetVMString() { return "1-n"; }
2245 };
2246 template <> struct TagToType<0x0010,0x1002> {
2247 static const char* GetVRString() { return "SQ"; }
2248 typedef VRToType<VR::SQ>::Type Type;
2249 enum : long long { VRType = VR::SQ };
2250 enum { VMType = VM::VM1 };
2251 static const char* GetVMString() { return "1"; }
2252 };
2253 template <> struct TagToType<0x0010,0x1005> {
2254 static const char* GetVRString() { return "PN"; }
2255 typedef VRToType<VR::PN>::Type Type;
2256 enum : long long { VRType = VR::PN };
2257 enum { VMType = VM::VM1 };
2258 static const char* GetVMString() { return "1"; }
2259 };
2260 template <> struct TagToType<0x0010,0x1010> {
2261 static const char* GetVRString() { return "AS"; }
2262 typedef VRToType<VR::AS>::Type Type;
2263 enum : long long { VRType = VR::AS };
2264 enum { VMType = VM::VM1 };
2265 static const char* GetVMString() { return "1"; }
2266 };
2267 template <> struct TagToType<0x0010,0x1020> {
2268 static const char* GetVRString() { return "DS"; }
2269 typedef VRToType<VR::DS>::Type Type;
2270 enum : long long { VRType = VR::DS };
2271 enum { VMType = VM::VM1 };
2272 static const char* GetVMString() { return "1"; }
2273 };
2274 template <> struct TagToType<0x0010,0x1021> {
2275 static const char* GetVRString() { return "SQ"; }
2276 typedef VRToType<VR::SQ>::Type Type;
2277 enum : long long { VRType = VR::SQ };
2278 enum { VMType = VM::VM1 };
2279 static const char* GetVMString() { return "1"; }
2280 };
2281 template <> struct TagToType<0x0010,0x1022> {
2282 static const char* GetVRString() { return "DS"; }
2283 typedef VRToType<VR::DS>::Type Type;
2284 enum : long long { VRType = VR::DS };
2285 enum { VMType = VM::VM1 };
2286 static const char* GetVMString() { return "1"; }
2287 };
2288 template <> struct TagToType<0x0010,0x1023> {
2289 static const char* GetVRString() { return "DS"; }
2290 typedef VRToType<VR::DS>::Type Type;
2291 enum : long long { VRType = VR::DS };
2292 enum { VMType = VM::VM1 };
2293 static const char* GetVMString() { return "1"; }
2294 };
2295 template <> struct TagToType<0x0010,0x1024> {
2296 static const char* GetVRString() { return "DS"; }
2297 typedef VRToType<VR::DS>::Type Type;
2298 enum : long long { VRType = VR::DS };
2299 enum { VMType = VM::VM1 };
2300 static const char* GetVMString() { return "1"; }
2301 };
2302 template <> struct TagToType<0x0010,0x1030> {
2303 static const char* GetVRString() { return "DS"; }
2304 typedef VRToType<VR::DS>::Type Type;
2305 enum : long long { VRType = VR::DS };
2306 enum { VMType = VM::VM1 };
2307 static const char* GetVMString() { return "1"; }
2308 };
2309 template <> struct TagToType<0x0010,0x1040> {
2310 static const char* GetVRString() { return "LO"; }
2311 typedef VRToType<VR::LO>::Type Type;
2312 enum : long long { VRType = VR::LO };
2313 enum { VMType = VM::VM1 };
2314 static const char* GetVMString() { return "1"; }
2315 };
2316 template <> struct TagToType<0x0010,0x1050> {
2317 static const char* GetVRString() { return "LO"; }
2318 typedef VRToType<VR::LO>::Type Type;
2319 enum : long long { VRType = VR::LO };
2320 enum { VMType = VM::VM1_n };
2321 static const char* GetVMString() { return "1-n"; }
2322 };
2323 template <> struct TagToType<0x0010,0x1060> {
2324 static const char* GetVRString() { return "PN"; }
2325 typedef VRToType<VR::PN>::Type Type;
2326 enum : long long { VRType = VR::PN };
2327 enum { VMType = VM::VM1 };
2328 static const char* GetVMString() { return "1"; }
2329 };
2330 template <> struct TagToType<0x0010,0x1080> {
2331 static const char* GetVRString() { return "LO"; }
2332 typedef VRToType<VR::LO>::Type Type;
2333 enum : long long { VRType = VR::LO };
2334 enum { VMType = VM::VM1 };
2335 static const char* GetVMString() { return "1"; }
2336 };
2337 template <> struct TagToType<0x0010,0x1081> {
2338 static const char* GetVRString() { return "LO"; }
2339 typedef VRToType<VR::LO>::Type Type;
2340 enum : long long { VRType = VR::LO };
2341 enum { VMType = VM::VM1 };
2342 static const char* GetVMString() { return "1"; }
2343 };
2344 template <> struct TagToType<0x0010,0x1090> {
2345 static const char* GetVRString() { return "LO"; }
2346 typedef VRToType<VR::LO>::Type Type;
2347 enum : long long { VRType = VR::LO };
2348 enum { VMType = VM::VM1 };
2349 static const char* GetVMString() { return "1"; }
2350 };
2351 template <> struct TagToType<0x0010,0x1100> {
2352 static const char* GetVRString() { return "SQ"; }
2353 typedef VRToType<VR::SQ>::Type Type;
2354 enum : long long { VRType = VR::SQ };
2355 enum { VMType = VM::VM1 };
2356 static const char* GetVMString() { return "1"; }
2357 };
2358 template <> struct TagToType<0x0010,0x2000> {
2359 static const char* GetVRString() { return "LO"; }
2360 typedef VRToType<VR::LO>::Type Type;
2361 enum : long long { VRType = VR::LO };
2362 enum { VMType = VM::VM1_n };
2363 static const char* GetVMString() { return "1-n"; }
2364 };
2365 template <> struct TagToType<0x0010,0x2110> {
2366 static const char* GetVRString() { return "LO"; }
2367 typedef VRToType<VR::LO>::Type Type;
2368 enum : long long { VRType = VR::LO };
2369 enum { VMType = VM::VM1_n };
2370 static const char* GetVMString() { return "1-n"; }
2371 };
2372 template <> struct TagToType<0x0010,0x2150> {
2373 static const char* GetVRString() { return "LO"; }
2374 typedef VRToType<VR::LO>::Type Type;
2375 enum : long long { VRType = VR::LO };
2376 enum { VMType = VM::VM1 };
2377 static const char* GetVMString() { return "1"; }
2378 };
2379 template <> struct TagToType<0x0010,0x2152> {
2380 static const char* GetVRString() { return "LO"; }
2381 typedef VRToType<VR::LO>::Type Type;
2382 enum : long long { VRType = VR::LO };
2383 enum { VMType = VM::VM1 };
2384 static const char* GetVMString() { return "1"; }
2385 };
2386 template <> struct TagToType<0x0010,0x2154> {
2387 static const char* GetVRString() { return "SH"; }
2388 typedef VRToType<VR::SH>::Type Type;
2389 enum : long long { VRType = VR::SH };
2390 enum { VMType = VM::VM1_n };
2391 static const char* GetVMString() { return "1-n"; }
2392 };
2393 template <> struct TagToType<0x0010,0x2155> {
2394 static const char* GetVRString() { return "LT"; }
2395 typedef VRToType<VR::LT>::Type Type;
2396 enum : long long { VRType = VR::LT };
2397 enum { VMType = VM::VM1 };
2398 static const char* GetVMString() { return "1"; }
2399 };
2400 template <> struct TagToType<0x0010,0x2160> {
2401 static const char* GetVRString() { return "SH"; }
2402 typedef VRToType<VR::SH>::Type Type;
2403 enum : long long { VRType = VR::SH };
2404 enum { VMType = VM::VM1 };
2405 static const char* GetVMString() { return "1"; }
2406 };
2407 template <> struct TagToType<0x0010,0x2180> {
2408 static const char* GetVRString() { return "SH"; }
2409 typedef VRToType<VR::SH>::Type Type;
2410 enum : long long { VRType = VR::SH };
2411 enum { VMType = VM::VM1 };
2412 static const char* GetVMString() { return "1"; }
2413 };
2414 template <> struct TagToType<0x0010,0x21a0> {
2415 static const char* GetVRString() { return "CS"; }
2416 typedef VRToType<VR::CS>::Type Type;
2417 enum : long long { VRType = VR::CS };
2418 enum { VMType = VM::VM1 };
2419 static const char* GetVMString() { return "1"; }
2420 };
2421 template <> struct TagToType<0x0010,0x21b0> {
2422 static const char* GetVRString() { return "LT"; }
2423 typedef VRToType<VR::LT>::Type Type;
2424 enum : long long { VRType = VR::LT };
2425 enum { VMType = VM::VM1 };
2426 static const char* GetVMString() { return "1"; }
2427 };
2428 template <> struct TagToType<0x0010,0x21c0> {
2429 static const char* GetVRString() { return "US"; }
2430 typedef VRToType<VR::US>::Type Type;
2431 enum : long long { VRType = VR::US };
2432 enum { VMType = VM::VM1 };
2433 static const char* GetVMString() { return "1"; }
2434 };
2435 template <> struct TagToType<0x0010,0x21d0> {
2436 static const char* GetVRString() { return "DA"; }
2437 typedef VRToType<VR::DA>::Type Type;
2438 enum : long long { VRType = VR::DA };
2439 enum { VMType = VM::VM1 };
2440 static const char* GetVMString() { return "1"; }
2441 };
2442 template <> struct TagToType<0x0010,0x21f0> {
2443 static const char* GetVRString() { return "LO"; }
2444 typedef VRToType<VR::LO>::Type Type;
2445 enum : long long { VRType = VR::LO };
2446 enum { VMType = VM::VM1 };
2447 static const char* GetVMString() { return "1"; }
2448 };
2449 template <> struct TagToType<0x0010,0x2201> {
2450 static const char* GetVRString() { return "LO"; }
2451 typedef VRToType<VR::LO>::Type Type;
2452 enum : long long { VRType = VR::LO };
2453 enum { VMType = VM::VM1 };
2454 static const char* GetVMString() { return "1"; }
2455 };
2456 template <> struct TagToType<0x0010,0x2202> {
2457 static const char* GetVRString() { return "SQ"; }
2458 typedef VRToType<VR::SQ>::Type Type;
2459 enum : long long { VRType = VR::SQ };
2460 enum { VMType = VM::VM1 };
2461 static const char* GetVMString() { return "1"; }
2462 };
2463 template <> struct TagToType<0x0010,0x2203> {
2464 static const char* GetVRString() { return "CS"; }
2465 typedef VRToType<VR::CS>::Type Type;
2466 enum : long long { VRType = VR::CS };
2467 enum { VMType = VM::VM1 };
2468 static const char* GetVMString() { return "1"; }
2469 };
2470 template <> struct TagToType<0x0010,0x2210> {
2471 static const char* GetVRString() { return "CS"; }
2472 typedef VRToType<VR::CS>::Type Type;
2473 enum : long long { VRType = VR::CS };
2474 enum { VMType = VM::VM1 };
2475 static const char* GetVMString() { return "1"; }
2476 };
2477 template <> struct TagToType<0x0010,0x2292> {
2478 static const char* GetVRString() { return "LO"; }
2479 typedef VRToType<VR::LO>::Type Type;
2480 enum : long long { VRType = VR::LO };
2481 enum { VMType = VM::VM1 };
2482 static const char* GetVMString() { return "1"; }
2483 };
2484 template <> struct TagToType<0x0010,0x2293> {
2485 static const char* GetVRString() { return "SQ"; }
2486 typedef VRToType<VR::SQ>::Type Type;
2487 enum : long long { VRType = VR::SQ };
2488 enum { VMType = VM::VM1 };
2489 static const char* GetVMString() { return "1"; }
2490 };
2491 template <> struct TagToType<0x0010,0x2294> {
2492 static const char* GetVRString() { return "SQ"; }
2493 typedef VRToType<VR::SQ>::Type Type;
2494 enum : long long { VRType = VR::SQ };
2495 enum { VMType = VM::VM1 };
2496 static const char* GetVMString() { return "1"; }
2497 };
2498 template <> struct TagToType<0x0010,0x2295> {
2499 static const char* GetVRString() { return "LO"; }
2500 typedef VRToType<VR::LO>::Type Type;
2501 enum : long long { VRType = VR::LO };
2502 enum { VMType = VM::VM1 };
2503 static const char* GetVMString() { return "1"; }
2504 };
2505 template <> struct TagToType<0x0010,0x2296> {
2506 static const char* GetVRString() { return "SQ"; }
2507 typedef VRToType<VR::SQ>::Type Type;
2508 enum : long long { VRType = VR::SQ };
2509 enum { VMType = VM::VM1 };
2510 static const char* GetVMString() { return "1"; }
2511 };
2512 template <> struct TagToType<0x0010,0x2297> {
2513 static const char* GetVRString() { return "PN"; }
2514 typedef VRToType<VR::PN>::Type Type;
2515 enum : long long { VRType = VR::PN };
2516 enum { VMType = VM::VM1 };
2517 static const char* GetVMString() { return "1"; }
2518 };
2519 template <> struct TagToType<0x0010,0x2298> {
2520 static const char* GetVRString() { return "CS"; }
2521 typedef VRToType<VR::CS>::Type Type;
2522 enum : long long { VRType = VR::CS };
2523 enum { VMType = VM::VM1 };
2524 static const char* GetVMString() { return "1"; }
2525 };
2526 template <> struct TagToType<0x0010,0x2299> {
2527 static const char* GetVRString() { return "LO"; }
2528 typedef VRToType<VR::LO>::Type Type;
2529 enum : long long { VRType = VR::LO };
2530 enum { VMType = VM::VM1 };
2531 static const char* GetVMString() { return "1"; }
2532 };
2533 template <> struct TagToType<0x0010,0x4000> {
2534 static const char* GetVRString() { return "LT"; }
2535 typedef VRToType<VR::LT>::Type Type;
2536 enum : long long { VRType = VR::LT };
2537 enum { VMType = VM::VM1 };
2538 static const char* GetVMString() { return "1"; }
2539 };
2540 template <> struct TagToType<0x0010,0x9431> {
2541 static const char* GetVRString() { return "FL"; }
2542 typedef VRToType<VR::FL>::Type Type;
2543 enum : long long { VRType = VR::FL };
2544 enum { VMType = VM::VM1 };
2545 static const char* GetVMString() { return "1"; }
2546 };
2547 template <> struct TagToType<0x0012,0x0010> {
2548 static const char* GetVRString() { return "LO"; }
2549 typedef VRToType<VR::LO>::Type Type;
2550 enum : long long { VRType = VR::LO };
2551 enum { VMType = VM::VM1 };
2552 static const char* GetVMString() { return "1"; }
2553 };
2554 template <> struct TagToType<0x0012,0x0020> {
2555 static const char* GetVRString() { return "LO"; }
2556 typedef VRToType<VR::LO>::Type Type;
2557 enum : long long { VRType = VR::LO };
2558 enum { VMType = VM::VM1 };
2559 static const char* GetVMString() { return "1"; }
2560 };
2561 template <> struct TagToType<0x0012,0x0021> {
2562 static const char* GetVRString() { return "LO"; }
2563 typedef VRToType<VR::LO>::Type Type;
2564 enum : long long { VRType = VR::LO };
2565 enum { VMType = VM::VM1 };
2566 static const char* GetVMString() { return "1"; }
2567 };
2568 template <> struct TagToType<0x0012,0x0030> {
2569 static const char* GetVRString() { return "LO"; }
2570 typedef VRToType<VR::LO>::Type Type;
2571 enum : long long { VRType = VR::LO };
2572 enum { VMType = VM::VM1 };
2573 static const char* GetVMString() { return "1"; }
2574 };
2575 template <> struct TagToType<0x0012,0x0031> {
2576 static const char* GetVRString() { return "LO"; }
2577 typedef VRToType<VR::LO>::Type Type;
2578 enum : long long { VRType = VR::LO };
2579 enum { VMType = VM::VM1 };
2580 static const char* GetVMString() { return "1"; }
2581 };
2582 template <> struct TagToType<0x0012,0x0040> {
2583 static const char* GetVRString() { return "LO"; }
2584 typedef VRToType<VR::LO>::Type Type;
2585 enum : long long { VRType = VR::LO };
2586 enum { VMType = VM::VM1 };
2587 static const char* GetVMString() { return "1"; }
2588 };
2589 template <> struct TagToType<0x0012,0x0042> {
2590 static const char* GetVRString() { return "LO"; }
2591 typedef VRToType<VR::LO>::Type Type;
2592 enum : long long { VRType = VR::LO };
2593 enum { VMType = VM::VM1 };
2594 static const char* GetVMString() { return "1"; }
2595 };
2596 template <> struct TagToType<0x0012,0x0050> {
2597 static const char* GetVRString() { return "LO"; }
2598 typedef VRToType<VR::LO>::Type Type;
2599 enum : long long { VRType = VR::LO };
2600 enum { VMType = VM::VM1 };
2601 static const char* GetVMString() { return "1"; }
2602 };
2603 template <> struct TagToType<0x0012,0x0051> {
2604 static const char* GetVRString() { return "ST"; }
2605 typedef VRToType<VR::ST>::Type Type;
2606 enum : long long { VRType = VR::ST };
2607 enum { VMType = VM::VM1 };
2608 static const char* GetVMString() { return "1"; }
2609 };
2610 template <> struct TagToType<0x0012,0x0060> {
2611 static const char* GetVRString() { return "LO"; }
2612 typedef VRToType<VR::LO>::Type Type;
2613 enum : long long { VRType = VR::LO };
2614 enum { VMType = VM::VM1 };
2615 static const char* GetVMString() { return "1"; }
2616 };
2617 template <> struct TagToType<0x0012,0x0062> {
2618 static const char* GetVRString() { return "CS"; }
2619 typedef VRToType<VR::CS>::Type Type;
2620 enum : long long { VRType = VR::CS };
2621 enum { VMType = VM::VM1 };
2622 static const char* GetVMString() { return "1"; }
2623 };
2624 template <> struct TagToType<0x0012,0x0063> {
2625 static const char* GetVRString() { return "LO"; }
2626 typedef VRToType<VR::LO>::Type Type;
2627 enum : long long { VRType = VR::LO };
2628 enum { VMType = VM::VM1_n };
2629 static const char* GetVMString() { return "1-n"; }
2630 };
2631 template <> struct TagToType<0x0012,0x0064> {
2632 static const char* GetVRString() { return "SQ"; }
2633 typedef VRToType<VR::SQ>::Type Type;
2634 enum : long long { VRType = VR::SQ };
2635 enum { VMType = VM::VM1 };
2636 static const char* GetVMString() { return "1"; }
2637 };
2638 template <> struct TagToType<0x0012,0x0071> {
2639 static const char* GetVRString() { return "LO"; }
2640 typedef VRToType<VR::LO>::Type Type;
2641 enum : long long { VRType = VR::LO };
2642 enum { VMType = VM::VM1 };
2643 static const char* GetVMString() { return "1"; }
2644 };
2645 template <> struct TagToType<0x0012,0x0072> {
2646 static const char* GetVRString() { return "LO"; }
2647 typedef VRToType<VR::LO>::Type Type;
2648 enum : long long { VRType = VR::LO };
2649 enum { VMType = VM::VM1 };
2650 static const char* GetVMString() { return "1"; }
2651 };
2652 template <> struct TagToType<0x0012,0x0081> {
2653 static const char* GetVRString() { return "LO"; }
2654 typedef VRToType<VR::LO>::Type Type;
2655 enum : long long { VRType = VR::LO };
2656 enum { VMType = VM::VM1 };
2657 static const char* GetVMString() { return "1"; }
2658 };
2659 template <> struct TagToType<0x0012,0x0082> {
2660 static const char* GetVRString() { return "LO"; }
2661 typedef VRToType<VR::LO>::Type Type;
2662 enum : long long { VRType = VR::LO };
2663 enum { VMType = VM::VM1 };
2664 static const char* GetVMString() { return "1"; }
2665 };
2666 template <> struct TagToType<0x0012,0x0083> {
2667 static const char* GetVRString() { return "SQ"; }
2668 typedef VRToType<VR::SQ>::Type Type;
2669 enum : long long { VRType = VR::SQ };
2670 enum { VMType = VM::VM1 };
2671 static const char* GetVMString() { return "1"; }
2672 };
2673 template <> struct TagToType<0x0012,0x0084> {
2674 static const char* GetVRString() { return "CS"; }
2675 typedef VRToType<VR::CS>::Type Type;
2676 enum : long long { VRType = VR::CS };
2677 enum { VMType = VM::VM1 };
2678 static const char* GetVMString() { return "1"; }
2679 };
2680 template <> struct TagToType<0x0012,0x0085> {
2681 static const char* GetVRString() { return "CS"; }
2682 typedef VRToType<VR::CS>::Type Type;
2683 enum : long long { VRType = VR::CS };
2684 enum { VMType = VM::VM1 };
2685 static const char* GetVMString() { return "1"; }
2686 };
2687 template <> struct TagToType<0x0012,0x0086> {
2688 static const char* GetVRString() { return "DA"; }
2689 typedef VRToType<VR::DA>::Type Type;
2690 enum : long long { VRType = VR::DA };
2691 enum { VMType = VM::VM1 };
2692 static const char* GetVMString() { return "1"; }
2693 };
2694 template <> struct TagToType<0x0012,0x0087> {
2695 static const char* GetVRString() { return "DA"; }
2696 typedef VRToType<VR::DA>::Type Type;
2697 enum : long long { VRType = VR::DA };
2698 enum { VMType = VM::VM1 };
2699 static const char* GetVMString() { return "1"; }
2700 };
2701 template <> struct TagToType<0x0014,0x0023> {
2702 static const char* GetVRString() { return "ST"; }
2703 typedef VRToType<VR::ST>::Type Type;
2704 enum : long long { VRType = VR::ST };
2705 enum { VMType = VM::VM1 };
2706 static const char* GetVMString() { return "1"; }
2707 };
2708 template <> struct TagToType<0x0014,0x0024> {
2709 static const char* GetVRString() { return "ST"; }
2710 typedef VRToType<VR::ST>::Type Type;
2711 enum : long long { VRType = VR::ST };
2712 enum { VMType = VM::VM1 };
2713 static const char* GetVMString() { return "1"; }
2714 };
2715 template <> struct TagToType<0x0014,0x0025> {
2716 static const char* GetVRString() { return "ST"; }
2717 typedef VRToType<VR::ST>::Type Type;
2718 enum : long long { VRType = VR::ST };
2719 enum { VMType = VM::VM1 };
2720 static const char* GetVMString() { return "1"; }
2721 };
2722 template <> struct TagToType<0x0014,0x0028> {
2723 static const char* GetVRString() { return "ST"; }
2724 typedef VRToType<VR::ST>::Type Type;
2725 enum : long long { VRType = VR::ST };
2726 enum { VMType = VM::VM1 };
2727 static const char* GetVMString() { return "1"; }
2728 };
2729 template <> struct TagToType<0x0014,0x0030> {
2730 static const char* GetVRString() { return "DS"; }
2731 typedef VRToType<VR::DS>::Type Type;
2732 enum : long long { VRType = VR::DS };
2733 enum { VMType = VM::VM1_n };
2734 static const char* GetVMString() { return "1-n"; }
2735 };
2736 template <> struct TagToType<0x0014,0x0032> {
2737 static const char* GetVRString() { return "DS"; }
2738 typedef VRToType<VR::DS>::Type Type;
2739 enum : long long { VRType = VR::DS };
2740 enum { VMType = VM::VM1_n };
2741 static const char* GetVMString() { return "1-n"; }
2742 };
2743 template <> struct TagToType<0x0014,0x0034> {
2744 static const char* GetVRString() { return "DS"; }
2745 typedef VRToType<VR::DS>::Type Type;
2746 enum : long long { VRType = VR::DS };
2747 enum { VMType = VM::VM1_n };
2748 static const char* GetVMString() { return "1-n"; }
2749 };
2750 template <> struct TagToType<0x0014,0x0042> {
2751 static const char* GetVRString() { return "ST"; }
2752 typedef VRToType<VR::ST>::Type Type;
2753 enum : long long { VRType = VR::ST };
2754 enum { VMType = VM::VM1 };
2755 static const char* GetVMString() { return "1"; }
2756 };
2757 template <> struct TagToType<0x0014,0x0044> {
2758 static const char* GetVRString() { return "ST"; }
2759 typedef VRToType<VR::ST>::Type Type;
2760 enum : long long { VRType = VR::ST };
2761 enum { VMType = VM::VM1 };
2762 static const char* GetVMString() { return "1"; }
2763 };
2764 template <> struct TagToType<0x0014,0x0045> {
2765 static const char* GetVRString() { return "ST"; }
2766 typedef VRToType<VR::ST>::Type Type;
2767 enum : long long { VRType = VR::ST };
2768 enum { VMType = VM::VM1 };
2769 static const char* GetVMString() { return "1"; }
2770 };
2771 template <> struct TagToType<0x0014,0x0046> {
2772 static const char* GetVRString() { return "LT"; }
2773 typedef VRToType<VR::LT>::Type Type;
2774 enum : long long { VRType = VR::LT };
2775 enum { VMType = VM::VM1 };
2776 static const char* GetVMString() { return "1"; }
2777 };
2778 template <> struct TagToType<0x0014,0x0050> {
2779 static const char* GetVRString() { return "CS"; }
2780 typedef VRToType<VR::CS>::Type Type;
2781 enum : long long { VRType = VR::CS };
2782 enum { VMType = VM::VM1 };
2783 static const char* GetVMString() { return "1"; }
2784 };
2785 template <> struct TagToType<0x0014,0x0052> {
2786 static const char* GetVRString() { return "CS"; }
2787 typedef VRToType<VR::CS>::Type Type;
2788 enum : long long { VRType = VR::CS };
2789 enum { VMType = VM::VM1 };
2790 static const char* GetVMString() { return "1"; }
2791 };
2792 template <> struct TagToType<0x0014,0x0054> {
2793 static const char* GetVRString() { return "DS"; }
2794 typedef VRToType<VR::DS>::Type Type;
2795 enum : long long { VRType = VR::DS };
2796 enum { VMType = VM::VM1 };
2797 static const char* GetVMString() { return "1"; }
2798 };
2799 template <> struct TagToType<0x0014,0x0056> {
2800 static const char* GetVRString() { return "DS"; }
2801 typedef VRToType<VR::DS>::Type Type;
2802 enum : long long { VRType = VR::DS };
2803 enum { VMType = VM::VM1 };
2804 static const char* GetVMString() { return "1"; }
2805 };
2806 template <> struct TagToType<0x0014,0x0100> {
2807 static const char* GetVRString() { return "LO"; }
2808 typedef VRToType<VR::LO>::Type Type;
2809 enum : long long { VRType = VR::LO };
2810 enum { VMType = VM::VM1_n };
2811 static const char* GetVMString() { return "1-n"; }
2812 };
2813 template <> struct TagToType<0x0014,0x0101> {
2814 static const char* GetVRString() { return "CS"; }
2815 typedef VRToType<VR::CS>::Type Type;
2816 enum : long long { VRType = VR::CS };
2817 enum { VMType = VM::VM1 };
2818 static const char* GetVMString() { return "1"; }
2819 };
2820 template <> struct TagToType<0x0014,0x0102> {
2821 static const char* GetVRString() { return "DA"; }
2822 typedef VRToType<VR::DA>::Type Type;
2823 enum : long long { VRType = VR::DA };
2824 enum { VMType = VM::VM1 };
2825 static const char* GetVMString() { return "1"; }
2826 };
2827 template <> struct TagToType<0x0014,0x0103> {
2828 static const char* GetVRString() { return "TM"; }
2829 typedef VRToType<VR::TM>::Type Type;
2830 enum : long long { VRType = VR::TM };
2831 enum { VMType = VM::VM1 };
2832 static const char* GetVMString() { return "1"; }
2833 };
2834 template <> struct TagToType<0x0014,0x0104> {
2835 static const char* GetVRString() { return "PN"; }
2836 typedef VRToType<VR::PN>::Type Type;
2837 enum : long long { VRType = VR::PN };
2838 enum { VMType = VM::VM1 };
2839 static const char* GetVMString() { return "1"; }
2840 };
2841 template <> struct TagToType<0x0014,0x0105> {
2842 static const char* GetVRString() { return "ST"; }
2843 typedef VRToType<VR::ST>::Type Type;
2844 enum : long long { VRType = VR::ST };
2845 enum { VMType = VM::VM1 };
2846 static const char* GetVMString() { return "1"; }
2847 };
2848 template <> struct TagToType<0x0014,0x0106> {
2849 static const char* GetVRString() { return "SQ"; }
2850 typedef VRToType<VR::SQ>::Type Type;
2851 enum : long long { VRType = VR::SQ };
2852 enum { VMType = VM::VM1 };
2853 static const char* GetVMString() { return "1"; }
2854 };
2855 template <> struct TagToType<0x0014,0x0107> {
2856 static const char* GetVRString() { return "CS"; }
2857 typedef VRToType<VR::CS>::Type Type;
2858 enum : long long { VRType = VR::CS };
2859 enum { VMType = VM::VM1_n };
2860 static const char* GetVMString() { return "1-n"; }
2861 };
2862 template <> struct TagToType<0x0014,0x0108> {
2863 static const char* GetVRString() { return "CS"; }
2864 typedef VRToType<VR::CS>::Type Type;
2865 enum : long long { VRType = VR::CS };
2866 enum { VMType = VM::VM1_n };
2867 static const char* GetVMString() { return "1-n"; }
2868 };
2869 template <> struct TagToType<0x0014,0x1010> {
2870 static const char* GetVRString() { return "ST"; }
2871 typedef VRToType<VR::ST>::Type Type;
2872 enum : long long { VRType = VR::ST };
2873 enum { VMType = VM::VM1 };
2874 static const char* GetVMString() { return "1"; }
2875 };
2876 template <> struct TagToType<0x0014,0x1020> {
2877 static const char* GetVRString() { return "DA"; }
2878 typedef VRToType<VR::DA>::Type Type;
2879 enum : long long { VRType = VR::DA };
2880 enum { VMType = VM::VM1 };
2881 static const char* GetVMString() { return "1"; }
2882 };
2883 template <> struct TagToType<0x0014,0x1040> {
2884 static const char* GetVRString() { return "ST"; }
2885 typedef VRToType<VR::ST>::Type Type;
2886 enum : long long { VRType = VR::ST };
2887 enum { VMType = VM::VM1 };
2888 static const char* GetVMString() { return "1"; }
2889 };
2890 template <> struct TagToType<0x0014,0x2002> {
2891 static const char* GetVRString() { return "SQ"; }
2892 typedef VRToType<VR::SQ>::Type Type;
2893 enum : long long { VRType = VR::SQ };
2894 enum { VMType = VM::VM1 };
2895 static const char* GetVMString() { return "1"; }
2896 };
2897 template <> struct TagToType<0x0014,0x2004> {
2898 static const char* GetVRString() { return "IS"; }
2899 typedef VRToType<VR::IS>::Type Type;
2900 enum : long long { VRType = VR::IS };
2901 enum { VMType = VM::VM1 };
2902 static const char* GetVMString() { return "1"; }
2903 };
2904 template <> struct TagToType<0x0014,0x2006> {
2905 static const char* GetVRString() { return "PN"; }
2906 typedef VRToType<VR::PN>::Type Type;
2907 enum : long long { VRType = VR::PN };
2908 enum { VMType = VM::VM1 };
2909 static const char* GetVMString() { return "1"; }
2910 };
2911 template <> struct TagToType<0x0014,0x2008> {
2912 static const char* GetVRString() { return "IS"; }
2913 typedef VRToType<VR::IS>::Type Type;
2914 enum : long long { VRType = VR::IS };
2915 enum { VMType = VM::VM1 };
2916 static const char* GetVMString() { return "1"; }
2917 };
2918 template <> struct TagToType<0x0014,0x2012> {
2919 static const char* GetVRString() { return "SQ"; }
2920 typedef VRToType<VR::SQ>::Type Type;
2921 enum : long long { VRType = VR::SQ };
2922 enum { VMType = VM::VM1 };
2923 static const char* GetVMString() { return "1"; }
2924 };
2925 template <> struct TagToType<0x0014,0x2014> {
2926 static const char* GetVRString() { return "IS"; }
2927 typedef VRToType<VR::IS>::Type Type;
2928 enum : long long { VRType = VR::IS };
2929 enum { VMType = VM::VM1 };
2930 static const char* GetVMString() { return "1"; }
2931 };
2932 template <> struct TagToType<0x0014,0x2016> {
2933 static const char* GetVRString() { return "SH"; }
2934 typedef VRToType<VR::SH>::Type Type;
2935 enum : long long { VRType = VR::SH };
2936 enum { VMType = VM::VM1 };
2937 static const char* GetVMString() { return "1"; }
2938 };
2939 template <> struct TagToType<0x0014,0x2018> {
2940 static const char* GetVRString() { return "ST"; }
2941 typedef VRToType<VR::ST>::Type Type;
2942 enum : long long { VRType = VR::ST };
2943 enum { VMType = VM::VM1 };
2944 static const char* GetVMString() { return "1"; }
2945 };
2946 template <> struct TagToType<0x0014,0x201a> {
2947 static const char* GetVRString() { return "CS"; }
2948 typedef VRToType<VR::CS>::Type Type;
2949 enum : long long { VRType = VR::CS };
2950 enum { VMType = VM::VM1_n };
2951 static const char* GetVMString() { return "1-n"; }
2952 };
2953 template <> struct TagToType<0x0014,0x201c> {
2954 static const char* GetVRString() { return "CS"; }
2955 typedef VRToType<VR::CS>::Type Type;
2956 enum : long long { VRType = VR::CS };
2957 enum { VMType = VM::VM1 };
2958 static const char* GetVMString() { return "1"; }
2959 };
2960 template <> struct TagToType<0x0014,0x201e> {
2961 static const char* GetVRString() { return "SQ"; }
2962 typedef VRToType<VR::SQ>::Type Type;
2963 enum : long long { VRType = VR::SQ };
2964 enum { VMType = VM::VM1 };
2965 static const char* GetVMString() { return "1"; }
2966 };
2967 template <> struct TagToType<0x0014,0x2030> {
2968 static const char* GetVRString() { return "SQ"; }
2969 typedef VRToType<VR::SQ>::Type Type;
2970 enum : long long { VRType = VR::SQ };
2971 enum { VMType = VM::VM1 };
2972 static const char* GetVMString() { return "1"; }
2973 };
2974 template <> struct TagToType<0x0014,0x2032> {
2975 static const char* GetVRString() { return "SH"; }
2976 typedef VRToType<VR::SH>::Type Type;
2977 enum : long long { VRType = VR::SH };
2978 enum { VMType = VM::VM1 };
2979 static const char* GetVMString() { return "1"; }
2980 };
2981 template <> struct TagToType<0x0014,0x2202> {
2982 static const char* GetVRString() { return "IS"; }
2983 typedef VRToType<VR::IS>::Type Type;
2984 enum : long long { VRType = VR::IS };
2985 enum { VMType = VM::VM1 };
2986 static const char* GetVMString() { return "1"; }
2987 };
2988 template <> struct TagToType<0x0014,0x2204> {
2989 static const char* GetVRString() { return "SQ"; }
2990 typedef VRToType<VR::SQ>::Type Type;
2991 enum : long long { VRType = VR::SQ };
2992 enum { VMType = VM::VM1 };
2993 static const char* GetVMString() { return "1"; }
2994 };
2995 template <> struct TagToType<0x0014,0x2206> {
2996 static const char* GetVRString() { return "ST"; }
2997 typedef VRToType<VR::ST>::Type Type;
2998 enum : long long { VRType = VR::ST };
2999 enum { VMType = VM::VM1 };
3000 static const char* GetVMString() { return "1"; }
3001 };
3002 template <> struct TagToType<0x0014,0x2208> {
3003 static const char* GetVRString() { return "CS"; }
3004 typedef VRToType<VR::CS>::Type Type;
3005 enum : long long { VRType = VR::CS };
3006 enum { VMType = VM::VM1 };
3007 static const char* GetVMString() { return "1"; }
3008 };
3009 template <> struct TagToType<0x0014,0x220a> {
3010 static const char* GetVRString() { return "IS"; }
3011 typedef VRToType<VR::IS>::Type Type;
3012 enum : long long { VRType = VR::IS };
3013 enum { VMType = VM::VM1 };
3014 static const char* GetVMString() { return "1"; }
3015 };
3016 template <> struct TagToType<0x0014,0x220c> {
3017 static const char* GetVRString() { return "CS"; }
3018 typedef VRToType<VR::CS>::Type Type;
3019 enum : long long { VRType = VR::CS };
3020 enum { VMType = VM::VM1 };
3021 static const char* GetVMString() { return "1"; }
3022 };
3023 template <> struct TagToType<0x0014,0x220e> {
3024 static const char* GetVRString() { return "CS"; }
3025 typedef VRToType<VR::CS>::Type Type;
3026 enum : long long { VRType = VR::CS };
3027 enum { VMType = VM::VM1 };
3028 static const char* GetVMString() { return "1"; }
3029 };
3030 template <> struct TagToType<0x0014,0x2210> {
3031 static const char* GetVRString() { return "OB"; }
3032 typedef VRToType<VR::OB>::Type Type;
3033 enum : long long { VRType = VR::OB };
3034 enum { VMType = VM::VM1 };
3035 static const char* GetVMString() { return "1"; }
3036 };
3037 template <> struct TagToType<0x0014,0x2220> {
3038 static const char* GetVRString() { return "SQ"; }
3039 typedef VRToType<VR::SQ>::Type Type;
3040 enum : long long { VRType = VR::SQ };
3041 enum { VMType = VM::VM1 };
3042 static const char* GetVMString() { return "1"; }
3043 };
3044 template <> struct TagToType<0x0014,0x2222> {
3045 static const char* GetVRString() { return "ST"; }
3046 typedef VRToType<VR::ST>::Type Type;
3047 enum : long long { VRType = VR::ST };
3048 enum { VMType = VM::VM1 };
3049 static const char* GetVMString() { return "1"; }
3050 };
3051 template <> struct TagToType<0x0014,0x2224> {
3052 static const char* GetVRString() { return "IS"; }
3053 typedef VRToType<VR::IS>::Type Type;
3054 enum : long long { VRType = VR::IS };
3055 enum { VMType = VM::VM1 };
3056 static const char* GetVMString() { return "1"; }
3057 };
3058 template <> struct TagToType<0x0014,0x2226> {
3059 static const char* GetVRString() { return "IS"; }
3060 typedef VRToType<VR::IS>::Type Type;
3061 enum : long long { VRType = VR::IS };
3062 enum { VMType = VM::VM1_n };
3063 static const char* GetVMString() { return "1-n"; }
3064 };
3065 template <> struct TagToType<0x0014,0x2228> {
3066 static const char* GetVRString() { return "CS"; }
3067 typedef VRToType<VR::CS>::Type Type;
3068 enum : long long { VRType = VR::CS };
3069 enum { VMType = VM::VM1 };
3070 static const char* GetVMString() { return "1"; }
3071 };
3072 template <> struct TagToType<0x0014,0x222a> {
3073 static const char* GetVRString() { return "DS"; }
3074 typedef VRToType<VR::DS>::Type Type;
3075 enum : long long { VRType = VR::DS };
3076 enum { VMType = VM::VM1_n };
3077 static const char* GetVMString() { return "1-n"; }
3078 };
3079 template <> struct TagToType<0x0014,0x222c> {
3080 static const char* GetVRString() { return "DS"; }
3081 typedef VRToType<VR::DS>::Type Type;
3082 enum : long long { VRType = VR::DS };
3083 enum { VMType = VM::VM1_n };
3084 static const char* GetVMString() { return "1-n"; }
3085 };
3086 template <> struct TagToType<0x0014,0x3011> {
3087 static const char* GetVRString() { return "DS"; }
3088 typedef VRToType<VR::DS>::Type Type;
3089 enum : long long { VRType = VR::DS };
3090 enum { VMType = VM::VM1 };
3091 static const char* GetVMString() { return "1"; }
3092 };
3093 template <> struct TagToType<0x0014,0x3012> {
3094 static const char* GetVRString() { return "DS"; }
3095 typedef VRToType<VR::DS>::Type Type;
3096 enum : long long { VRType = VR::DS };
3097 enum { VMType = VM::VM1 };
3098 static const char* GetVMString() { return "1"; }
3099 };
3100 template <> struct TagToType<0x0014,0x3020> {
3101 static const char* GetVRString() { return "SQ"; }
3102 typedef VRToType<VR::SQ>::Type Type;
3103 enum : long long { VRType = VR::SQ };
3104 enum { VMType = VM::VM1 };
3105 static const char* GetVMString() { return "1"; }
3106 };
3107 template <> struct TagToType<0x0014,0x3022> {
3108 static const char* GetVRString() { return "ST"; }
3109 typedef VRToType<VR::ST>::Type Type;
3110 enum : long long { VRType = VR::ST };
3111 enum { VMType = VM::VM1 };
3112 static const char* GetVMString() { return "1"; }
3113 };
3114 template <> struct TagToType<0x0014,0x3024> {
3115 static const char* GetVRString() { return "DS"; }
3116 typedef VRToType<VR::DS>::Type Type;
3117 enum : long long { VRType = VR::DS };
3118 enum { VMType = VM::VM1 };
3119 static const char* GetVMString() { return "1"; }
3120 };
3121 template <> struct TagToType<0x0014,0x3026> {
3122 static const char* GetVRString() { return "DS"; }
3123 typedef VRToType<VR::DS>::Type Type;
3124 enum : long long { VRType = VR::DS };
3125 enum { VMType = VM::VM1 };
3126 static const char* GetVMString() { return "1"; }
3127 };
3128 template <> struct TagToType<0x0014,0x3028> {
3129 static const char* GetVRString() { return "DS"; }
3130 typedef VRToType<VR::DS>::Type Type;
3131 enum : long long { VRType = VR::DS };
3132 enum { VMType = VM::VM1 };
3133 static const char* GetVMString() { return "1"; }
3134 };
3135 template <> struct TagToType<0x0014,0x3040> {
3136 static const char* GetVRString() { return "SQ"; }
3137 typedef VRToType<VR::SQ>::Type Type;
3138 enum : long long { VRType = VR::SQ };
3139 enum { VMType = VM::VM1 };
3140 static const char* GetVMString() { return "1"; }
3141 };
3142 template <> struct TagToType<0x0014,0x3060> {
3143 static const char* GetVRString() { return "SQ"; }
3144 typedef VRToType<VR::SQ>::Type Type;
3145 enum : long long { VRType = VR::SQ };
3146 enum { VMType = VM::VM1 };
3147 static const char* GetVMString() { return "1"; }
3148 };
3149 template <> struct TagToType<0x0014,0x3071> {
3150 static const char* GetVRString() { return "DS"; }
3151 typedef VRToType<VR::DS>::Type Type;
3152 enum : long long { VRType = VR::DS };
3153 enum { VMType = VM::VM1 };
3154 static const char* GetVMString() { return "1"; }
3155 };
3156 template <> struct TagToType<0x0014,0x3072> {
3157 static const char* GetVRString() { return "DS"; }
3158 typedef VRToType<VR::DS>::Type Type;
3159 enum : long long { VRType = VR::DS };
3160 enum { VMType = VM::VM1 };
3161 static const char* GetVMString() { return "1"; }
3162 };
3163 template <> struct TagToType<0x0014,0x3073> {
3164 static const char* GetVRString() { return "DS"; }
3165 typedef VRToType<VR::DS>::Type Type;
3166 enum : long long { VRType = VR::DS };
3167 enum { VMType = VM::VM1 };
3168 static const char* GetVMString() { return "1"; }
3169 };
3170 template <> struct TagToType<0x0014,0x3074> {
3171 static const char* GetVRString() { return "LO"; }
3172 typedef VRToType<VR::LO>::Type Type;
3173 enum : long long { VRType = VR::LO };
3174 enum { VMType = VM::VM1 };
3175 static const char* GetVMString() { return "1"; }
3176 };
3177 template <> struct TagToType<0x0014,0x3075> {
3178 static const char* GetVRString() { return "DS"; }
3179 typedef VRToType<VR::DS>::Type Type;
3180 enum : long long { VRType = VR::DS };
3181 enum { VMType = VM::VM1 };
3182 static const char* GetVMString() { return "1"; }
3183 };
3184 template <> struct TagToType<0x0014,0x3076> {
3185 static const char* GetVRString() { return "DA"; }
3186 typedef VRToType<VR::DA>::Type Type;
3187 enum : long long { VRType = VR::DA };
3188 enum { VMType = VM::VM1 };
3189 static const char* GetVMString() { return "1"; }
3190 };
3191 template <> struct TagToType<0x0014,0x3077> {
3192 static const char* GetVRString() { return "TM"; }
3193 typedef VRToType<VR::TM>::Type Type;
3194 enum : long long { VRType = VR::TM };
3195 enum { VMType = VM::VM1 };
3196 static const char* GetVMString() { return "1"; }
3197 };
3198 template <> struct TagToType<0x0014,0x3080> {
3199 static const char* GetVRString() { return "OB"; }
3200 typedef VRToType<VR::OB>::Type Type;
3201 enum : long long { VRType = VR::OB };
3202 enum { VMType = VM::VM1 };
3203 static const char* GetVMString() { return "1"; }
3204 };
3205 template <> struct TagToType<0x0014,0x3099> {
3206 static const char* GetVRString() { return "LT"; }
3207 typedef VRToType<VR::LT>::Type Type;
3208 enum : long long { VRType = VR::LT };
3209 enum { VMType = VM::VM1 };
3210 static const char* GetVMString() { return "1"; }
3211 };
3212 template <> struct TagToType<0x0014,0x4002> {
3213 static const char* GetVRString() { return "SQ"; }
3214 typedef VRToType<VR::SQ>::Type Type;
3215 enum : long long { VRType = VR::SQ };
3216 enum { VMType = VM::VM1 };
3217 static const char* GetVMString() { return "1"; }
3218 };
3219 template <> struct TagToType<0x0014,0x4004> {
3220 static const char* GetVRString() { return "CS"; }
3221 typedef VRToType<VR::CS>::Type Type;
3222 enum : long long { VRType = VR::CS };
3223 enum { VMType = VM::VM1 };
3224 static const char* GetVMString() { return "1"; }
3225 };
3226 template <> struct TagToType<0x0014,0x4006> {
3227 static const char* GetVRString() { return "LT"; }
3228 typedef VRToType<VR::LT>::Type Type;
3229 enum : long long { VRType = VR::LT };
3230 enum { VMType = VM::VM1 };
3231 static const char* GetVMString() { return "1"; }
3232 };
3233 template <> struct TagToType<0x0014,0x4008> {
3234 static const char* GetVRString() { return "SQ"; }
3235 typedef VRToType<VR::SQ>::Type Type;
3236 enum : long long { VRType = VR::SQ };
3237 enum { VMType = VM::VM1 };
3238 static const char* GetVMString() { return "1"; }
3239 };
3240 template <> struct TagToType<0x0014,0x400a> {
3241 static const char* GetVRString() { return "CS"; }
3242 typedef VRToType<VR::CS>::Type Type;
3243 enum : long long { VRType = VR::CS };
3244 enum { VMType = VM::VM1 };
3245 static const char* GetVMString() { return "1"; }
3246 };
3247 template <> struct TagToType<0x0014,0x400c> {
3248 static const char* GetVRString() { return "LT"; }
3249 typedef VRToType<VR::LT>::Type Type;
3250 enum : long long { VRType = VR::LT };
3251 enum { VMType = VM::VM1 };
3252 static const char* GetVMString() { return "1"; }
3253 };
3254 template <> struct TagToType<0x0014,0x400e> {
3255 static const char* GetVRString() { return "SQ"; }
3256 typedef VRToType<VR::SQ>::Type Type;
3257 enum : long long { VRType = VR::SQ };
3258 enum { VMType = VM::VM1 };
3259 static const char* GetVMString() { return "1"; }
3260 };
3261 template <> struct TagToType<0x0014,0x400f> {
3262 static const char* GetVRString() { return "LT"; }
3263 typedef VRToType<VR::LT>::Type Type;
3264 enum : long long { VRType = VR::LT };
3265 enum { VMType = VM::VM1 };
3266 static const char* GetVMString() { return "1"; }
3267 };
3268 template <> struct TagToType<0x0014,0x4010> {
3269 static const char* GetVRString() { return "SQ"; }
3270 typedef VRToType<VR::SQ>::Type Type;
3271 enum : long long { VRType = VR::SQ };
3272 enum { VMType = VM::VM1 };
3273 static const char* GetVMString() { return "1"; }
3274 };
3275 template <> struct TagToType<0x0014,0x4011> {
3276 static const char* GetVRString() { return "SQ"; }
3277 typedef VRToType<VR::SQ>::Type Type;
3278 enum : long long { VRType = VR::SQ };
3279 enum { VMType = VM::VM1 };
3280 static const char* GetVMString() { return "1"; }
3281 };
3282 template <> struct TagToType<0x0014,0x4012> {
3283 static const char* GetVRString() { return "US"; }
3284 typedef VRToType<VR::US>::Type Type;
3285 enum : long long { VRType = VR::US };
3286 enum { VMType = VM::VM1 };
3287 static const char* GetVMString() { return "1"; }
3288 };
3289 template <> struct TagToType<0x0014,0x4013> {
3290 static const char* GetVRString() { return "CS"; }
3291 typedef VRToType<VR::CS>::Type Type;
3292 enum : long long { VRType = VR::CS };
3293 enum { VMType = VM::VM1 };
3294 static const char* GetVMString() { return "1"; }
3295 };
3296 template <> struct TagToType<0x0014,0x4014> {
3297 static const char* GetVRString() { return "DS"; }
3298 typedef VRToType<VR::DS>::Type Type;
3299 enum : long long { VRType = VR::DS };
3300 enum { VMType = VM::VM1 };
3301 static const char* GetVMString() { return "1"; }
3302 };
3303 template <> struct TagToType<0x0014,0x4015> {
3304 static const char* GetVRString() { return "DS"; }
3305 typedef VRToType<VR::DS>::Type Type;
3306 enum : long long { VRType = VR::DS };
3307 enum { VMType = VM::VM1 };
3308 static const char* GetVMString() { return "1"; }
3309 };
3310 template <> struct TagToType<0x0014,0x4016> {
3311 static const char* GetVRString() { return "DS"; }
3312 typedef VRToType<VR::DS>::Type Type;
3313 enum : long long { VRType = VR::DS };
3314 enum { VMType = VM::VM1 };
3315 static const char* GetVMString() { return "1"; }
3316 };
3317 template <> struct TagToType<0x0014,0x4017> {
3318 static const char* GetVRString() { return "DS"; }
3319 typedef VRToType<VR::DS>::Type Type;
3320 enum : long long { VRType = VR::DS };
3321 enum { VMType = VM::VM1 };
3322 static const char* GetVMString() { return "1"; }
3323 };
3324 template <> struct TagToType<0x0014,0x4018> {
3325 static const char* GetVRString() { return "DS"; }
3326 typedef VRToType<VR::DS>::Type Type;
3327 enum : long long { VRType = VR::DS };
3328 enum { VMType = VM::VM1 };
3329 static const char* GetVMString() { return "1"; }
3330 };
3331 template <> struct TagToType<0x0014,0x4019> {
3332 static const char* GetVRString() { return "DS"; }
3333 typedef VRToType<VR::DS>::Type Type;
3334 enum : long long { VRType = VR::DS };
3335 enum { VMType = VM::VM1 };
3336 static const char* GetVMString() { return "1"; }
3337 };
3338 template <> struct TagToType<0x0014,0x401a> {
3339 static const char* GetVRString() { return "DS"; }
3340 typedef VRToType<VR::DS>::Type Type;
3341 enum : long long { VRType = VR::DS };
3342 enum { VMType = VM::VM1 };
3343 static const char* GetVMString() { return "1"; }
3344 };
3345 template <> struct TagToType<0x0014,0x401b> {
3346 static const char* GetVRString() { return "DS"; }
3347 typedef VRToType<VR::DS>::Type Type;
3348 enum : long long { VRType = VR::DS };
3349 enum { VMType = VM::VM1 };
3350 static const char* GetVMString() { return "1"; }
3351 };
3352 template <> struct TagToType<0x0014,0x401c> {
3353 static const char* GetVRString() { return "DS"; }
3354 typedef VRToType<VR::DS>::Type Type;
3355 enum : long long { VRType = VR::DS };
3356 enum { VMType = VM::VM1 };
3357 static const char* GetVMString() { return "1"; }
3358 };
3359 template <> struct TagToType<0x0014,0x401d> {
3360 static const char* GetVRString() { return "DS"; }
3361 typedef VRToType<VR::DS>::Type Type;
3362 enum : long long { VRType = VR::DS };
3363 enum { VMType = VM::VM1 };
3364 static const char* GetVMString() { return "1"; }
3365 };
3366 template <> struct TagToType<0x0014,0x4020> {
3367 static const char* GetVRString() { return "SQ"; }
3368 typedef VRToType<VR::SQ>::Type Type;
3369 enum : long long { VRType = VR::SQ };
3370 enum { VMType = VM::VM1 };
3371 static const char* GetVMString() { return "1"; }
3372 };
3373 template <> struct TagToType<0x0014,0x4022> {
3374 static const char* GetVRString() { return "DS"; }
3375 typedef VRToType<VR::DS>::Type Type;
3376 enum : long long { VRType = VR::DS };
3377 enum { VMType = VM::VM1 };
3378 static const char* GetVMString() { return "1"; }
3379 };
3380 template <> struct TagToType<0x0014,0x4024> {
3381 static const char* GetVRString() { return "DS"; }
3382 typedef VRToType<VR::DS>::Type Type;
3383 enum : long long { VRType = VR::DS };
3384 enum { VMType = VM::VM1 };
3385 static const char* GetVMString() { return "1"; }
3386 };
3387 template <> struct TagToType<0x0014,0x4026> {
3388 static const char* GetVRString() { return "CS"; }
3389 typedef VRToType<VR::CS>::Type Type;
3390 enum : long long { VRType = VR::CS };
3391 enum { VMType = VM::VM1 };
3392 static const char* GetVMString() { return "1"; }
3393 };
3394 template <> struct TagToType<0x0014,0x4028> {
3395 static const char* GetVRString() { return "DS"; }
3396 typedef VRToType<VR::DS>::Type Type;
3397 enum : long long { VRType = VR::DS };
3398 enum { VMType = VM::VM1 };
3399 static const char* GetVMString() { return "1"; }
3400 };
3401 template <> struct TagToType<0x0014,0x4030> {
3402 static const char* GetVRString() { return "SQ"; }
3403 typedef VRToType<VR::SQ>::Type Type;
3404 enum : long long { VRType = VR::SQ };
3405 enum { VMType = VM::VM1 };
3406 static const char* GetVMString() { return "1"; }
3407 };
3408 template <> struct TagToType<0x0014,0x4031> {
3409 static const char* GetVRString() { return "DS"; }
3410 typedef VRToType<VR::DS>::Type Type;
3411 enum : long long { VRType = VR::DS };
3412 enum { VMType = VM::VM1 };
3413 static const char* GetVMString() { return "1"; }
3414 };
3415 template <> struct TagToType<0x0014,0x4032> {
3416 static const char* GetVRString() { return "CS"; }
3417 typedef VRToType<VR::CS>::Type Type;
3418 enum : long long { VRType = VR::CS };
3419 enum { VMType = VM::VM1 };
3420 static const char* GetVMString() { return "1"; }
3421 };
3422 template <> struct TagToType<0x0014,0x4033> {
3423 static const char* GetVRString() { return "IS"; }
3424 typedef VRToType<VR::IS>::Type Type;
3425 enum : long long { VRType = VR::IS };
3426 enum { VMType = VM::VM1 };
3427 static const char* GetVMString() { return "1"; }
3428 };
3429 template <> struct TagToType<0x0014,0x4034> {
3430 static const char* GetVRString() { return "DS"; }
3431 typedef VRToType<VR::DS>::Type Type;
3432 enum : long long { VRType = VR::DS };
3433 enum { VMType = VM::VM1 };
3434 static const char* GetVMString() { return "1"; }
3435 };
3436 template <> struct TagToType<0x0014,0x4035> {
3437 static const char* GetVRString() { return "SQ"; }
3438 typedef VRToType<VR::SQ>::Type Type;
3439 enum : long long { VRType = VR::SQ };
3440 enum { VMType = VM::VM1 };
3441 static const char* GetVMString() { return "1"; }
3442 };
3443 template <> struct TagToType<0x0014,0x4036> {
3444 static const char* GetVRString() { return "CS"; }
3445 typedef VRToType<VR::CS>::Type Type;
3446 enum : long long { VRType = VR::CS };
3447 enum { VMType = VM::VM1 };
3448 static const char* GetVMString() { return "1"; }
3449 };
3450 template <> struct TagToType<0x0014,0x4038> {
3451 static const char* GetVRString() { return "DS"; }
3452 typedef VRToType<VR::DS>::Type Type;
3453 enum : long long { VRType = VR::DS };
3454 enum { VMType = VM::VM1_n };
3455 static const char* GetVMString() { return "1-n"; }
3456 };
3457 template <> struct TagToType<0x0014,0x403a> {
3458 static const char* GetVRString() { return "DS"; }
3459 typedef VRToType<VR::DS>::Type Type;
3460 enum : long long { VRType = VR::DS };
3461 enum { VMType = VM::VM1_n };
3462 static const char* GetVMString() { return "1-n"; }
3463 };
3464 template <> struct TagToType<0x0014,0x403c> {
3465 static const char* GetVRString() { return "DS"; }
3466 typedef VRToType<VR::DS>::Type Type;
3467 enum : long long { VRType = VR::DS };
3468 enum { VMType = VM::VM1_n };
3469 static const char* GetVMString() { return "1-n"; }
3470 };
3471 template <> struct TagToType<0x0014,0x4040> {
3472 static const char* GetVRString() { return "SQ"; }
3473 typedef VRToType<VR::SQ>::Type Type;
3474 enum : long long { VRType = VR::SQ };
3475 enum { VMType = VM::VM1 };
3476 static const char* GetVMString() { return "1"; }
3477 };
3478 template <> struct TagToType<0x0014,0x4050> {
3479 static const char* GetVRString() { return "SQ"; }
3480 typedef VRToType<VR::SQ>::Type Type;
3481 enum : long long { VRType = VR::SQ };
3482 enum { VMType = VM::VM1 };
3483 static const char* GetVMString() { return "1"; }
3484 };
3485 template <> struct TagToType<0x0014,0x4051> {
3486 static const char* GetVRString() { return "SQ"; }
3487 typedef VRToType<VR::SQ>::Type Type;
3488 enum : long long { VRType = VR::SQ };
3489 enum { VMType = VM::VM1 };
3490 static const char* GetVMString() { return "1"; }
3491 };
3492 template <> struct TagToType<0x0014,0x4052> {
3493 static const char* GetVRString() { return "DS"; }
3494 typedef VRToType<VR::DS>::Type Type;
3495 enum : long long { VRType = VR::DS };
3496 enum { VMType = VM::VM1 };
3497 static const char* GetVMString() { return "1"; }
3498 };
3499 template <> struct TagToType<0x0014,0x4054> {
3500 static const char* GetVRString() { return "ST"; }
3501 typedef VRToType<VR::ST>::Type Type;
3502 enum : long long { VRType = VR::ST };
3503 enum { VMType = VM::VM1 };
3504 static const char* GetVMString() { return "1"; }
3505 };
3506 template <> struct TagToType<0x0014,0x4056> {
3507 static const char* GetVRString() { return "ST"; }
3508 typedef VRToType<VR::ST>::Type Type;
3509 enum : long long { VRType = VR::ST };
3510 enum { VMType = VM::VM1 };
3511 static const char* GetVMString() { return "1"; }
3512 };
3513 template <> struct TagToType<0x0014,0x4057> {
3514 static const char* GetVRString() { return "DS"; }
3515 typedef VRToType<VR::DS>::Type Type;
3516 enum : long long { VRType = VR::DS };
3517 enum { VMType = VM::VM1 };
3518 static const char* GetVMString() { return "1"; }
3519 };
3520 template <> struct TagToType<0x0014,0x4058> {
3521 static const char* GetVRString() { return "DS"; }
3522 typedef VRToType<VR::DS>::Type Type;
3523 enum : long long { VRType = VR::DS };
3524 enum { VMType = VM::VM1 };
3525 static const char* GetVMString() { return "1"; }
3526 };
3527 template <> struct TagToType<0x0014,0x4059> {
3528 static const char* GetVRString() { return "DS"; }
3529 typedef VRToType<VR::DS>::Type Type;
3530 enum : long long { VRType = VR::DS };
3531 enum { VMType = VM::VM1 };
3532 static const char* GetVMString() { return "1"; }
3533 };
3534 template <> struct TagToType<0x0014,0x405a> {
3535 static const char* GetVRString() { return "DS"; }
3536 typedef VRToType<VR::DS>::Type Type;
3537 enum : long long { VRType = VR::DS };
3538 enum { VMType = VM::VM1 };
3539 static const char* GetVMString() { return "1"; }
3540 };
3541 template <> struct TagToType<0x0014,0x405c> {
3542 static const char* GetVRString() { return "ST"; }
3543 typedef VRToType<VR::ST>::Type Type;
3544 enum : long long { VRType = VR::ST };
3545 enum { VMType = VM::VM1 };
3546 static const char* GetVMString() { return "1"; }
3547 };
3548 template <> struct TagToType<0x0014,0x4060> {
3549 static const char* GetVRString() { return "SQ"; }
3550 typedef VRToType<VR::SQ>::Type Type;
3551 enum : long long { VRType = VR::SQ };
3552 enum { VMType = VM::VM1 };
3553 static const char* GetVMString() { return "1"; }
3554 };
3555 template <> struct TagToType<0x0014,0x4062> {
3556 static const char* GetVRString() { return "DS"; }
3557 typedef VRToType<VR::DS>::Type Type;
3558 enum : long long { VRType = VR::DS };
3559 enum { VMType = VM::VM1 };
3560 static const char* GetVMString() { return "1"; }
3561 };
3562 template <> struct TagToType<0x0014,0x4064> {
3563 static const char* GetVRString() { return "DS"; }
3564 typedef VRToType<VR::DS>::Type Type;
3565 enum : long long { VRType = VR::DS };
3566 enum { VMType = VM::VM1 };
3567 static const char* GetVMString() { return "1"; }
3568 };
3569 template <> struct TagToType<0x0014,0x4070> {
3570 static const char* GetVRString() { return "SQ"; }
3571 typedef VRToType<VR::SQ>::Type Type;
3572 enum : long long { VRType = VR::SQ };
3573 enum { VMType = VM::VM1 };
3574 static const char* GetVMString() { return "1"; }
3575 };
3576 template <> struct TagToType<0x0014,0x4072> {
3577 static const char* GetVRString() { return "ST"; }
3578 typedef VRToType<VR::ST>::Type Type;
3579 enum : long long { VRType = VR::ST };
3580 enum { VMType = VM::VM1 };
3581 static const char* GetVMString() { return "1"; }
3582 };
3583 template <> struct TagToType<0x0014,0x4074> {
3584 static const char* GetVRString() { return "SH"; }
3585 typedef VRToType<VR::SH>::Type Type;
3586 enum : long long { VRType = VR::SH };
3587 enum { VMType = VM::VM1 };
3588 static const char* GetVMString() { return "1"; }
3589 };
3590 template <> struct TagToType<0x0014,0x4076> {
3591 static const char* GetVRString() { return "DA"; }
3592 typedef VRToType<VR::DA>::Type Type;
3593 enum : long long { VRType = VR::DA };
3594 enum { VMType = VM::VM1 };
3595 static const char* GetVMString() { return "1"; }
3596 };
3597 template <> struct TagToType<0x0014,0x4078> {
3598 static const char* GetVRString() { return "DA"; }
3599 typedef VRToType<VR::DA>::Type Type;
3600 enum : long long { VRType = VR::DA };
3601 enum { VMType = VM::VM1 };
3602 static const char* GetVMString() { return "1"; }
3603 };
3604 template <> struct TagToType<0x0014,0x407a> {
3605 static const char* GetVRString() { return "DA"; }
3606 typedef VRToType<VR::DA>::Type Type;
3607 enum : long long { VRType = VR::DA };
3608 enum { VMType = VM::VM1 };
3609 static const char* GetVMString() { return "1"; }
3610 };
3611 template <> struct TagToType<0x0014,0x407c> {
3612 static const char* GetVRString() { return "TM"; }
3613 typedef VRToType<VR::TM>::Type Type;
3614 enum : long long { VRType = VR::TM };
3615 enum { VMType = VM::VM1_n };
3616 static const char* GetVMString() { return "1-n"; }
3617 };
3618 template <> struct TagToType<0x0014,0x407e> {
3619 static const char* GetVRString() { return "DA"; }
3620 typedef VRToType<VR::DA>::Type Type;
3621 enum : long long { VRType = VR::DA };
3622 enum { VMType = VM::VM1_n };
3623 static const char* GetVMString() { return "1-n"; }
3624 };
3625 template <> struct TagToType<0x0014,0x4080> {
3626 static const char* GetVRString() { return "SQ"; }
3627 typedef VRToType<VR::SQ>::Type Type;
3628 enum : long long { VRType = VR::SQ };
3629 enum { VMType = VM::VM1 };
3630 static const char* GetVMString() { return "1"; }
3631 };
3632 template <> struct TagToType<0x0014,0x4081> {
3633 static const char* GetVRString() { return "CS"; }
3634 typedef VRToType<VR::CS>::Type Type;
3635 enum : long long { VRType = VR::CS };
3636 enum { VMType = VM::VM1 };
3637 static const char* GetVMString() { return "1"; }
3638 };
3639 template <> struct TagToType<0x0014,0x4082> {
3640 static const char* GetVRString() { return "LT"; }
3641 typedef VRToType<VR::LT>::Type Type;
3642 enum : long long { VRType = VR::LT };
3643 enum { VMType = VM::VM1 };
3644 static const char* GetVMString() { return "1"; }
3645 };
3646 template <> struct TagToType<0x0014,0x4083> {
3647 static const char* GetVRString() { return "SQ"; }
3648 typedef VRToType<VR::SQ>::Type Type;
3649 enum : long long { VRType = VR::SQ };
3650 enum { VMType = VM::VM1 };
3651 static const char* GetVMString() { return "1"; }
3652 };
3653 template <> struct TagToType<0x0014,0x4084> {
3654 static const char* GetVRString() { return "DS"; }
3655 typedef VRToType<VR::DS>::Type Type;
3656 enum : long long { VRType = VR::DS };
3657 enum { VMType = VM::VM1 };
3658 static const char* GetVMString() { return "1"; }
3659 };
3660 template <> struct TagToType<0x0014,0x4085> {
3661 static const char* GetVRString() { return "DS"; }
3662 typedef VRToType<VR::DS>::Type Type;
3663 enum : long long { VRType = VR::DS };
3664 enum { VMType = VM::VM1 };
3665 static const char* GetVMString() { return "1"; }
3666 };
3667 template <> struct TagToType<0x0014,0x4086> {
3668 static const char* GetVRString() { return "SQ"; }
3669 typedef VRToType<VR::SQ>::Type Type;
3670 enum : long long { VRType = VR::SQ };
3671 enum { VMType = VM::VM1 };
3672 static const char* GetVMString() { return "1"; }
3673 };
3674 template <> struct TagToType<0x0014,0x4087> {
3675 static const char* GetVRString() { return "SQ"; }
3676 typedef VRToType<VR::SQ>::Type Type;
3677 enum : long long { VRType = VR::SQ };
3678 enum { VMType = VM::VM1 };
3679 static const char* GetVMString() { return "1"; }
3680 };
3681 template <> struct TagToType<0x0014,0x4088> {
3682 static const char* GetVRString() { return "DS"; }
3683 typedef VRToType<VR::DS>::Type Type;
3684 enum : long long { VRType = VR::DS };
3685 enum { VMType = VM::VM1 };
3686 static const char* GetVMString() { return "1"; }
3687 };
3688 template <> struct TagToType<0x0014,0x4089> {
3689 static const char* GetVRString() { return "DS"; }
3690 typedef VRToType<VR::DS>::Type Type;
3691 enum : long long { VRType = VR::DS };
3692 enum { VMType = VM::VM1 };
3693 static const char* GetVMString() { return "1"; }
3694 };
3695 template <> struct TagToType<0x0014,0x408b> {
3696 static const char* GetVRString() { return "DS"; }
3697 typedef VRToType<VR::DS>::Type Type;
3698 enum : long long { VRType = VR::DS };
3699 enum { VMType = VM::VM1 };
3700 static const char* GetVMString() { return "1"; }
3701 };
3702 template <> struct TagToType<0x0014,0x408c> {
3703 static const char* GetVRString() { return "DS"; }
3704 typedef VRToType<VR::DS>::Type Type;
3705 enum : long long { VRType = VR::DS };
3706 enum { VMType = VM::VM1 };
3707 static const char* GetVMString() { return "1"; }
3708 };
3709 template <> struct TagToType<0x0014,0x408d> {
3710 static const char* GetVRString() { return "DS"; }
3711 typedef VRToType<VR::DS>::Type Type;
3712 enum : long long { VRType = VR::DS };
3713 enum { VMType = VM::VM1 };
3714 static const char* GetVMString() { return "1"; }
3715 };
3716 template <> struct TagToType<0x0014,0x408e> {
3717 static const char* GetVRString() { return "DS"; }
3718 typedef VRToType<VR::DS>::Type Type;
3719 enum : long long { VRType = VR::DS };
3720 enum { VMType = VM::VM1 };
3721 static const char* GetVMString() { return "1"; }
3722 };
3723 template <> struct TagToType<0x0014,0x4091> {
3724 static const char* GetVRString() { return "SQ"; }
3725 typedef VRToType<VR::SQ>::Type Type;
3726 enum : long long { VRType = VR::SQ };
3727 enum { VMType = VM::VM1 };
3728 static const char* GetVMString() { return "1"; }
3729 };
3730 template <> struct TagToType<0x0014,0x4092> {
3731 static const char* GetVRString() { return "DS"; }
3732 typedef VRToType<VR::DS>::Type Type;
3733 enum : long long { VRType = VR::DS };
3734 enum { VMType = VM::VM1 };
3735 static const char* GetVMString() { return "1"; }
3736 };
3737 template <> struct TagToType<0x0014,0x409a> {
3738 static const char* GetVRString() { return "SQ"; }
3739 typedef VRToType<VR::SQ>::Type Type;
3740 enum : long long { VRType = VR::SQ };
3741 enum { VMType = VM::VM1 };
3742 static const char* GetVMString() { return "1"; }
3743 };
3744 template <> struct TagToType<0x0014,0x409b> {
3745 static const char* GetVRString() { return "ST"; }
3746 typedef VRToType<VR::ST>::Type Type;
3747 enum : long long { VRType = VR::ST };
3748 enum { VMType = VM::VM1 };
3749 static const char* GetVMString() { return "1"; }
3750 };
3751 template <> struct TagToType<0x0014,0x409c> {
3752 static const char* GetVRString() { return "DS"; }
3753 typedef VRToType<VR::DS>::Type Type;
3754 enum : long long { VRType = VR::DS };
3755 enum { VMType = VM::VM1 };
3756 static const char* GetVMString() { return "1"; }
3757 };
3758 template <> struct TagToType<0x0014,0x409d> {
3759 static const char* GetVRString() { return "DS"; }
3760 typedef VRToType<VR::DS>::Type Type;
3761 enum : long long { VRType = VR::DS };
3762 enum { VMType = VM::VM1 };
3763 static const char* GetVMString() { return "1"; }
3764 };
3765 template <> struct TagToType<0x0014,0x409f> {
3766 static const char* GetVRString() { return "DS"; }
3767 typedef VRToType<VR::DS>::Type Type;
3768 enum : long long { VRType = VR::DS };
3769 enum { VMType = VM::VM1 };
3770 static const char* GetVMString() { return "1"; }
3771 };
3772 template <> struct TagToType<0x0014,0x40a0> {
3773 static const char* GetVRString() { return "LO"; }
3774 typedef VRToType<VR::LO>::Type Type;
3775 enum : long long { VRType = VR::LO };
3776 enum { VMType = VM::VM1 };
3777 static const char* GetVMString() { return "1"; }
3778 };
3779 template <> struct TagToType<0x0014,0x40a1> {
3780 static const char* GetVRString() { return "LO"; }
3781 typedef VRToType<VR::LO>::Type Type;
3782 enum : long long { VRType = VR::LO };
3783 enum { VMType = VM::VM1 };
3784 static const char* GetVMString() { return "1"; }
3785 };
3786 template <> struct TagToType<0x0014,0x40a2> {
3787 static const char* GetVRString() { return "LO"; }
3788 typedef VRToType<VR::LO>::Type Type;
3789 enum : long long { VRType = VR::LO };
3790 enum { VMType = VM::VM1 };
3791 static const char* GetVMString() { return "1"; }
3792 };
3793 template <> struct TagToType<0x0014,0x5002> {
3794 static const char* GetVRString() { return "IS"; }
3795 typedef VRToType<VR::IS>::Type Type;
3796 enum : long long { VRType = VR::IS };
3797 enum { VMType = VM::VM1 };
3798 static const char* GetVMString() { return "1"; }
3799 };
3800 template <> struct TagToType<0x0014,0x5004> {
3801 static const char* GetVRString() { return "IS"; }
3802 typedef VRToType<VR::IS>::Type Type;
3803 enum : long long { VRType = VR::IS };
3804 enum { VMType = VM::VM1 };
3805 static const char* GetVMString() { return "1"; }
3806 };
3807 template <> struct TagToType<0x0014,0x5100> {
3808 static const char* GetVRString() { return "US"; }
3809 typedef VRToType<VR::US>::Type Type;
3810 enum : long long { VRType = VR::US };
3811 enum { VMType = VM::VM1 };
3812 static const char* GetVMString() { return "1"; }
3813 };
3814 template <> struct TagToType<0x0014,0x5101> {
3815 static const char* GetVRString() { return "DS"; }
3816 typedef VRToType<VR::DS>::Type Type;
3817 enum : long long { VRType = VR::DS };
3818 enum { VMType = VM::VM1 };
3819 static const char* GetVMString() { return "1"; }
3820 };
3821 template <> struct TagToType<0x0014,0x5102> {
3822 static const char* GetVRString() { return "DS"; }
3823 typedef VRToType<VR::DS>::Type Type;
3824 enum : long long { VRType = VR::DS };
3825 enum { VMType = VM::VM1 };
3826 static const char* GetVMString() { return "1"; }
3827 };
3828 template <> struct TagToType<0x0014,0x5103> {
3829 static const char* GetVRString() { return "DS"; }
3830 typedef VRToType<VR::DS>::Type Type;
3831 enum : long long { VRType = VR::DS };
3832 enum { VMType = VM::VM1 };
3833 static const char* GetVMString() { return "1"; }
3834 };
3835 template <> struct TagToType<0x0014,0x5104> {
3836 static const char* GetVRString() { return "DS"; }
3837 typedef VRToType<VR::DS>::Type Type;
3838 enum : long long { VRType = VR::DS };
3839 enum { VMType = VM::VM1 };
3840 static const char* GetVMString() { return "1"; }
3841 };
3842 template <> struct TagToType<0x0014,0x5105> {
3843 static const char* GetVRString() { return "CS"; }
3844 typedef VRToType<VR::CS>::Type Type;
3845 enum : long long { VRType = VR::CS };
3846 enum { VMType = VM::VM1 };
3847 static const char* GetVMString() { return "1"; }
3848 };
3849 template <> struct TagToType<0x0014,0x5106> {
3850 static const char* GetVRString() { return "SH"; }
3851 typedef VRToType<VR::SH>::Type Type;
3852 enum : long long { VRType = VR::SH };
3853 enum { VMType = VM::VM1 };
3854 static const char* GetVMString() { return "1"; }
3855 };
3856 template <> struct TagToType<0x0014,0x5107> {
3857 static const char* GetVRString() { return "DS"; }
3858 typedef VRToType<VR::DS>::Type Type;
3859 enum : long long { VRType = VR::DS };
3860 enum { VMType = VM::VM1 };
3861 static const char* GetVMString() { return "1"; }
3862 };
3863 template <> struct TagToType<0x0014,0x5108> {
3864 static const char* GetVRString() { return "DS"; }
3865 typedef VRToType<VR::DS>::Type Type;
3866 enum : long long { VRType = VR::DS };
3867 enum { VMType = VM::VM1 };
3868 static const char* GetVMString() { return "1"; }
3869 };
3870 template <> struct TagToType<0x0014,0x5109> {
3871 static const char* GetVRString() { return "CS"; }
3872 typedef VRToType<VR::CS>::Type Type;
3873 enum : long long { VRType = VR::CS };
3874 enum { VMType = VM::VM1 };
3875 static const char* GetVMString() { return "1"; }
3876 };
3877 template <> struct TagToType<0x0014,0x510a> {
3878 static const char* GetVRString() { return "DS"; }
3879 typedef VRToType<VR::DS>::Type Type;
3880 enum : long long { VRType = VR::DS };
3881 enum { VMType = VM::VM1 };
3882 static const char* GetVMString() { return "1"; }
3883 };
3884 template <> struct TagToType<0x0014,0x510b> {
3885 static const char* GetVRString() { return "SH"; }
3886 typedef VRToType<VR::SH>::Type Type;
3887 enum : long long { VRType = VR::SH };
3888 enum { VMType = VM::VM1 };
3889 static const char* GetVMString() { return "1"; }
3890 };
3891 template <> struct TagToType<0x0014,0x510c> {
3892 static const char* GetVRString() { return "DS"; }
3893 typedef VRToType<VR::DS>::Type Type;
3894 enum : long long { VRType = VR::DS };
3895 enum { VMType = VM::VM1 };
3896 static const char* GetVMString() { return "1"; }
3897 };
3898 template <> struct TagToType<0x0014,0x510d> {
3899 static const char* GetVRString() { return "DS"; }
3900 typedef VRToType<VR::DS>::Type Type;
3901 enum : long long { VRType = VR::DS };
3902 enum { VMType = VM::VM1 };
3903 static const char* GetVMString() { return "1"; }
3904 };
3905 template <> struct TagToType<0x0014,0x510e> {
3906 static const char* GetVRString() { return "DS"; }
3907 typedef VRToType<VR::DS>::Type Type;
3908 enum : long long { VRType = VR::DS };
3909 enum { VMType = VM::VM1 };
3910 static const char* GetVMString() { return "1"; }
3911 };
3912 template <> struct TagToType<0x0014,0x510f> {
3913 static const char* GetVRString() { return "SH"; }
3914 typedef VRToType<VR::SH>::Type Type;
3915 enum : long long { VRType = VR::SH };
3916 enum { VMType = VM::VM1 };
3917 static const char* GetVMString() { return "1"; }
3918 };
3919 template <> struct TagToType<0x0014,0x5110> {
3920 static const char* GetVRString() { return "SH"; }
3921 typedef VRToType<VR::SH>::Type Type;
3922 enum : long long { VRType = VR::SH };
3923 enum { VMType = VM::VM1 };
3924 static const char* GetVMString() { return "1"; }
3925 };
3926 template <> struct TagToType<0x0014,0x5111> {
3927 static const char* GetVRString() { return "LO"; }
3928 typedef VRToType<VR::LO>::Type Type;
3929 enum : long long { VRType = VR::LO };
3930 enum { VMType = VM::VM1 };
3931 static const char* GetVMString() { return "1"; }
3932 };
3933 template <> struct TagToType<0x0014,0x5112> {
3934 static const char* GetVRString() { return "DS"; }
3935 typedef VRToType<VR::DS>::Type Type;
3936 enum : long long { VRType = VR::DS };
3937 enum { VMType = VM::VM1 };
3938 static const char* GetVMString() { return "1"; }
3939 };
3940 template <> struct TagToType<0x0014,0x5113> {
3941 static const char* GetVRString() { return "DS"; }
3942 typedef VRToType<VR::DS>::Type Type;
3943 enum : long long { VRType = VR::DS };
3944 enum { VMType = VM::VM1 };
3945 static const char* GetVMString() { return "1"; }
3946 };
3947 template <> struct TagToType<0x0014,0x5114> {
3948 static const char* GetVRString() { return "DS"; }
3949 typedef VRToType<VR::DS>::Type Type;
3950 enum : long long { VRType = VR::DS };
3951 enum { VMType = VM::VM1 };
3952 static const char* GetVMString() { return "1"; }
3953 };
3954 template <> struct TagToType<0x0014,0x5115> {
3955 static const char* GetVRString() { return "DS"; }
3956 typedef VRToType<VR::DS>::Type Type;
3957 enum : long long { VRType = VR::DS };
3958 enum { VMType = VM::VM1 };
3959 static const char* GetVMString() { return "1"; }
3960 };
3961 template <> struct TagToType<0x0014,0x5116> {
3962 static const char* GetVRString() { return "DS"; }
3963 typedef VRToType<VR::DS>::Type Type;
3964 enum : long long { VRType = VR::DS };
3965 enum { VMType = VM::VM1 };
3966 static const char* GetVMString() { return "1"; }
3967 };
3968 template <> struct TagToType<0x0014,0x5117> {
3969 static const char* GetVRString() { return "DS"; }
3970 typedef VRToType<VR::DS>::Type Type;
3971 enum : long long { VRType = VR::DS };
3972 enum { VMType = VM::VM1 };
3973 static const char* GetVMString() { return "1"; }
3974 };
3975 template <> struct TagToType<0x0014,0x5118> {
3976 static const char* GetVRString() { return "DS"; }
3977 typedef VRToType<VR::DS>::Type Type;
3978 enum : long long { VRType = VR::DS };
3979 enum { VMType = VM::VM1 };
3980 static const char* GetVMString() { return "1"; }
3981 };
3982 template <> struct TagToType<0x0014,0x5119> {
3983 static const char* GetVRString() { return "DS"; }
3984 typedef VRToType<VR::DS>::Type Type;
3985 enum : long long { VRType = VR::DS };
3986 enum { VMType = VM::VM1 };
3987 static const char* GetVMString() { return "1"; }
3988 };
3989 template <> struct TagToType<0x0014,0x511a> {
3990 static const char* GetVRString() { return "DS"; }
3991 typedef VRToType<VR::DS>::Type Type;
3992 enum : long long { VRType = VR::DS };
3993 enum { VMType = VM::VM1 };
3994 static const char* GetVMString() { return "1"; }
3995 };
3996 template <> struct TagToType<0x0014,0x511b> {
3997 static const char* GetVRString() { return "DS"; }
3998 typedef VRToType<VR::DS>::Type Type;
3999 enum : long long { VRType = VR::DS };
4000 enum { VMType = VM::VM1 };
4001 static const char* GetVMString() { return "1"; }
4002 };
4003 template <> struct TagToType<0x0014,0x511c> {
4004 static const char* GetVRString() { return "DS"; }
4005 typedef VRToType<VR::DS>::Type Type;
4006 enum : long long { VRType = VR::DS };
4007 enum { VMType = VM::VM1 };
4008 static const char* GetVMString() { return "1"; }
4009 };
4010 template <> struct TagToType<0x0014,0x511d> {
4011 static const char* GetVRString() { return "DS"; }
4012 typedef VRToType<VR::DS>::Type Type;
4013 enum : long long { VRType = VR::DS };
4014 enum { VMType = VM::VM1 };
4015 static const char* GetVMString() { return "1"; }
4016 };
4017 template <> struct TagToType<0x0014,0x511e> {
4018 static const char* GetVRString() { return "CS"; }
4019 typedef VRToType<VR::CS>::Type Type;
4020 enum : long long { VRType = VR::CS };
4021 enum { VMType = VM::VM1 };
4022 static const char* GetVMString() { return "1"; }
4023 };
4024 template <> struct TagToType<0x0014,0x511f> {
4025 static const char* GetVRString() { return "DS"; }
4026 typedef VRToType<VR::DS>::Type Type;
4027 enum : long long { VRType = VR::DS };
4028 enum { VMType = VM::VM1 };
4029 static const char* GetVMString() { return "1"; }
4030 };
4031 template <> struct TagToType<0x0018,0x0010> {
4032 static const char* GetVRString() { return "LO"; }
4033 typedef VRToType<VR::LO>::Type Type;
4034 enum : long long { VRType = VR::LO };
4035 enum { VMType = VM::VM1 };
4036 static const char* GetVMString() { return "1"; }
4037 };
4038 template <> struct TagToType<0x0018,0x0012> {
4039 static const char* GetVRString() { return "SQ"; }
4040 typedef VRToType<VR::SQ>::Type Type;
4041 enum : long long { VRType = VR::SQ };
4042 enum { VMType = VM::VM1 };
4043 static const char* GetVMString() { return "1"; }
4044 };
4045 template <> struct TagToType<0x0018,0x0013> {
4046 static const char* GetVRString() { return "FL"; }
4047 typedef VRToType<VR::FL>::Type Type;
4048 enum : long long { VRType = VR::FL };
4049 enum { VMType = VM::VM1 };
4050 static const char* GetVMString() { return "1"; }
4051 };
4052 template <> struct TagToType<0x0018,0x0014> {
4053 static const char* GetVRString() { return "SQ"; }
4054 typedef VRToType<VR::SQ>::Type Type;
4055 enum : long long { VRType = VR::SQ };
4056 enum { VMType = VM::VM1 };
4057 static const char* GetVMString() { return "1"; }
4058 };
4059 template <> struct TagToType<0x0018,0x0015> {
4060 static const char* GetVRString() { return "CS"; }
4061 typedef VRToType<VR::CS>::Type Type;
4062 enum : long long { VRType = VR::CS };
4063 enum { VMType = VM::VM1 };
4064 static const char* GetVMString() { return "1"; }
4065 };
4066 template <> struct TagToType<0x0018,0x0020> {
4067 static const char* GetVRString() { return "CS"; }
4068 typedef VRToType<VR::CS>::Type Type;
4069 enum : long long { VRType = VR::CS };
4070 enum { VMType = VM::VM1_n };
4071 static const char* GetVMString() { return "1-n"; }
4072 };
4073 template <> struct TagToType<0x0018,0x0021> {
4074 static const char* GetVRString() { return "CS"; }
4075 typedef VRToType<VR::CS>::Type Type;
4076 enum : long long { VRType = VR::CS };
4077 enum { VMType = VM::VM1_n };
4078 static const char* GetVMString() { return "1-n"; }
4079 };
4080 template <> struct TagToType<0x0018,0x0022> {
4081 static const char* GetVRString() { return "CS"; }
4082 typedef VRToType<VR::CS>::Type Type;
4083 enum : long long { VRType = VR::CS };
4084 enum { VMType = VM::VM1_n };
4085 static const char* GetVMString() { return "1-n"; }
4086 };
4087 template <> struct TagToType<0x0018,0x0023> {
4088 static const char* GetVRString() { return "CS"; }
4089 typedef VRToType<VR::CS>::Type Type;
4090 enum : long long { VRType = VR::CS };
4091 enum { VMType = VM::VM1 };
4092 static const char* GetVMString() { return "1"; }
4093 };
4094 template <> struct TagToType<0x0018,0x0024> {
4095 static const char* GetVRString() { return "SH"; }
4096 typedef VRToType<VR::SH>::Type Type;
4097 enum : long long { VRType = VR::SH };
4098 enum { VMType = VM::VM1 };
4099 static const char* GetVMString() { return "1"; }
4100 };
4101 template <> struct TagToType<0x0018,0x0025> {
4102 static const char* GetVRString() { return "CS"; }
4103 typedef VRToType<VR::CS>::Type Type;
4104 enum : long long { VRType = VR::CS };
4105 enum { VMType = VM::VM1 };
4106 static const char* GetVMString() { return "1"; }
4107 };
4108 template <> struct TagToType<0x0018,0x0026> {
4109 static const char* GetVRString() { return "SQ"; }
4110 typedef VRToType<VR::SQ>::Type Type;
4111 enum : long long { VRType = VR::SQ };
4112 enum { VMType = VM::VM1 };
4113 static const char* GetVMString() { return "1"; }
4114 };
4115 template <> struct TagToType<0x0018,0x0027> {
4116 static const char* GetVRString() { return "TM"; }
4117 typedef VRToType<VR::TM>::Type Type;
4118 enum : long long { VRType = VR::TM };
4119 enum { VMType = VM::VM1 };
4120 static const char* GetVMString() { return "1"; }
4121 };
4122 template <> struct TagToType<0x0018,0x0028> {
4123 static const char* GetVRString() { return "DS"; }
4124 typedef VRToType<VR::DS>::Type Type;
4125 enum : long long { VRType = VR::DS };
4126 enum { VMType = VM::VM1 };
4127 static const char* GetVMString() { return "1"; }
4128 };
4129 template <> struct TagToType<0x0018,0x0029> {
4130 static const char* GetVRString() { return "SQ"; }
4131 typedef VRToType<VR::SQ>::Type Type;
4132 enum : long long { VRType = VR::SQ };
4133 enum { VMType = VM::VM1 };
4134 static const char* GetVMString() { return "1"; }
4135 };
4136 template <> struct TagToType<0x0018,0x002a> {
4137 static const char* GetVRString() { return "SQ"; }
4138 typedef VRToType<VR::SQ>::Type Type;
4139 enum : long long { VRType = VR::SQ };
4140 enum { VMType = VM::VM1 };
4141 static const char* GetVMString() { return "1"; }
4142 };
4143 template <> struct TagToType<0x0018,0x0030> {
4144 static const char* GetVRString() { return "LO"; }
4145 typedef VRToType<VR::LO>::Type Type;
4146 enum : long long { VRType = VR::LO };
4147 enum { VMType = VM::VM1_n };
4148 static const char* GetVMString() { return "1-n"; }
4149 };
4150 template <> struct TagToType<0x0018,0x0031> {
4151 static const char* GetVRString() { return "LO"; }
4152 typedef VRToType<VR::LO>::Type Type;
4153 enum : long long { VRType = VR::LO };
4154 enum { VMType = VM::VM1 };
4155 static const char* GetVMString() { return "1"; }
4156 };
4157 template <> struct TagToType<0x0018,0x0032> {
4158 static const char* GetVRString() { return "DS"; }
4159 typedef VRToType<VR::DS>::Type Type;
4160 enum : long long { VRType = VR::DS };
4161 enum { VMType = VM::VM1 };
4162 static const char* GetVMString() { return "1"; }
4163 };
4164 template <> struct TagToType<0x0018,0x0033> {
4165 static const char* GetVRString() { return "DS"; }
4166 typedef VRToType<VR::DS>::Type Type;
4167 enum : long long { VRType = VR::DS };
4168 enum { VMType = VM::VM1_n };
4169 static const char* GetVMString() { return "1-n"; }
4170 };
4171 template <> struct TagToType<0x0018,0x0034> {
4172 static const char* GetVRString() { return "LO"; }
4173 typedef VRToType<VR::LO>::Type Type;
4174 enum : long long { VRType = VR::LO };
4175 enum { VMType = VM::VM1 };
4176 static const char* GetVMString() { return "1"; }
4177 };
4178 template <> struct TagToType<0x0018,0x0035> {
4179 static const char* GetVRString() { return "TM"; }
4180 typedef VRToType<VR::TM>::Type Type;
4181 enum : long long { VRType = VR::TM };
4182 enum { VMType = VM::VM1 };
4183 static const char* GetVMString() { return "1"; }
4184 };
4185 template <> struct TagToType<0x0018,0x0036> {
4186 static const char* GetVRString() { return "SQ"; }
4187 typedef VRToType<VR::SQ>::Type Type;
4188 enum : long long { VRType = VR::SQ };
4189 enum { VMType = VM::VM1 };
4190 static const char* GetVMString() { return "1"; }
4191 };
4192 template <> struct TagToType<0x0018,0x0037> {
4193 static const char* GetVRString() { return "CS"; }
4194 typedef VRToType<VR::CS>::Type Type;
4195 enum : long long { VRType = VR::CS };
4196 enum { VMType = VM::VM1 };
4197 static const char* GetVMString() { return "1"; }
4198 };
4199 template <> struct TagToType<0x0018,0x0038> {
4200 static const char* GetVRString() { return "CS"; }
4201 typedef VRToType<VR::CS>::Type Type;
4202 enum : long long { VRType = VR::CS };
4203 enum { VMType = VM::VM1 };
4204 static const char* GetVMString() { return "1"; }
4205 };
4206 template <> struct TagToType<0x0018,0x0039> {
4207 static const char* GetVRString() { return "CS"; }
4208 typedef VRToType<VR::CS>::Type Type;
4209 enum : long long { VRType = VR::CS };
4210 enum { VMType = VM::VM1 };
4211 static const char* GetVMString() { return "1"; }
4212 };
4213 template <> struct TagToType<0x0018,0x003a> {
4214 static const char* GetVRString() { return "ST"; }
4215 typedef VRToType<VR::ST>::Type Type;
4216 enum : long long { VRType = VR::ST };
4217 enum { VMType = VM::VM1 };
4218 static const char* GetVMString() { return "1"; }
4219 };
4220 template <> struct TagToType<0x0018,0x0040> {
4221 static const char* GetVRString() { return "IS"; }
4222 typedef VRToType<VR::IS>::Type Type;
4223 enum : long long { VRType = VR::IS };
4224 enum { VMType = VM::VM1 };
4225 static const char* GetVMString() { return "1"; }
4226 };
4227 template <> struct TagToType<0x0018,0x0042> {
4228 static const char* GetVRString() { return "CS"; }
4229 typedef VRToType<VR::CS>::Type Type;
4230 enum : long long { VRType = VR::CS };
4231 enum { VMType = VM::VM1 };
4232 static const char* GetVMString() { return "1"; }
4233 };
4234 template <> struct TagToType<0x0018,0x0050> {
4235 static const char* GetVRString() { return "DS"; }
4236 typedef VRToType<VR::DS>::Type Type;
4237 enum : long long { VRType = VR::DS };
4238 enum { VMType = VM::VM1 };
4239 static const char* GetVMString() { return "1"; }
4240 };
4241 template <> struct TagToType<0x0018,0x0060> {
4242 static const char* GetVRString() { return "DS"; }
4243 typedef VRToType<VR::DS>::Type Type;
4244 enum : long long { VRType = VR::DS };
4245 enum { VMType = VM::VM1 };
4246 static const char* GetVMString() { return "1"; }
4247 };
4248 template <> struct TagToType<0x0018,0x0061> {
4249 static const char* GetVRString() { return "DS"; }
4250 typedef VRToType<VR::DS>::Type Type;
4251 enum : long long { VRType = VR::DS };
4252 enum { VMType = VM::VM1 };
4253 static const char* GetVMString() { return "1"; }
4254 };
4255 template <> struct TagToType<0x0018,0x0070> {
4256 static const char* GetVRString() { return "IS"; }
4257 typedef VRToType<VR::IS>::Type Type;
4258 enum : long long { VRType = VR::IS };
4259 enum { VMType = VM::VM1 };
4260 static const char* GetVMString() { return "1"; }
4261 };
4262 template <> struct TagToType<0x0018,0x0071> {
4263 static const char* GetVRString() { return "CS"; }
4264 typedef VRToType<VR::CS>::Type Type;
4265 enum : long long { VRType = VR::CS };
4266 enum { VMType = VM::VM1 };
4267 static const char* GetVMString() { return "1"; }
4268 };
4269 template <> struct TagToType<0x0018,0x0072> {
4270 static const char* GetVRString() { return "DS"; }
4271 typedef VRToType<VR::DS>::Type Type;
4272 enum : long long { VRType = VR::DS };
4273 enum { VMType = VM::VM1 };
4274 static const char* GetVMString() { return "1"; }
4275 };
4276 template <> struct TagToType<0x0018,0x0073> {
4277 static const char* GetVRString() { return "CS"; }
4278 typedef VRToType<VR::CS>::Type Type;
4279 enum : long long { VRType = VR::CS };
4280 enum { VMType = VM::VM1 };
4281 static const char* GetVMString() { return "1"; }
4282 };
4283 template <> struct TagToType<0x0018,0x0074> {
4284 static const char* GetVRString() { return "IS"; }
4285 typedef VRToType<VR::IS>::Type Type;
4286 enum : long long { VRType = VR::IS };
4287 enum { VMType = VM::VM1 };
4288 static const char* GetVMString() { return "1"; }
4289 };
4290 template <> struct TagToType<0x0018,0x0075> {
4291 static const char* GetVRString() { return "IS"; }
4292 typedef VRToType<VR::IS>::Type Type;
4293 enum : long long { VRType = VR::IS };
4294 enum { VMType = VM::VM1 };
4295 static const char* GetVMString() { return "1"; }
4296 };
4297 template <> struct TagToType<0x0018,0x0080> {
4298 static const char* GetVRString() { return "DS"; }
4299 typedef VRToType<VR::DS>::Type Type;
4300 enum : long long { VRType = VR::DS };
4301 enum { VMType = VM::VM1 };
4302 static const char* GetVMString() { return "1"; }
4303 };
4304 template <> struct TagToType<0x0018,0x0081> {
4305 static const char* GetVRString() { return "DS"; }
4306 typedef VRToType<VR::DS>::Type Type;
4307 enum : long long { VRType = VR::DS };
4308 enum { VMType = VM::VM1 };
4309 static const char* GetVMString() { return "1"; }
4310 };
4311 template <> struct TagToType<0x0018,0x0082> {
4312 static const char* GetVRString() { return "DS"; }
4313 typedef VRToType<VR::DS>::Type Type;
4314 enum : long long { VRType = VR::DS };
4315 enum { VMType = VM::VM1 };
4316 static const char* GetVMString() { return "1"; }
4317 };
4318 template <> struct TagToType<0x0018,0x0083> {
4319 static const char* GetVRString() { return "DS"; }
4320 typedef VRToType<VR::DS>::Type Type;
4321 enum : long long { VRType = VR::DS };
4322 enum { VMType = VM::VM1 };
4323 static const char* GetVMString() { return "1"; }
4324 };
4325 template <> struct TagToType<0x0018,0x0084> {
4326 static const char* GetVRString() { return "DS"; }
4327 typedef VRToType<VR::DS>::Type Type;
4328 enum : long long { VRType = VR::DS };
4329 enum { VMType = VM::VM1 };
4330 static const char* GetVMString() { return "1"; }
4331 };
4332 template <> struct TagToType<0x0018,0x0085> {
4333 static const char* GetVRString() { return "SH"; }
4334 typedef VRToType<VR::SH>::Type Type;
4335 enum : long long { VRType = VR::SH };
4336 enum { VMType = VM::VM1 };
4337 static const char* GetVMString() { return "1"; }
4338 };
4339 template <> struct TagToType<0x0018,0x0086> {
4340 static const char* GetVRString() { return "IS"; }
4341 typedef VRToType<VR::IS>::Type Type;
4342 enum : long long { VRType = VR::IS };
4343 enum { VMType = VM::VM1_n };
4344 static const char* GetVMString() { return "1-n"; }
4345 };
4346 template <> struct TagToType<0x0018,0x0087> {
4347 static const char* GetVRString() { return "DS"; }
4348 typedef VRToType<VR::DS>::Type Type;
4349 enum : long long { VRType = VR::DS };
4350 enum { VMType = VM::VM1 };
4351 static const char* GetVMString() { return "1"; }
4352 };
4353 template <> struct TagToType<0x0018,0x0088> {
4354 static const char* GetVRString() { return "DS"; }
4355 typedef VRToType<VR::DS>::Type Type;
4356 enum : long long { VRType = VR::DS };
4357 enum { VMType = VM::VM1 };
4358 static const char* GetVMString() { return "1"; }
4359 };
4360 template <> struct TagToType<0x0018,0x0089> {
4361 static const char* GetVRString() { return "IS"; }
4362 typedef VRToType<VR::IS>::Type Type;
4363 enum : long long { VRType = VR::IS };
4364 enum { VMType = VM::VM1 };
4365 static const char* GetVMString() { return "1"; }
4366 };
4367 template <> struct TagToType<0x0018,0x0090> {
4368 static const char* GetVRString() { return "DS"; }
4369 typedef VRToType<VR::DS>::Type Type;
4370 enum : long long { VRType = VR::DS };
4371 enum { VMType = VM::VM1 };
4372 static const char* GetVMString() { return "1"; }
4373 };
4374 template <> struct TagToType<0x0018,0x0091> {
4375 static const char* GetVRString() { return "IS"; }
4376 typedef VRToType<VR::IS>::Type Type;
4377 enum : long long { VRType = VR::IS };
4378 enum { VMType = VM::VM1 };
4379 static const char* GetVMString() { return "1"; }
4380 };
4381 template <> struct TagToType<0x0018,0x0093> {
4382 static const char* GetVRString() { return "DS"; }
4383 typedef VRToType<VR::DS>::Type Type;
4384 enum : long long { VRType = VR::DS };
4385 enum { VMType = VM::VM1 };
4386 static const char* GetVMString() { return "1"; }
4387 };
4388 template <> struct TagToType<0x0018,0x0094> {
4389 static const char* GetVRString() { return "DS"; }
4390 typedef VRToType<VR::DS>::Type Type;
4391 enum : long long { VRType = VR::DS };
4392 enum { VMType = VM::VM1 };
4393 static const char* GetVMString() { return "1"; }
4394 };
4395 template <> struct TagToType<0x0018,0x0095> {
4396 static const char* GetVRString() { return "DS"; }
4397 typedef VRToType<VR::DS>::Type Type;
4398 enum : long long { VRType = VR::DS };
4399 enum { VMType = VM::VM1 };
4400 static const char* GetVMString() { return "1"; }
4401 };
4402 template <> struct TagToType<0x0018,0x1000> {
4403 static const char* GetVRString() { return "LO"; }
4404 typedef VRToType<VR::LO>::Type Type;
4405 enum : long long { VRType = VR::LO };
4406 enum { VMType = VM::VM1 };
4407 static const char* GetVMString() { return "1"; }
4408 };
4409 template <> struct TagToType<0x0018,0x1002> {
4410 static const char* GetVRString() { return "UI"; }
4411 typedef VRToType<VR::UI>::Type Type;
4412 enum : long long { VRType = VR::UI };
4413 enum { VMType = VM::VM1 };
4414 static const char* GetVMString() { return "1"; }
4415 };
4416 template <> struct TagToType<0x0018,0x1003> {
4417 static const char* GetVRString() { return "LO"; }
4418 typedef VRToType<VR::LO>::Type Type;
4419 enum : long long { VRType = VR::LO };
4420 enum { VMType = VM::VM1 };
4421 static const char* GetVMString() { return "1"; }
4422 };
4423 template <> struct TagToType<0x0018,0x1004> {
4424 static const char* GetVRString() { return "LO"; }
4425 typedef VRToType<VR::LO>::Type Type;
4426 enum : long long { VRType = VR::LO };
4427 enum { VMType = VM::VM1 };
4428 static const char* GetVMString() { return "1"; }
4429 };
4430 template <> struct TagToType<0x0018,0x1005> {
4431 static const char* GetVRString() { return "LO"; }
4432 typedef VRToType<VR::LO>::Type Type;
4433 enum : long long { VRType = VR::LO };
4434 enum { VMType = VM::VM1 };
4435 static const char* GetVMString() { return "1"; }
4436 };
4437 template <> struct TagToType<0x0018,0x1006> {
4438 static const char* GetVRString() { return "LO"; }
4439 typedef VRToType<VR::LO>::Type Type;
4440 enum : long long { VRType = VR::LO };
4441 enum { VMType = VM::VM1 };
4442 static const char* GetVMString() { return "1"; }
4443 };
4444 template <> struct TagToType<0x0018,0x1007> {
4445 static const char* GetVRString() { return "LO"; }
4446 typedef VRToType<VR::LO>::Type Type;
4447 enum : long long { VRType = VR::LO };
4448 enum { VMType = VM::VM1 };
4449 static const char* GetVMString() { return "1"; }
4450 };
4451 template <> struct TagToType<0x0018,0x1008> {
4452 static const char* GetVRString() { return "LO"; }
4453 typedef VRToType<VR::LO>::Type Type;
4454 enum : long long { VRType = VR::LO };
4455 enum { VMType = VM::VM1 };
4456 static const char* GetVMString() { return "1"; }
4457 };
4458 template <> struct TagToType<0x0018,0x1009> {
4459 static const char* GetVRString() { return "UT"; }
4460 typedef VRToType<VR::UT>::Type Type;
4461 enum : long long { VRType = VR::UT };
4462 enum { VMType = VM::VM1 };
4463 static const char* GetVMString() { return "1"; }
4464 };
4465 template <> struct TagToType<0x0018,0x100a> {
4466 static const char* GetVRString() { return "SQ"; }
4467 typedef VRToType<VR::SQ>::Type Type;
4468 enum : long long { VRType = VR::SQ };
4469 enum { VMType = VM::VM1 };
4470 static const char* GetVMString() { return "1"; }
4471 };
4472 template <> struct TagToType<0x0018,0x1010> {
4473 static const char* GetVRString() { return "LO"; }
4474 typedef VRToType<VR::LO>::Type Type;
4475 enum : long long { VRType = VR::LO };
4476 enum { VMType = VM::VM1 };
4477 static const char* GetVMString() { return "1"; }
4478 };
4479 template <> struct TagToType<0x0018,0x1011> {
4480 static const char* GetVRString() { return "LO"; }
4481 typedef VRToType<VR::LO>::Type Type;
4482 enum : long long { VRType = VR::LO };
4483 enum { VMType = VM::VM1 };
4484 static const char* GetVMString() { return "1"; }
4485 };
4486 template <> struct TagToType<0x0018,0x1012> {
4487 static const char* GetVRString() { return "DA"; }
4488 typedef VRToType<VR::DA>::Type Type;
4489 enum : long long { VRType = VR::DA };
4490 enum { VMType = VM::VM1 };
4491 static const char* GetVMString() { return "1"; }
4492 };
4493 template <> struct TagToType<0x0018,0x1014> {
4494 static const char* GetVRString() { return "TM"; }
4495 typedef VRToType<VR::TM>::Type Type;
4496 enum : long long { VRType = VR::TM };
4497 enum { VMType = VM::VM1 };
4498 static const char* GetVMString() { return "1"; }
4499 };
4500 template <> struct TagToType<0x0018,0x1016> {
4501 static const char* GetVRString() { return "LO"; }
4502 typedef VRToType<VR::LO>::Type Type;
4503 enum : long long { VRType = VR::LO };
4504 enum { VMType = VM::VM1 };
4505 static const char* GetVMString() { return "1"; }
4506 };
4507 template <> struct TagToType<0x0018,0x1017> {
4508 static const char* GetVRString() { return "LO"; }
4509 typedef VRToType<VR::LO>::Type Type;
4510 enum : long long { VRType = VR::LO };
4511 enum { VMType = VM::VM1 };
4512 static const char* GetVMString() { return "1"; }
4513 };
4514 template <> struct TagToType<0x0018,0x1018> {
4515 static const char* GetVRString() { return "LO"; }
4516 typedef VRToType<VR::LO>::Type Type;
4517 enum : long long { VRType = VR::LO };
4518 enum { VMType = VM::VM1 };
4519 static const char* GetVMString() { return "1"; }
4520 };
4521 template <> struct TagToType<0x0018,0x1019> {
4522 static const char* GetVRString() { return "LO"; }
4523 typedef VRToType<VR::LO>::Type Type;
4524 enum : long long { VRType = VR::LO };
4525 enum { VMType = VM::VM1_n };
4526 static const char* GetVMString() { return "1-n"; }
4527 };
4528 template <> struct TagToType<0x0018,0x101a> {
4529 static const char* GetVRString() { return "LO"; }
4530 typedef VRToType<VR::LO>::Type Type;
4531 enum : long long { VRType = VR::LO };
4532 enum { VMType = VM::VM1_n };
4533 static const char* GetVMString() { return "1-n"; }
4534 };
4535 template <> struct TagToType<0x0018,0x101b> {
4536 static const char* GetVRString() { return "LO"; }
4537 typedef VRToType<VR::LO>::Type Type;
4538 enum : long long { VRType = VR::LO };
4539 enum { VMType = VM::VM1 };
4540 static const char* GetVMString() { return "1"; }
4541 };
4542 template <> struct TagToType<0x0018,0x1020> {
4543 static const char* GetVRString() { return "LO"; }
4544 typedef VRToType<VR::LO>::Type Type;
4545 enum : long long { VRType = VR::LO };
4546 enum { VMType = VM::VM1_n };
4547 static const char* GetVMString() { return "1-n"; }
4548 };
4549 template <> struct TagToType<0x0018,0x1022> {
4550 static const char* GetVRString() { return "SH"; }
4551 typedef VRToType<VR::SH>::Type Type;
4552 enum : long long { VRType = VR::SH };
4553 enum { VMType = VM::VM1 };
4554 static const char* GetVMString() { return "1"; }
4555 };
4556 template <> struct TagToType<0x0018,0x1023> {
4557 static const char* GetVRString() { return "LO"; }
4558 typedef VRToType<VR::LO>::Type Type;
4559 enum : long long { VRType = VR::LO };
4560 enum { VMType = VM::VM1 };
4561 static const char* GetVMString() { return "1"; }
4562 };
4563 template <> struct TagToType<0x0018,0x1030> {
4564 static const char* GetVRString() { return "LO"; }
4565 typedef VRToType<VR::LO>::Type Type;
4566 enum : long long { VRType = VR::LO };
4567 enum { VMType = VM::VM1 };
4568 static const char* GetVMString() { return "1"; }
4569 };
4570 template <> struct TagToType<0x0018,0x1040> {
4571 static const char* GetVRString() { return "LO"; }
4572 typedef VRToType<VR::LO>::Type Type;
4573 enum : long long { VRType = VR::LO };
4574 enum { VMType = VM::VM1 };
4575 static const char* GetVMString() { return "1"; }
4576 };
4577 template <> struct TagToType<0x0018,0x1041> {
4578 static const char* GetVRString() { return "DS"; }
4579 typedef VRToType<VR::DS>::Type Type;
4580 enum : long long { VRType = VR::DS };
4581 enum { VMType = VM::VM1 };
4582 static const char* GetVMString() { return "1"; }
4583 };
4584 template <> struct TagToType<0x0018,0x1042> {
4585 static const char* GetVRString() { return "TM"; }
4586 typedef VRToType<VR::TM>::Type Type;
4587 enum : long long { VRType = VR::TM };
4588 enum { VMType = VM::VM1 };
4589 static const char* GetVMString() { return "1"; }
4590 };
4591 template <> struct TagToType<0x0018,0x1043> {
4592 static const char* GetVRString() { return "TM"; }
4593 typedef VRToType<VR::TM>::Type Type;
4594 enum : long long { VRType = VR::TM };
4595 enum { VMType = VM::VM1 };
4596 static const char* GetVMString() { return "1"; }
4597 };
4598 template <> struct TagToType<0x0018,0x1044> {
4599 static const char* GetVRString() { return "DS"; }
4600 typedef VRToType<VR::DS>::Type Type;
4601 enum : long long { VRType = VR::DS };
4602 enum { VMType = VM::VM1 };
4603 static const char* GetVMString() { return "1"; }
4604 };
4605 template <> struct TagToType<0x0018,0x1045> {
4606 static const char* GetVRString() { return "IS"; }
4607 typedef VRToType<VR::IS>::Type Type;
4608 enum : long long { VRType = VR::IS };
4609 enum { VMType = VM::VM1 };
4610 static const char* GetVMString() { return "1"; }
4611 };
4612 template <> struct TagToType<0x0018,0x1046> {
4613 static const char* GetVRString() { return "DS"; }
4614 typedef VRToType<VR::DS>::Type Type;
4615 enum : long long { VRType = VR::DS };
4616 enum { VMType = VM::VM1_n };
4617 static const char* GetVMString() { return "1-n"; }
4618 };
4619 template <> struct TagToType<0x0018,0x1047> {
4620 static const char* GetVRString() { return "DS"; }
4621 typedef VRToType<VR::DS>::Type Type;
4622 enum : long long { VRType = VR::DS };
4623 enum { VMType = VM::VM1_n };
4624 static const char* GetVMString() { return "1-n"; }
4625 };
4626 template <> struct TagToType<0x0018,0x1048> {
4627 static const char* GetVRString() { return "CS"; }
4628 typedef VRToType<VR::CS>::Type Type;
4629 enum : long long { VRType = VR::CS };
4630 enum { VMType = VM::VM1 };
4631 static const char* GetVMString() { return "1"; }
4632 };
4633 template <> struct TagToType<0x0018,0x1049> {
4634 static const char* GetVRString() { return "DS"; }
4635 typedef VRToType<VR::DS>::Type Type;
4636 enum : long long { VRType = VR::DS };
4637 enum { VMType = VM::VM1 };
4638 static const char* GetVMString() { return "1"; }
4639 };
4640 template <> struct TagToType<0x0018,0x1050> {
4641 static const char* GetVRString() { return "DS"; }
4642 typedef VRToType<VR::DS>::Type Type;
4643 enum : long long { VRType = VR::DS };
4644 enum { VMType = VM::VM1 };
4645 static const char* GetVMString() { return "1"; }
4646 };
4647 template <> struct TagToType<0x0018,0x1060> {
4648 static const char* GetVRString() { return "DS"; }
4649 typedef VRToType<VR::DS>::Type Type;
4650 enum : long long { VRType = VR::DS };
4651 enum { VMType = VM::VM1 };
4652 static const char* GetVMString() { return "1"; }
4653 };
4654 template <> struct TagToType<0x0018,0x1061> {
4655 static const char* GetVRString() { return "LO"; }
4656 typedef VRToType<VR::LO>::Type Type;
4657 enum : long long { VRType = VR::LO };
4658 enum { VMType = VM::VM1 };
4659 static const char* GetVMString() { return "1"; }
4660 };
4661 template <> struct TagToType<0x0018,0x1062> {
4662 static const char* GetVRString() { return "IS"; }
4663 typedef VRToType<VR::IS>::Type Type;
4664 enum : long long { VRType = VR::IS };
4665 enum { VMType = VM::VM1 };
4666 static const char* GetVMString() { return "1"; }
4667 };
4668 template <> struct TagToType<0x0018,0x1063> {
4669 static const char* GetVRString() { return "DS"; }
4670 typedef VRToType<VR::DS>::Type Type;
4671 enum : long long { VRType = VR::DS };
4672 enum { VMType = VM::VM1 };
4673 static const char* GetVMString() { return "1"; }
4674 };
4675 template <> struct TagToType<0x0018,0x1064> {
4676 static const char* GetVRString() { return "LO"; }
4677 typedef VRToType<VR::LO>::Type Type;
4678 enum : long long { VRType = VR::LO };
4679 enum { VMType = VM::VM1 };
4680 static const char* GetVMString() { return "1"; }
4681 };
4682 template <> struct TagToType<0x0018,0x1065> {
4683 static const char* GetVRString() { return "DS"; }
4684 typedef VRToType<VR::DS>::Type Type;
4685 enum : long long { VRType = VR::DS };
4686 enum { VMType = VM::VM1_n };
4687 static const char* GetVMString() { return "1-n"; }
4688 };
4689 template <> struct TagToType<0x0018,0x1066> {
4690 static const char* GetVRString() { return "DS"; }
4691 typedef VRToType<VR::DS>::Type Type;
4692 enum : long long { VRType = VR::DS };
4693 enum { VMType = VM::VM1 };
4694 static const char* GetVMString() { return "1"; }
4695 };
4696 template <> struct TagToType<0x0018,0x1067> {
4697 static const char* GetVRString() { return "DS"; }
4698 typedef VRToType<VR::DS>::Type Type;
4699 enum : long long { VRType = VR::DS };
4700 enum { VMType = VM::VM1 };
4701 static const char* GetVMString() { return "1"; }
4702 };
4703 template <> struct TagToType<0x0018,0x1068> {
4704 static const char* GetVRString() { return "DS"; }
4705 typedef VRToType<VR::DS>::Type Type;
4706 enum : long long { VRType = VR::DS };
4707 enum { VMType = VM::VM1 };
4708 static const char* GetVMString() { return "1"; }
4709 };
4710 template <> struct TagToType<0x0018,0x1069> {
4711 static const char* GetVRString() { return "DS"; }
4712 typedef VRToType<VR::DS>::Type Type;
4713 enum : long long { VRType = VR::DS };
4714 enum { VMType = VM::VM1 };
4715 static const char* GetVMString() { return "1"; }
4716 };
4717 template <> struct TagToType<0x0018,0x106a> {
4718 static const char* GetVRString() { return "CS"; }
4719 typedef VRToType<VR::CS>::Type Type;
4720 enum : long long { VRType = VR::CS };
4721 enum { VMType = VM::VM1 };
4722 static const char* GetVMString() { return "1"; }
4723 };
4724 template <> struct TagToType<0x0018,0x106c> {
4725 static const char* GetVRString() { return "US"; }
4726 typedef VRToType<VR::US>::Type Type;
4727 enum : long long { VRType = VR::US };
4728 enum { VMType = VM::VM2 };
4729 static const char* GetVMString() { return "2"; }
4730 };
4731 template <> struct TagToType<0x0018,0x106e> {
4732 static const char* GetVRString() { return "UL"; }
4733 typedef VRToType<VR::UL>::Type Type;
4734 enum : long long { VRType = VR::UL };
4735 enum { VMType = VM::VM1 };
4736 static const char* GetVMString() { return "1"; }
4737 };
4738 template <> struct TagToType<0x0018,0x1070> {
4739 static const char* GetVRString() { return "LO"; }
4740 typedef VRToType<VR::LO>::Type Type;
4741 enum : long long { VRType = VR::LO };
4742 enum { VMType = VM::VM1 };
4743 static const char* GetVMString() { return "1"; }
4744 };
4745 template <> struct TagToType<0x0018,0x1071> {
4746 static const char* GetVRString() { return "DS"; }
4747 typedef VRToType<VR::DS>::Type Type;
4748 enum : long long { VRType = VR::DS };
4749 enum { VMType = VM::VM1 };
4750 static const char* GetVMString() { return "1"; }
4751 };
4752 template <> struct TagToType<0x0018,0x1072> {
4753 static const char* GetVRString() { return "TM"; }
4754 typedef VRToType<VR::TM>::Type Type;
4755 enum : long long { VRType = VR::TM };
4756 enum { VMType = VM::VM1 };
4757 static const char* GetVMString() { return "1"; }
4758 };
4759 template <> struct TagToType<0x0018,0x1073> {
4760 static const char* GetVRString() { return "TM"; }
4761 typedef VRToType<VR::TM>::Type Type;
4762 enum : long long { VRType = VR::TM };
4763 enum { VMType = VM::VM1 };
4764 static const char* GetVMString() { return "1"; }
4765 };
4766 template <> struct TagToType<0x0018,0x1074> {
4767 static const char* GetVRString() { return "DS"; }
4768 typedef VRToType<VR::DS>::Type Type;
4769 enum : long long { VRType = VR::DS };
4770 enum { VMType = VM::VM1 };
4771 static const char* GetVMString() { return "1"; }
4772 };
4773 template <> struct TagToType<0x0018,0x1075> {
4774 static const char* GetVRString() { return "DS"; }
4775 typedef VRToType<VR::DS>::Type Type;
4776 enum : long long { VRType = VR::DS };
4777 enum { VMType = VM::VM1 };
4778 static const char* GetVMString() { return "1"; }
4779 };
4780 template <> struct TagToType<0x0018,0x1076> {
4781 static const char* GetVRString() { return "DS"; }
4782 typedef VRToType<VR::DS>::Type Type;
4783 enum : long long { VRType = VR::DS };
4784 enum { VMType = VM::VM1 };
4785 static const char* GetVMString() { return "1"; }
4786 };
4787 template <> struct TagToType<0x0018,0x1077> {
4788 static const char* GetVRString() { return "DS"; }
4789 typedef VRToType<VR::DS>::Type Type;
4790 enum : long long { VRType = VR::DS };
4791 enum { VMType = VM::VM1 };
4792 static const char* GetVMString() { return "1"; }
4793 };
4794 template <> struct TagToType<0x0018,0x1078> {
4795 static const char* GetVRString() { return "DT"; }
4796 typedef VRToType<VR::DT>::Type Type;
4797 enum : long long { VRType = VR::DT };
4798 enum { VMType = VM::VM1 };
4799 static const char* GetVMString() { return "1"; }
4800 };
4801 template <> struct TagToType<0x0018,0x1079> {
4802 static const char* GetVRString() { return "DT"; }
4803 typedef VRToType<VR::DT>::Type Type;
4804 enum : long long { VRType = VR::DT };
4805 enum { VMType = VM::VM1 };
4806 static const char* GetVMString() { return "1"; }
4807 };
4808 template <> struct TagToType<0x0018,0x1080> {
4809 static const char* GetVRString() { return "CS"; }
4810 typedef VRToType<VR::CS>::Type Type;
4811 enum : long long { VRType = VR::CS };
4812 enum { VMType = VM::VM1 };
4813 static const char* GetVMString() { return "1"; }
4814 };
4815 template <> struct TagToType<0x0018,0x1081> {
4816 static const char* GetVRString() { return "IS"; }
4817 typedef VRToType<VR::IS>::Type Type;
4818 enum : long long { VRType = VR::IS };
4819 enum { VMType = VM::VM1 };
4820 static const char* GetVMString() { return "1"; }
4821 };
4822 template <> struct TagToType<0x0018,0x1082> {
4823 static const char* GetVRString() { return "IS"; }
4824 typedef VRToType<VR::IS>::Type Type;
4825 enum : long long { VRType = VR::IS };
4826 enum { VMType = VM::VM1 };
4827 static const char* GetVMString() { return "1"; }
4828 };
4829 template <> struct TagToType<0x0018,0x1083> {
4830 static const char* GetVRString() { return "IS"; }
4831 typedef VRToType<VR::IS>::Type Type;
4832 enum : long long { VRType = VR::IS };
4833 enum { VMType = VM::VM1 };
4834 static const char* GetVMString() { return "1"; }
4835 };
4836 template <> struct TagToType<0x0018,0x1084> {
4837 static const char* GetVRString() { return "IS"; }
4838 typedef VRToType<VR::IS>::Type Type;
4839 enum : long long { VRType = VR::IS };
4840 enum { VMType = VM::VM1 };
4841 static const char* GetVMString() { return "1"; }
4842 };
4843 template <> struct TagToType<0x0018,0x1085> {
4844 static const char* GetVRString() { return "LO"; }
4845 typedef VRToType<VR::LO>::Type Type;
4846 enum : long long { VRType = VR::LO };
4847 enum { VMType = VM::VM1 };
4848 static const char* GetVMString() { return "1"; }
4849 };
4850 template <> struct TagToType<0x0018,0x1086> {
4851 static const char* GetVRString() { return "IS"; }
4852 typedef VRToType<VR::IS>::Type Type;
4853 enum : long long { VRType = VR::IS };
4854 enum { VMType = VM::VM1 };
4855 static const char* GetVMString() { return "1"; }
4856 };
4857 template <> struct TagToType<0x0018,0x1088> {
4858 static const char* GetVRString() { return "IS"; }
4859 typedef VRToType<VR::IS>::Type Type;
4860 enum : long long { VRType = VR::IS };
4861 enum { VMType = VM::VM1 };
4862 static const char* GetVMString() { return "1"; }
4863 };
4864 template <> struct TagToType<0x0018,0x1090> {
4865 static const char* GetVRString() { return "IS"; }
4866 typedef VRToType<VR::IS>::Type Type;
4867 enum : long long { VRType = VR::IS };
4868 enum { VMType = VM::VM1 };
4869 static const char* GetVMString() { return "1"; }
4870 };
4871 template <> struct TagToType<0x0018,0x1094> {
4872 static const char* GetVRString() { return "IS"; }
4873 typedef VRToType<VR::IS>::Type Type;
4874 enum : long long { VRType = VR::IS };
4875 enum { VMType = VM::VM1 };
4876 static const char* GetVMString() { return "1"; }
4877 };
4878 template <> struct TagToType<0x0018,0x1100> {
4879 static const char* GetVRString() { return "DS"; }
4880 typedef VRToType<VR::DS>::Type Type;
4881 enum : long long { VRType = VR::DS };
4882 enum { VMType = VM::VM1 };
4883 static const char* GetVMString() { return "1"; }
4884 };
4885 template <> struct TagToType<0x0018,0x1110> {
4886 static const char* GetVRString() { return "DS"; }
4887 typedef VRToType<VR::DS>::Type Type;
4888 enum : long long { VRType = VR::DS };
4889 enum { VMType = VM::VM1 };
4890 static const char* GetVMString() { return "1"; }
4891 };
4892 template <> struct TagToType<0x0018,0x1111> {
4893 static const char* GetVRString() { return "DS"; }
4894 typedef VRToType<VR::DS>::Type Type;
4895 enum : long long { VRType = VR::DS };
4896 enum { VMType = VM::VM1 };
4897 static const char* GetVMString() { return "1"; }
4898 };
4899 template <> struct TagToType<0x0018,0x1114> {
4900 static const char* GetVRString() { return "DS"; }
4901 typedef VRToType<VR::DS>::Type Type;
4902 enum : long long { VRType = VR::DS };
4903 enum { VMType = VM::VM1 };
4904 static const char* GetVMString() { return "1"; }
4905 };
4906 template <> struct TagToType<0x0018,0x1120> {
4907 static const char* GetVRString() { return "DS"; }
4908 typedef VRToType<VR::DS>::Type Type;
4909 enum : long long { VRType = VR::DS };
4910 enum { VMType = VM::VM1 };
4911 static const char* GetVMString() { return "1"; }
4912 };
4913 template <> struct TagToType<0x0018,0x1121> {
4914 static const char* GetVRString() { return "DS"; }
4915 typedef VRToType<VR::DS>::Type Type;
4916 enum : long long { VRType = VR::DS };
4917 enum { VMType = VM::VM1 };
4918 static const char* GetVMString() { return "1"; }
4919 };
4920 template <> struct TagToType<0x0018,0x1130> {
4921 static const char* GetVRString() { return "DS"; }
4922 typedef VRToType<VR::DS>::Type Type;
4923 enum : long long { VRType = VR::DS };
4924 enum { VMType = VM::VM1 };
4925 static const char* GetVMString() { return "1"; }
4926 };
4927 template <> struct TagToType<0x0018,0x1131> {
4928 static const char* GetVRString() { return "DS"; }
4929 typedef VRToType<VR::DS>::Type Type;
4930 enum : long long { VRType = VR::DS };
4931 enum { VMType = VM::VM1 };
4932 static const char* GetVMString() { return "1"; }
4933 };
4934 template <> struct TagToType<0x0018,0x1134> {
4935 static const char* GetVRString() { return "CS"; }
4936 typedef VRToType<VR::CS>::Type Type;
4937 enum : long long { VRType = VR::CS };
4938 enum { VMType = VM::VM1 };
4939 static const char* GetVMString() { return "1"; }
4940 };
4941 template <> struct TagToType<0x0018,0x1135> {
4942 static const char* GetVRString() { return "DS"; }
4943 typedef VRToType<VR::DS>::Type Type;
4944 enum : long long { VRType = VR::DS };
4945 enum { VMType = VM::VM1_n };
4946 static const char* GetVMString() { return "1-n"; }
4947 };
4948 template <> struct TagToType<0x0018,0x1136> {
4949 static const char* GetVRString() { return "DS"; }
4950 typedef VRToType<VR::DS>::Type Type;
4951 enum : long long { VRType = VR::DS };
4952 enum { VMType = VM::VM1_n };
4953 static const char* GetVMString() { return "1-n"; }
4954 };
4955 template <> struct TagToType<0x0018,0x1137> {
4956 static const char* GetVRString() { return "DS"; }
4957 typedef VRToType<VR::DS>::Type Type;
4958 enum : long long { VRType = VR::DS };
4959 enum { VMType = VM::VM1_n };
4960 static const char* GetVMString() { return "1-n"; }
4961 };
4962 template <> struct TagToType<0x0018,0x1138> {
4963 static const char* GetVRString() { return "DS"; }
4964 typedef VRToType<VR::DS>::Type Type;
4965 enum : long long { VRType = VR::DS };
4966 enum { VMType = VM::VM1 };
4967 static const char* GetVMString() { return "1"; }
4968 };
4969 template <> struct TagToType<0x0018,0x113a> {
4970 static const char* GetVRString() { return "CS"; }
4971 typedef VRToType<VR::CS>::Type Type;
4972 enum : long long { VRType = VR::CS };
4973 enum { VMType = VM::VM1 };
4974 static const char* GetVMString() { return "1"; }
4975 };
4976 template <> struct TagToType<0x0018,0x1140> {
4977 static const char* GetVRString() { return "CS"; }
4978 typedef VRToType<VR::CS>::Type Type;
4979 enum : long long { VRType = VR::CS };
4980 enum { VMType = VM::VM1 };
4981 static const char* GetVMString() { return "1"; }
4982 };
4983 template <> struct TagToType<0x0018,0x1141> {
4984 static const char* GetVRString() { return "DS"; }
4985 typedef VRToType<VR::DS>::Type Type;
4986 enum : long long { VRType = VR::DS };
4987 enum { VMType = VM::VM1 };
4988 static const char* GetVMString() { return "1"; }
4989 };
4990 template <> struct TagToType<0x0018,0x1142> {
4991 static const char* GetVRString() { return "DS"; }
4992 typedef VRToType<VR::DS>::Type Type;
4993 enum : long long { VRType = VR::DS };
4994 enum { VMType = VM::VM1_n };
4995 static const char* GetVMString() { return "1-n"; }
4996 };
4997 template <> struct TagToType<0x0018,0x1143> {
4998 static const char* GetVRString() { return "DS"; }
4999 typedef VRToType<VR::DS>::Type Type;
5000 enum : long long { VRType = VR::DS };
5001 enum { VMType = VM::VM1 };
5002 static const char* GetVMString() { return "1"; }
5003 };
5004 template <> struct TagToType<0x0018,0x1144> {
5005 static const char* GetVRString() { return "DS"; }
5006 typedef VRToType<VR::DS>::Type Type;
5007 enum : long long { VRType = VR::DS };
5008 enum { VMType = VM::VM1 };
5009 static const char* GetVMString() { return "1"; }
5010 };
5011 template <> struct TagToType<0x0018,0x1145> {
5012 static const char* GetVRString() { return "DS"; }
5013 typedef VRToType<VR::DS>::Type Type;
5014 enum : long long { VRType = VR::DS };
5015 enum { VMType = VM::VM1 };
5016 static const char* GetVMString() { return "1"; }
5017 };
5018 template <> struct TagToType<0x0018,0x1146> {
5019 static const char* GetVRString() { return "DS"; }
5020 typedef VRToType<VR::DS>::Type Type;
5021 enum : long long { VRType = VR::DS };
5022 enum { VMType = VM::VM1_n };
5023 static const char* GetVMString() { return "1-n"; }
5024 };
5025 template <> struct TagToType<0x0018,0x1147> {
5026 static const char* GetVRString() { return "CS"; }
5027 typedef VRToType<VR::CS>::Type Type;
5028 enum : long long { VRType = VR::CS };
5029 enum { VMType = VM::VM1 };
5030 static const char* GetVMString() { return "1"; }
5031 };
5032 template <> struct TagToType<0x0018,0x1149> {
5033 static const char* GetVRString() { return "IS"; }
5034 typedef VRToType<VR::IS>::Type Type;
5035 enum : long long { VRType = VR::IS };
5036 enum { VMType = VM::VM1_2 };
5037 static const char* GetVMString() { return "1-2"; }
5038 };
5039 template <> struct TagToType<0x0018,0x1150> {
5040 static const char* GetVRString() { return "IS"; }
5041 typedef VRToType<VR::IS>::Type Type;
5042 enum : long long { VRType = VR::IS };
5043 enum { VMType = VM::VM1 };
5044 static const char* GetVMString() { return "1"; }
5045 };
5046 template <> struct TagToType<0x0018,0x1151> {
5047 static const char* GetVRString() { return "IS"; }
5048 typedef VRToType<VR::IS>::Type Type;
5049 enum : long long { VRType = VR::IS };
5050 enum { VMType = VM::VM1 };
5051 static const char* GetVMString() { return "1"; }
5052 };
5053 template <> struct TagToType<0x0018,0x1152> {
5054 static const char* GetVRString() { return "IS"; }
5055 typedef VRToType<VR::IS>::Type Type;
5056 enum : long long { VRType = VR::IS };
5057 enum { VMType = VM::VM1 };
5058 static const char* GetVMString() { return "1"; }
5059 };
5060 template <> struct TagToType<0x0018,0x1153> {
5061 static const char* GetVRString() { return "IS"; }
5062 typedef VRToType<VR::IS>::Type Type;
5063 enum : long long { VRType = VR::IS };
5064 enum { VMType = VM::VM1 };
5065 static const char* GetVMString() { return "1"; }
5066 };
5067 template <> struct TagToType<0x0018,0x1154> {
5068 static const char* GetVRString() { return "DS"; }
5069 typedef VRToType<VR::DS>::Type Type;
5070 enum : long long { VRType = VR::DS };
5071 enum { VMType = VM::VM1 };
5072 static const char* GetVMString() { return "1"; }
5073 };
5074 template <> struct TagToType<0x0018,0x1155> {
5075 static const char* GetVRString() { return "CS"; }
5076 typedef VRToType<VR::CS>::Type Type;
5077 enum : long long { VRType = VR::CS };
5078 enum { VMType = VM::VM1 };
5079 static const char* GetVMString() { return "1"; }
5080 };
5081 template <> struct TagToType<0x0018,0x1156> {
5082 static const char* GetVRString() { return "CS"; }
5083 typedef VRToType<VR::CS>::Type Type;
5084 enum : long long { VRType = VR::CS };
5085 enum { VMType = VM::VM1 };
5086 static const char* GetVMString() { return "1"; }
5087 };
5088 template <> struct TagToType<0x0018,0x115a> {
5089 static const char* GetVRString() { return "CS"; }
5090 typedef VRToType<VR::CS>::Type Type;
5091 enum : long long { VRType = VR::CS };
5092 enum { VMType = VM::VM1 };
5093 static const char* GetVMString() { return "1"; }
5094 };
5095 template <> struct TagToType<0x0018,0x115e> {
5096 static const char* GetVRString() { return "DS"; }
5097 typedef VRToType<VR::DS>::Type Type;
5098 enum : long long { VRType = VR::DS };
5099 enum { VMType = VM::VM1 };
5100 static const char* GetVMString() { return "1"; }
5101 };
5102 template <> struct TagToType<0x0018,0x1160> {
5103 static const char* GetVRString() { return "SH"; }
5104 typedef VRToType<VR::SH>::Type Type;
5105 enum : long long { VRType = VR::SH };
5106 enum { VMType = VM::VM1 };
5107 static const char* GetVMString() { return "1"; }
5108 };
5109 template <> struct TagToType<0x0018,0x1161> {
5110 static const char* GetVRString() { return "LO"; }
5111 typedef VRToType<VR::LO>::Type Type;
5112 enum : long long { VRType = VR::LO };
5113 enum { VMType = VM::VM1_n };
5114 static const char* GetVMString() { return "1-n"; }
5115 };
5116 template <> struct TagToType<0x0018,0x1162> {
5117 static const char* GetVRString() { return "DS"; }
5118 typedef VRToType<VR::DS>::Type Type;
5119 enum : long long { VRType = VR::DS };
5120 enum { VMType = VM::VM1 };
5121 static const char* GetVMString() { return "1"; }
5122 };
5123 template <> struct TagToType<0x0018,0x1164> {
5124 static const char* GetVRString() { return "DS"; }
5125 typedef VRToType<VR::DS>::Type Type;
5126 enum : long long { VRType = VR::DS };
5127 enum { VMType = VM::VM2 };
5128 static const char* GetVMString() { return "2"; }
5129 };
5130 template <> struct TagToType<0x0018,0x1166> {
5131 static const char* GetVRString() { return "CS"; }
5132 typedef VRToType<VR::CS>::Type Type;
5133 enum : long long { VRType = VR::CS };
5134 enum { VMType = VM::VM1_n };
5135 static const char* GetVMString() { return "1-n"; }
5136 };
5137 template <> struct TagToType<0x0018,0x1170> {
5138 static const char* GetVRString() { return "IS"; }
5139 typedef VRToType<VR::IS>::Type Type;
5140 enum : long long { VRType = VR::IS };
5141 enum { VMType = VM::VM1 };
5142 static const char* GetVMString() { return "1"; }
5143 };
5144 template <> struct TagToType<0x0018,0x1180> {
5145 static const char* GetVRString() { return "SH"; }
5146 typedef VRToType<VR::SH>::Type Type;
5147 enum : long long { VRType = VR::SH };
5148 enum { VMType = VM::VM1 };
5149 static const char* GetVMString() { return "1"; }
5150 };
5151 template <> struct TagToType<0x0018,0x1181> {
5152 static const char* GetVRString() { return "CS"; }
5153 typedef VRToType<VR::CS>::Type Type;
5154 enum : long long { VRType = VR::CS };
5155 enum { VMType = VM::VM1 };
5156 static const char* GetVMString() { return "1"; }
5157 };
5158 template <> struct TagToType<0x0018,0x1182> {
5159 static const char* GetVRString() { return "IS"; }
5160 typedef VRToType<VR::IS>::Type Type;
5161 enum : long long { VRType = VR::IS };
5162 enum { VMType = VM::VM1_2 };
5163 static const char* GetVMString() { return "1-2"; }
5164 };
5165 template <> struct TagToType<0x0018,0x1183> {
5166 static const char* GetVRString() { return "DS"; }
5167 typedef VRToType<VR::DS>::Type Type;
5168 enum : long long { VRType = VR::DS };
5169 enum { VMType = VM::VM1_2 };
5170 static const char* GetVMString() { return "1-2"; }
5171 };
5172 template <> struct TagToType<0x0018,0x1184> {
5173 static const char* GetVRString() { return "DS"; }
5174 typedef VRToType<VR::DS>::Type Type;
5175 enum : long long { VRType = VR::DS };
5176 enum { VMType = VM::VM1_2 };
5177 static const char* GetVMString() { return "1-2"; }
5178 };
5179 template <> struct TagToType<0x0018,0x1190> {
5180 static const char* GetVRString() { return "DS"; }
5181 typedef VRToType<VR::DS>::Type Type;
5182 enum : long long { VRType = VR::DS };
5183 enum { VMType = VM::VM1_n };
5184 static const char* GetVMString() { return "1-n"; }
5185 };
5186 template <> struct TagToType<0x0018,0x1191> {
5187 static const char* GetVRString() { return "CS"; }
5188 typedef VRToType<VR::CS>::Type Type;
5189 enum : long long { VRType = VR::CS };
5190 enum { VMType = VM::VM1 };
5191 static const char* GetVMString() { return "1"; }
5192 };
5193 template <> struct TagToType<0x0018,0x11a0> {
5194 static const char* GetVRString() { return "DS"; }
5195 typedef VRToType<VR::DS>::Type Type;
5196 enum : long long { VRType = VR::DS };
5197 enum { VMType = VM::VM1 };
5198 static const char* GetVMString() { return "1"; }
5199 };
5200 template <> struct TagToType<0x0018,0x11a2> {
5201 static const char* GetVRString() { return "DS"; }
5202 typedef VRToType<VR::DS>::Type Type;
5203 enum : long long { VRType = VR::DS };
5204 enum { VMType = VM::VM1 };
5205 static const char* GetVMString() { return "1"; }
5206 };
5207 template <> struct TagToType<0x0018,0x11a4> {
5208 static const char* GetVRString() { return "LO"; }
5209 typedef VRToType<VR::LO>::Type Type;
5210 enum : long long { VRType = VR::LO };
5211 enum { VMType = VM::VM1 };
5212 static const char* GetVMString() { return "1"; }
5213 };
5214 template <> struct TagToType<0x0018,0x1200> {
5215 static const char* GetVRString() { return "DA"; }
5216 typedef VRToType<VR::DA>::Type Type;
5217 enum : long long { VRType = VR::DA };
5218 enum { VMType = VM::VM1_n };
5219 static const char* GetVMString() { return "1-n"; }
5220 };
5221 template <> struct TagToType<0x0018,0x1201> {
5222 static const char* GetVRString() { return "TM"; }
5223 typedef VRToType<VR::TM>::Type Type;
5224 enum : long long { VRType = VR::TM };
5225 enum { VMType = VM::VM1_n };
5226 static const char* GetVMString() { return "1-n"; }
5227 };
5228 template <> struct TagToType<0x0018,0x1202> {
5229 static const char* GetVRString() { return "DT"; }
5230 typedef VRToType<VR::DT>::Type Type;
5231 enum : long long { VRType = VR::DT };
5232 enum { VMType = VM::VM1 };
5233 static const char* GetVMString() { return "1"; }
5234 };
5235 template <> struct TagToType<0x0018,0x1210> {
5236 static const char* GetVRString() { return "SH"; }
5237 typedef VRToType<VR::SH>::Type Type;
5238 enum : long long { VRType = VR::SH };
5239 enum { VMType = VM::VM1_n };
5240 static const char* GetVMString() { return "1-n"; }
5241 };
5242 template <> struct TagToType<0x0018,0x1240> {
5243 static const char* GetVRString() { return "IS"; }
5244 typedef VRToType<VR::IS>::Type Type;
5245 enum : long long { VRType = VR::IS };
5246 enum { VMType = VM::VM1_n };
5247 static const char* GetVMString() { return "1-n"; }
5248 };
5249 template <> struct TagToType<0x0018,0x1242> {
5250 static const char* GetVRString() { return "IS"; }
5251 typedef VRToType<VR::IS>::Type Type;
5252 enum : long long { VRType = VR::IS };
5253 enum { VMType = VM::VM1 };
5254 static const char* GetVMString() { return "1"; }
5255 };
5256 template <> struct TagToType<0x0018,0x1243> {
5257 static const char* GetVRString() { return "IS"; }
5258 typedef VRToType<VR::IS>::Type Type;
5259 enum : long long { VRType = VR::IS };
5260 enum { VMType = VM::VM1 };
5261 static const char* GetVMString() { return "1"; }
5262 };
5263 template <> struct TagToType<0x0018,0x1244> {
5264 static const char* GetVRString() { return "US"; }
5265 typedef VRToType<VR::US>::Type Type;
5266 enum : long long { VRType = VR::US };
5267 enum { VMType = VM::VM1 };
5268 static const char* GetVMString() { return "1"; }
5269 };
5270 template <> struct TagToType<0x0018,0x1250> {
5271 static const char* GetVRString() { return "SH"; }
5272 typedef VRToType<VR::SH>::Type Type;
5273 enum : long long { VRType = VR::SH };
5274 enum { VMType = VM::VM1 };
5275 static const char* GetVMString() { return "1"; }
5276 };
5277 template <> struct TagToType<0x0018,0x1251> {
5278 static const char* GetVRString() { return "SH"; }
5279 typedef VRToType<VR::SH>::Type Type;
5280 enum : long long { VRType = VR::SH };
5281 enum { VMType = VM::VM1 };
5282 static const char* GetVMString() { return "1"; }
5283 };
5284 template <> struct TagToType<0x0018,0x1260> {
5285 static const char* GetVRString() { return "SH"; }
5286 typedef VRToType<VR::SH>::Type Type;
5287 enum : long long { VRType = VR::SH };
5288 enum { VMType = VM::VM1 };
5289 static const char* GetVMString() { return "1"; }
5290 };
5291 template <> struct TagToType<0x0018,0x1261> {
5292 static const char* GetVRString() { return "LO"; }
5293 typedef VRToType<VR::LO>::Type Type;
5294 enum : long long { VRType = VR::LO };
5295 enum { VMType = VM::VM1 };
5296 static const char* GetVMString() { return "1"; }
5297 };
5298 template <> struct TagToType<0x0018,0x1271> {
5299 static const char* GetVRString() { return "FD"; }
5300 typedef VRToType<VR::FD>::Type Type;
5301 enum : long long { VRType = VR::FD };
5302 enum { VMType = VM::VM1 };
5303 static const char* GetVMString() { return "1"; }
5304 };
5305 template <> struct TagToType<0x0018,0x1272> {
5306 static const char* GetVRString() { return "SQ"; }
5307 typedef VRToType<VR::SQ>::Type Type;
5308 enum : long long { VRType = VR::SQ };
5309 enum { VMType = VM::VM1 };
5310 static const char* GetVMString() { return "1"; }
5311 };
5312 template <> struct TagToType<0x0018,0x1300> {
5313 static const char* GetVRString() { return "DS"; }
5314 typedef VRToType<VR::DS>::Type Type;
5315 enum : long long { VRType = VR::DS };
5316 enum { VMType = VM::VM1 };
5317 static const char* GetVMString() { return "1"; }
5318 };
5319 template <> struct TagToType<0x0018,0x1301> {
5320 static const char* GetVRString() { return "CS"; }
5321 typedef VRToType<VR::CS>::Type Type;
5322 enum : long long { VRType = VR::CS };
5323 enum { VMType = VM::VM1_n };
5324 static const char* GetVMString() { return "1-n"; }
5325 };
5326 template <> struct TagToType<0x0018,0x1302> {
5327 static const char* GetVRString() { return "IS"; }
5328 typedef VRToType<VR::IS>::Type Type;
5329 enum : long long { VRType = VR::IS };
5330 enum { VMType = VM::VM1 };
5331 static const char* GetVMString() { return "1"; }
5332 };
5333 template <> struct TagToType<0x0018,0x1310> {
5334 static const char* GetVRString() { return "US"; }
5335 typedef VRToType<VR::US>::Type Type;
5336 enum : long long { VRType = VR::US };
5337 enum { VMType = VM::VM4 };
5338 static const char* GetVMString() { return "4"; }
5339 };
5340 template <> struct TagToType<0x0018,0x1312> {
5341 static const char* GetVRString() { return "CS"; }
5342 typedef VRToType<VR::CS>::Type Type;
5343 enum : long long { VRType = VR::CS };
5344 enum { VMType = VM::VM1 };
5345 static const char* GetVMString() { return "1"; }
5346 };
5347 template <> struct TagToType<0x0018,0x1314> {
5348 static const char* GetVRString() { return "DS"; }
5349 typedef VRToType<VR::DS>::Type Type;
5350 enum : long long { VRType = VR::DS };
5351 enum { VMType = VM::VM1 };
5352 static const char* GetVMString() { return "1"; }
5353 };
5354 template <> struct TagToType<0x0018,0x1315> {
5355 static const char* GetVRString() { return "CS"; }
5356 typedef VRToType<VR::CS>::Type Type;
5357 enum : long long { VRType = VR::CS };
5358 enum { VMType = VM::VM1 };
5359 static const char* GetVMString() { return "1"; }
5360 };
5361 template <> struct TagToType<0x0018,0x1316> {
5362 static const char* GetVRString() { return "DS"; }
5363 typedef VRToType<VR::DS>::Type Type;
5364 enum : long long { VRType = VR::DS };
5365 enum { VMType = VM::VM1 };
5366 static const char* GetVMString() { return "1"; }
5367 };
5368 template <> struct TagToType<0x0018,0x1318> {
5369 static const char* GetVRString() { return "DS"; }
5370 typedef VRToType<VR::DS>::Type Type;
5371 enum : long long { VRType = VR::DS };
5372 enum { VMType = VM::VM1 };
5373 static const char* GetVMString() { return "1"; }
5374 };
5375 template <> struct TagToType<0x0018,0x1320> {
5376 static const char* GetVRString() { return "FL"; }
5377 typedef VRToType<VR::FL>::Type Type;
5378 enum : long long { VRType = VR::FL };
5379 enum { VMType = VM::VM1 };
5380 static const char* GetVMString() { return "1"; }
5381 };
5382 template <> struct TagToType<0x0018,0x1400> {
5383 static const char* GetVRString() { return "LO"; }
5384 typedef VRToType<VR::LO>::Type Type;
5385 enum : long long { VRType = VR::LO };
5386 enum { VMType = VM::VM1 };
5387 static const char* GetVMString() { return "1"; }
5388 };
5389 template <> struct TagToType<0x0018,0x1401> {
5390 static const char* GetVRString() { return "LO"; }
5391 typedef VRToType<VR::LO>::Type Type;
5392 enum : long long { VRType = VR::LO };
5393 enum { VMType = VM::VM1 };
5394 static const char* GetVMString() { return "1"; }
5395 };
5396 template <> struct TagToType<0x0018,0x1402> {
5397 static const char* GetVRString() { return "CS"; }
5398 typedef VRToType<VR::CS>::Type Type;
5399 enum : long long { VRType = VR::CS };
5400 enum { VMType = VM::VM1 };
5401 static const char* GetVMString() { return "1"; }
5402 };
5403 template <> struct TagToType<0x0018,0x1403> {
5404 static const char* GetVRString() { return "CS"; }
5405 typedef VRToType<VR::CS>::Type Type;
5406 enum : long long { VRType = VR::CS };
5407 enum { VMType = VM::VM1 };
5408 static const char* GetVMString() { return "1"; }
5409 };
5410 template <> struct TagToType<0x0018,0x1404> {
5411 static const char* GetVRString() { return "US"; }
5412 typedef VRToType<VR::US>::Type Type;
5413 enum : long long { VRType = VR::US };
5414 enum { VMType = VM::VM1 };
5415 static const char* GetVMString() { return "1"; }
5416 };
5417 template <> struct TagToType<0x0018,0x1405> {
5418 static const char* GetVRString() { return "IS"; }
5419 typedef VRToType<VR::IS>::Type Type;
5420 enum : long long { VRType = VR::IS };
5421 enum { VMType = VM::VM1 };
5422 static const char* GetVMString() { return "1"; }
5423 };
5424 template <> struct TagToType<0x0018,0x1411> {
5425 static const char* GetVRString() { return "DS"; }
5426 typedef VRToType<VR::DS>::Type Type;
5427 enum : long long { VRType = VR::DS };
5428 enum { VMType = VM::VM1 };
5429 static const char* GetVMString() { return "1"; }
5430 };
5431 template <> struct TagToType<0x0018,0x1412> {
5432 static const char* GetVRString() { return "DS"; }
5433 typedef VRToType<VR::DS>::Type Type;
5434 enum : long long { VRType = VR::DS };
5435 enum { VMType = VM::VM1 };
5436 static const char* GetVMString() { return "1"; }
5437 };
5438 template <> struct TagToType<0x0018,0x1413> {
5439 static const char* GetVRString() { return "DS"; }
5440 typedef VRToType<VR::DS>::Type Type;
5441 enum : long long { VRType = VR::DS };
5442 enum { VMType = VM::VM1 };
5443 static const char* GetVMString() { return "1"; }
5444 };
5445 template <> struct TagToType<0x0018,0x1450> {
5446 static const char* GetVRString() { return "DS"; }
5447 typedef VRToType<VR::DS>::Type Type;
5448 enum : long long { VRType = VR::DS };
5449 enum { VMType = VM::VM1 };
5450 static const char* GetVMString() { return "1"; }
5451 };
5452 template <> struct TagToType<0x0018,0x1460> {
5453 static const char* GetVRString() { return "DS"; }
5454 typedef VRToType<VR::DS>::Type Type;
5455 enum : long long { VRType = VR::DS };
5456 enum { VMType = VM::VM1 };
5457 static const char* GetVMString() { return "1"; }
5458 };
5459 template <> struct TagToType<0x0018,0x1470> {
5460 static const char* GetVRString() { return "DS"; }
5461 typedef VRToType<VR::DS>::Type Type;
5462 enum : long long { VRType = VR::DS };
5463 enum { VMType = VM::VM1 };
5464 static const char* GetVMString() { return "1"; }
5465 };
5466 template <> struct TagToType<0x0018,0x1480> {
5467 static const char* GetVRString() { return "DS"; }
5468 typedef VRToType<VR::DS>::Type Type;
5469 enum : long long { VRType = VR::DS };
5470 enum { VMType = VM::VM1 };
5471 static const char* GetVMString() { return "1"; }
5472 };
5473 template <> struct TagToType<0x0018,0x1490> {
5474 static const char* GetVRString() { return "CS"; }
5475 typedef VRToType<VR::CS>::Type Type;
5476 enum : long long { VRType = VR::CS };
5477 enum { VMType = VM::VM1 };
5478 static const char* GetVMString() { return "1"; }
5479 };
5480 template <> struct TagToType<0x0018,0x1491> {
5481 static const char* GetVRString() { return "CS"; }
5482 typedef VRToType<VR::CS>::Type Type;
5483 enum : long long { VRType = VR::CS };
5484 enum { VMType = VM::VM1 };
5485 static const char* GetVMString() { return "1"; }
5486 };
5487 template <> struct TagToType<0x0018,0x1495> {
5488 static const char* GetVRString() { return "IS"; }
5489 typedef VRToType<VR::IS>::Type Type;
5490 enum : long long { VRType = VR::IS };
5491 enum { VMType = VM::VM1 };
5492 static const char* GetVMString() { return "1"; }
5493 };
5494 template <> struct TagToType<0x0018,0x1500> {
5495 static const char* GetVRString() { return "CS"; }
5496 typedef VRToType<VR::CS>::Type Type;
5497 enum : long long { VRType = VR::CS };
5498 enum { VMType = VM::VM1 };
5499 static const char* GetVMString() { return "1"; }
5500 };
5501 template <> struct TagToType<0x0018,0x1508> {
5502 static const char* GetVRString() { return "CS"; }
5503 typedef VRToType<VR::CS>::Type Type;
5504 enum : long long { VRType = VR::CS };
5505 enum { VMType = VM::VM1 };
5506 static const char* GetVMString() { return "1"; }
5507 };
5508 template <> struct TagToType<0x0018,0x1510> {
5509 static const char* GetVRString() { return "DS"; }
5510 typedef VRToType<VR::DS>::Type Type;
5511 enum : long long { VRType = VR::DS };
5512 enum { VMType = VM::VM1 };
5513 static const char* GetVMString() { return "1"; }
5514 };
5515 template <> struct TagToType<0x0018,0x1511> {
5516 static const char* GetVRString() { return "DS"; }
5517 typedef VRToType<VR::DS>::Type Type;
5518 enum : long long { VRType = VR::DS };
5519 enum { VMType = VM::VM1 };
5520 static const char* GetVMString() { return "1"; }
5521 };
5522 template <> struct TagToType<0x0018,0x1520> {
5523 static const char* GetVRString() { return "DS"; }
5524 typedef VRToType<VR::DS>::Type Type;
5525 enum : long long { VRType = VR::DS };
5526 enum { VMType = VM::VM1_n };
5527 static const char* GetVMString() { return "1-n"; }
5528 };
5529 template <> struct TagToType<0x0018,0x1521> {
5530 static const char* GetVRString() { return "DS"; }
5531 typedef VRToType<VR::DS>::Type Type;
5532 enum : long long { VRType = VR::DS };
5533 enum { VMType = VM::VM1_n };
5534 static const char* GetVMString() { return "1-n"; }
5535 };
5536 template <> struct TagToType<0x0018,0x1530> {
5537 static const char* GetVRString() { return "DS"; }
5538 typedef VRToType<VR::DS>::Type Type;
5539 enum : long long { VRType = VR::DS };
5540 enum { VMType = VM::VM1 };
5541 static const char* GetVMString() { return "1"; }
5542 };
5543 template <> struct TagToType<0x0018,0x1531> {
5544 static const char* GetVRString() { return "DS"; }
5545 typedef VRToType<VR::DS>::Type Type;
5546 enum : long long { VRType = VR::DS };
5547 enum { VMType = VM::VM1 };
5548 static const char* GetVMString() { return "1"; }
5549 };
5550 template <> struct TagToType<0x0018,0x1600> {
5551 static const char* GetVRString() { return "CS"; }
5552 typedef VRToType<VR::CS>::Type Type;
5553 enum : long long { VRType = VR::CS };
5554 enum { VMType = VM::VM1_3 };
5555 static const char* GetVMString() { return "1-3"; }
5556 };
5557 template <> struct TagToType<0x0018,0x1602> {
5558 static const char* GetVRString() { return "IS"; }
5559 typedef VRToType<VR::IS>::Type Type;
5560 enum : long long { VRType = VR::IS };
5561 enum { VMType = VM::VM1 };
5562 static const char* GetVMString() { return "1"; }
5563 };
5564 template <> struct TagToType<0x0018,0x1604> {
5565 static const char* GetVRString() { return "IS"; }
5566 typedef VRToType<VR::IS>::Type Type;
5567 enum : long long { VRType = VR::IS };
5568 enum { VMType = VM::VM1 };
5569 static const char* GetVMString() { return "1"; }
5570 };
5571 template <> struct TagToType<0x0018,0x1606> {
5572 static const char* GetVRString() { return "IS"; }
5573 typedef VRToType<VR::IS>::Type Type;
5574 enum : long long { VRType = VR::IS };
5575 enum { VMType = VM::VM1 };
5576 static const char* GetVMString() { return "1"; }
5577 };
5578 template <> struct TagToType<0x0018,0x1608> {
5579 static const char* GetVRString() { return "IS"; }
5580 typedef VRToType<VR::IS>::Type Type;
5581 enum : long long { VRType = VR::IS };
5582 enum { VMType = VM::VM1 };
5583 static const char* GetVMString() { return "1"; }
5584 };
5585 template <> struct TagToType<0x0018,0x1610> {
5586 static const char* GetVRString() { return "IS"; }
5587 typedef VRToType<VR::IS>::Type Type;
5588 enum : long long { VRType = VR::IS };
5589 enum { VMType = VM::VM2 };
5590 static const char* GetVMString() { return "2"; }
5591 };
5592 template <> struct TagToType<0x0018,0x1612> {
5593 static const char* GetVRString() { return "IS"; }
5594 typedef VRToType<VR::IS>::Type Type;
5595 enum : long long { VRType = VR::IS };
5596 enum { VMType = VM::VM1 };
5597 static const char* GetVMString() { return "1"; }
5598 };
5599 template <> struct TagToType<0x0018,0x1620> {
5600 static const char* GetVRString() { return "IS"; }
5601 typedef VRToType<VR::IS>::Type Type;
5602 enum : long long { VRType = VR::IS };
5603 enum { VMType = VM::VM2_2n };
5604 static const char* GetVMString() { return "2-2n"; }
5605 };
5606 template <> struct TagToType<0x0018,0x1622> {
5607 static const char* GetVRString() { return "US"; }
5608 typedef VRToType<VR::US>::Type Type;
5609 enum : long long { VRType = VR::US };
5610 enum { VMType = VM::VM1 };
5611 static const char* GetVMString() { return "1"; }
5612 };
5613 template <> struct TagToType<0x0018,0x1623> {
5614 static const char* GetVRString() { return "US"; }
5615 typedef VRToType<VR::US>::Type Type;
5616 enum : long long { VRType = VR::US };
5617 enum { VMType = VM::VM1 };
5618 static const char* GetVMString() { return "1"; }
5619 };
5620 template <> struct TagToType<0x0018,0x1624> {
5621 static const char* GetVRString() { return "US"; }
5622 typedef VRToType<VR::US>::Type Type;
5623 enum : long long { VRType = VR::US };
5624 enum { VMType = VM::VM3 };
5625 static const char* GetVMString() { return "3"; }
5626 };
5627 template <> struct TagToType<0x0018,0x1700> {
5628 static const char* GetVRString() { return "CS"; }
5629 typedef VRToType<VR::CS>::Type Type;
5630 enum : long long { VRType = VR::CS };
5631 enum { VMType = VM::VM1_3 };
5632 static const char* GetVMString() { return "1-3"; }
5633 };
5634 template <> struct TagToType<0x0018,0x1702> {
5635 static const char* GetVRString() { return "IS"; }
5636 typedef VRToType<VR::IS>::Type Type;
5637 enum : long long { VRType = VR::IS };
5638 enum { VMType = VM::VM1 };
5639 static const char* GetVMString() { return "1"; }
5640 };
5641 template <> struct TagToType<0x0018,0x1704> {
5642 static const char* GetVRString() { return "IS"; }
5643 typedef VRToType<VR::IS>::Type Type;
5644 enum : long long { VRType = VR::IS };
5645 enum { VMType = VM::VM1 };
5646 static const char* GetVMString() { return "1"; }
5647 };
5648 template <> struct TagToType<0x0018,0x1706> {
5649 static const char* GetVRString() { return "IS"; }
5650 typedef VRToType<VR::IS>::Type Type;
5651 enum : long long { VRType = VR::IS };
5652 enum { VMType = VM::VM1 };
5653 static const char* GetVMString() { return "1"; }
5654 };
5655 template <> struct TagToType<0x0018,0x1708> {
5656 static const char* GetVRString() { return "IS"; }
5657 typedef VRToType<VR::IS>::Type Type;
5658 enum : long long { VRType = VR::IS };
5659 enum { VMType = VM::VM1 };
5660 static const char* GetVMString() { return "1"; }
5661 };
5662 template <> struct TagToType<0x0018,0x1710> {
5663 static const char* GetVRString() { return "IS"; }
5664 typedef VRToType<VR::IS>::Type Type;
5665 enum : long long { VRType = VR::IS };
5666 enum { VMType = VM::VM2 };
5667 static const char* GetVMString() { return "2"; }
5668 };
5669 template <> struct TagToType<0x0018,0x1712> {
5670 static const char* GetVRString() { return "IS"; }
5671 typedef VRToType<VR::IS>::Type Type;
5672 enum : long long { VRType = VR::IS };
5673 enum { VMType = VM::VM1 };
5674 static const char* GetVMString() { return "1"; }
5675 };
5676 template <> struct TagToType<0x0018,0x1720> {
5677 static const char* GetVRString() { return "IS"; }
5678 typedef VRToType<VR::IS>::Type Type;
5679 enum : long long { VRType = VR::IS };
5680 enum { VMType = VM::VM2_2n };
5681 static const char* GetVMString() { return "2-2n"; }
5682 };
5683 template <> struct TagToType<0x0018,0x1800> {
5684 static const char* GetVRString() { return "CS"; }
5685 typedef VRToType<VR::CS>::Type Type;
5686 enum : long long { VRType = VR::CS };
5687 enum { VMType = VM::VM1 };
5688 static const char* GetVMString() { return "1"; }
5689 };
5690 template <> struct TagToType<0x0018,0x1801> {
5691 static const char* GetVRString() { return "SH"; }
5692 typedef VRToType<VR::SH>::Type Type;
5693 enum : long long { VRType = VR::SH };
5694 enum { VMType = VM::VM1 };
5695 static const char* GetVMString() { return "1"; }
5696 };
5697 template <> struct TagToType<0x0018,0x1802> {
5698 static const char* GetVRString() { return "CS"; }
5699 typedef VRToType<VR::CS>::Type Type;
5700 enum : long long { VRType = VR::CS };
5701 enum { VMType = VM::VM1 };
5702 static const char* GetVMString() { return "1"; }
5703 };
5704 template <> struct TagToType<0x0018,0x1803> {
5705 static const char* GetVRString() { return "LO"; }
5706 typedef VRToType<VR::LO>::Type Type;
5707 enum : long long { VRType = VR::LO };
5708 enum { VMType = VM::VM1 };
5709 static const char* GetVMString() { return "1"; }
5710 };
5711 template <> struct TagToType<0x0018,0x2001> {
5712 static const char* GetVRString() { return "IS"; }
5713 typedef VRToType<VR::IS>::Type Type;
5714 enum : long long { VRType = VR::IS };
5715 enum { VMType = VM::VM1_n };
5716 static const char* GetVMString() { return "1-n"; }
5717 };
5718 template <> struct TagToType<0x0018,0x2002> {
5719 static const char* GetVRString() { return "SH"; }
5720 typedef VRToType<VR::SH>::Type Type;
5721 enum : long long { VRType = VR::SH };
5722 enum { VMType = VM::VM1_n };
5723 static const char* GetVMString() { return "1-n"; }
5724 };
5725 template <> struct TagToType<0x0018,0x2003> {
5726 static const char* GetVRString() { return "DS"; }
5727 typedef VRToType<VR::DS>::Type Type;
5728 enum : long long { VRType = VR::DS };
5729 enum { VMType = VM::VM1_n };
5730 static const char* GetVMString() { return "1-n"; }
5731 };
5732 template <> struct TagToType<0x0018,0x2004> {
5733 static const char* GetVRString() { return "DS"; }
5734 typedef VRToType<VR::DS>::Type Type;
5735 enum : long long { VRType = VR::DS };
5736 enum { VMType = VM::VM1_n };
5737 static const char* GetVMString() { return "1-n"; }
5738 };
5739 template <> struct TagToType<0x0018,0x2005> {
5740 static const char* GetVRString() { return "DS"; }
5741 typedef VRToType<VR::DS>::Type Type;
5742 enum : long long { VRType = VR::DS };
5743 enum { VMType = VM::VM1_n };
5744 static const char* GetVMString() { return "1-n"; }
5745 };
5746 template <> struct TagToType<0x0018,0x2006> {
5747 static const char* GetVRString() { return "SH"; }
5748 typedef VRToType<VR::SH>::Type Type;
5749 enum : long long { VRType = VR::SH };
5750 enum { VMType = VM::VM1_n };
5751 static const char* GetVMString() { return "1-n"; }
5752 };
5753 template <> struct TagToType<0x0018,0x2010> {
5754 static const char* GetVRString() { return "DS"; }
5755 typedef VRToType<VR::DS>::Type Type;
5756 enum : long long { VRType = VR::DS };
5757 enum { VMType = VM::VM2 };
5758 static const char* GetVMString() { return "2"; }
5759 };
5760 template <> struct TagToType<0x0018,0x2020> {
5761 static const char* GetVRString() { return "CS"; }
5762 typedef VRToType<VR::CS>::Type Type;
5763 enum : long long { VRType = VR::CS };
5764 enum { VMType = VM::VM1 };
5765 static const char* GetVMString() { return "1"; }
5766 };
5767 template <> struct TagToType<0x0018,0x2030> {
5768 static const char* GetVRString() { return "DS"; }
5769 typedef VRToType<VR::DS>::Type Type;
5770 enum : long long { VRType = VR::DS };
5771 enum { VMType = VM::VM1 };
5772 static const char* GetVMString() { return "1"; }
5773 };
5774 template <> struct TagToType<0x0018,0x2041> {
5775 static const char* GetVRString() { return "SQ"; }
5776 typedef VRToType<VR::SQ>::Type Type;
5777 enum : long long { VRType = VR::SQ };
5778 enum { VMType = VM::VM1 };
5779 static const char* GetVMString() { return "1"; }
5780 };
5781 template <> struct TagToType<0x0018,0x2042> {
5782 static const char* GetVRString() { return "UI"; }
5783 typedef VRToType<VR::UI>::Type Type;
5784 enum : long long { VRType = VR::UI };
5785 enum { VMType = VM::VM1 };
5786 static const char* GetVMString() { return "1"; }
5787 };
5788 template <> struct TagToType<0x0018,0x2043> {
5789 static const char* GetVRString() { return "FL"; }
5790 typedef VRToType<VR::FL>::Type Type;
5791 enum : long long { VRType = VR::FL };
5792 enum { VMType = VM::VM2 };
5793 static const char* GetVMString() { return "2"; }
5794 };
5795 template <> struct TagToType<0x0018,0x2044> {
5796 static const char* GetVRString() { return "FL"; }
5797 typedef VRToType<VR::FL>::Type Type;
5798 enum : long long { VRType = VR::FL };
5799 enum { VMType = VM::VM3 };
5800 static const char* GetVMString() { return "3"; }
5801 };
5802 template <> struct TagToType<0x0018,0x2045> {
5803 static const char* GetVRString() { return "SH"; }
5804 typedef VRToType<VR::SH>::Type Type;
5805 enum : long long { VRType = VR::SH };
5806 enum { VMType = VM::VM1 };
5807 static const char* GetVMString() { return "1"; }
5808 };
5809 template <> struct TagToType<0x0018,0x2046> {
5810 static const char* GetVRString() { return "FL"; }
5811 typedef VRToType<VR::FL>::Type Type;
5812 enum : long long { VRType = VR::FL };
5813 enum { VMType = VM::VM1 };
5814 static const char* GetVMString() { return "1"; }
5815 };
5816 template <> struct TagToType<0x0018,0x3100> {
5817 static const char* GetVRString() { return "CS"; }
5818 typedef VRToType<VR::CS>::Type Type;
5819 enum : long long { VRType = VR::CS };
5820 enum { VMType = VM::VM1 };
5821 static const char* GetVMString() { return "1"; }
5822 };
5823 template <> struct TagToType<0x0018,0x3101> {
5824 static const char* GetVRString() { return "DS"; }
5825 typedef VRToType<VR::DS>::Type Type;
5826 enum : long long { VRType = VR::DS };
5827 enum { VMType = VM::VM1 };
5828 static const char* GetVMString() { return "1"; }
5829 };
5830 template <> struct TagToType<0x0018,0x3102> {
5831 static const char* GetVRString() { return "DS"; }
5832 typedef VRToType<VR::DS>::Type Type;
5833 enum : long long { VRType = VR::DS };
5834 enum { VMType = VM::VM1 };
5835 static const char* GetVMString() { return "1"; }
5836 };
5837 template <> struct TagToType<0x0018,0x3103> {
5838 static const char* GetVRString() { return "IS"; }
5839 typedef VRToType<VR::IS>::Type Type;
5840 enum : long long { VRType = VR::IS };
5841 enum { VMType = VM::VM1 };
5842 static const char* GetVMString() { return "1"; }
5843 };
5844 template <> struct TagToType<0x0018,0x3104> {
5845 static const char* GetVRString() { return "IS"; }
5846 typedef VRToType<VR::IS>::Type Type;
5847 enum : long long { VRType = VR::IS };
5848 enum { VMType = VM::VM1 };
5849 static const char* GetVMString() { return "1"; }
5850 };
5851 template <> struct TagToType<0x0018,0x3105> {
5852 static const char* GetVRString() { return "IS"; }
5853 typedef VRToType<VR::IS>::Type Type;
5854 enum : long long { VRType = VR::IS };
5855 enum { VMType = VM::VM1_n };
5856 static const char* GetVMString() { return "1-n"; }
5857 };
5858 template <> struct TagToType<0x0018,0x4000> {
5859 static const char* GetVRString() { return "LT"; }
5860 typedef VRToType<VR::LT>::Type Type;
5861 enum : long long { VRType = VR::LT };
5862 enum { VMType = VM::VM1 };
5863 static const char* GetVMString() { return "1"; }
5864 };
5865 template <> struct TagToType<0x0018,0x5000> {
5866 static const char* GetVRString() { return "SH"; }
5867 typedef VRToType<VR::SH>::Type Type;
5868 enum : long long { VRType = VR::SH };
5869 enum { VMType = VM::VM1_n };
5870 static const char* GetVMString() { return "1-n"; }
5871 };
5872 template <> struct TagToType<0x0018,0x5010> {
5873 static const char* GetVRString() { return "LO"; }
5874 typedef VRToType<VR::LO>::Type Type;
5875 enum : long long { VRType = VR::LO };
5876 enum { VMType = VM::VM1_n };
5877 static const char* GetVMString() { return "1-n"; }
5878 };
5879 template <> struct TagToType<0x0018,0x5012> {
5880 static const char* GetVRString() { return "DS"; }
5881 typedef VRToType<VR::DS>::Type Type;
5882 enum : long long { VRType = VR::DS };
5883 enum { VMType = VM::VM1 };
5884 static const char* GetVMString() { return "1"; }
5885 };
5886 template <> struct TagToType<0x0018,0x5020> {
5887 static const char* GetVRString() { return "LO"; }
5888 typedef VRToType<VR::LO>::Type Type;
5889 enum : long long { VRType = VR::LO };
5890 enum { VMType = VM::VM1 };
5891 static const char* GetVMString() { return "1"; }
5892 };
5893 template <> struct TagToType<0x0018,0x5021> {
5894 static const char* GetVRString() { return "LO"; }
5895 typedef VRToType<VR::LO>::Type Type;
5896 enum : long long { VRType = VR::LO };
5897 enum { VMType = VM::VM1 };
5898 static const char* GetVMString() { return "1"; }
5899 };
5900 template <> struct TagToType<0x0018,0x5022> {
5901 static const char* GetVRString() { return "DS"; }
5902 typedef VRToType<VR::DS>::Type Type;
5903 enum : long long { VRType = VR::DS };
5904 enum { VMType = VM::VM1 };
5905 static const char* GetVMString() { return "1"; }
5906 };
5907 template <> struct TagToType<0x0018,0x5024> {
5908 static const char* GetVRString() { return "DS"; }
5909 typedef VRToType<VR::DS>::Type Type;
5910 enum : long long { VRType = VR::DS };
5911 enum { VMType = VM::VM1 };
5912 static const char* GetVMString() { return "1"; }
5913 };
5914 template <> struct TagToType<0x0018,0x5026> {
5915 static const char* GetVRString() { return "DS"; }
5916 typedef VRToType<VR::DS>::Type Type;
5917 enum : long long { VRType = VR::DS };
5918 enum { VMType = VM::VM1 };
5919 static const char* GetVMString() { return "1"; }
5920 };
5921 template <> struct TagToType<0x0018,0x5027> {
5922 static const char* GetVRString() { return "DS"; }
5923 typedef VRToType<VR::DS>::Type Type;
5924 enum : long long { VRType = VR::DS };
5925 enum { VMType = VM::VM1 };
5926 static const char* GetVMString() { return "1"; }
5927 };
5928 template <> struct TagToType<0x0018,0x5028> {
5929 static const char* GetVRString() { return "DS"; }
5930 typedef VRToType<VR::DS>::Type Type;
5931 enum : long long { VRType = VR::DS };
5932 enum { VMType = VM::VM1 };
5933 static const char* GetVMString() { return "1"; }
5934 };
5935 template <> struct TagToType<0x0018,0x5029> {
5936 static const char* GetVRString() { return "DS"; }
5937 typedef VRToType<VR::DS>::Type Type;
5938 enum : long long { VRType = VR::DS };
5939 enum { VMType = VM::VM1 };
5940 static const char* GetVMString() { return "1"; }
5941 };
5942 template <> struct TagToType<0x0018,0x5030> {
5943 static const char* GetVRString() { return "DS"; }
5944 typedef VRToType<VR::DS>::Type Type;
5945 enum : long long { VRType = VR::DS };
5946 enum { VMType = VM::VM1 };
5947 static const char* GetVMString() { return "1"; }
5948 };
5949 template <> struct TagToType<0x0018,0x5040> {
5950 static const char* GetVRString() { return "DS"; }
5951 typedef VRToType<VR::DS>::Type Type;
5952 enum : long long { VRType = VR::DS };
5953 enum { VMType = VM::VM1 };
5954 static const char* GetVMString() { return "1"; }
5955 };
5956 template <> struct TagToType<0x0018,0x5050> {
5957 static const char* GetVRString() { return "IS"; }
5958 typedef VRToType<VR::IS>::Type Type;
5959 enum : long long { VRType = VR::IS };
5960 enum { VMType = VM::VM1 };
5961 static const char* GetVMString() { return "1"; }
5962 };
5963 template <> struct TagToType<0x0018,0x5100> {
5964 static const char* GetVRString() { return "CS"; }
5965 typedef VRToType<VR::CS>::Type Type;
5966 enum : long long { VRType = VR::CS };
5967 enum { VMType = VM::VM1 };
5968 static const char* GetVMString() { return "1"; }
5969 };
5970 template <> struct TagToType<0x0018,0x5101> {
5971 static const char* GetVRString() { return "CS"; }
5972 typedef VRToType<VR::CS>::Type Type;
5973 enum : long long { VRType = VR::CS };
5974 enum { VMType = VM::VM1 };
5975 static const char* GetVMString() { return "1"; }
5976 };
5977 template <> struct TagToType<0x0018,0x5104> {
5978 static const char* GetVRString() { return "SQ"; }
5979 typedef VRToType<VR::SQ>::Type Type;
5980 enum : long long { VRType = VR::SQ };
5981 enum { VMType = VM::VM1 };
5982 static const char* GetVMString() { return "1"; }
5983 };
5984 template <> struct TagToType<0x0018,0x5210> {
5985 static const char* GetVRString() { return "DS"; }
5986 typedef VRToType<VR::DS>::Type Type;
5987 enum : long long { VRType = VR::DS };
5988 enum { VMType = VM::VM6 };
5989 static const char* GetVMString() { return "6"; }
5990 };
5991 template <> struct TagToType<0x0018,0x5212> {
5992 static const char* GetVRString() { return "DS"; }
5993 typedef VRToType<VR::DS>::Type Type;
5994 enum : long long { VRType = VR::DS };
5995 enum { VMType = VM::VM3 };
5996 static const char* GetVMString() { return "3"; }
5997 };
5998 template <> struct TagToType<0x0018,0x6000> {
5999 static const char* GetVRString() { return "DS"; }
6000 typedef VRToType<VR::DS>::Type Type;
6001 enum : long long { VRType = VR::DS };
6002 enum { VMType = VM::VM1 };
6003 static const char* GetVMString() { return "1"; }
6004 };
6005 template <> struct TagToType<0x0018,0x6011> {
6006 static const char* GetVRString() { return "SQ"; }
6007 typedef VRToType<VR::SQ>::Type Type;
6008 enum : long long { VRType = VR::SQ };
6009 enum { VMType = VM::VM1 };
6010 static const char* GetVMString() { return "1"; }
6011 };
6012 template <> struct TagToType<0x0018,0x6012> {
6013 static const char* GetVRString() { return "US"; }
6014 typedef VRToType<VR::US>::Type Type;
6015 enum : long long { VRType = VR::US };
6016 enum { VMType = VM::VM1 };
6017 static const char* GetVMString() { return "1"; }
6018 };
6019 template <> struct TagToType<0x0018,0x6014> {
6020 static const char* GetVRString() { return "US"; }
6021 typedef VRToType<VR::US>::Type Type;
6022 enum : long long { VRType = VR::US };
6023 enum { VMType = VM::VM1 };
6024 static const char* GetVMString() { return "1"; }
6025 };
6026 template <> struct TagToType<0x0018,0x6016> {
6027 static const char* GetVRString() { return "UL"; }
6028 typedef VRToType<VR::UL>::Type Type;
6029 enum : long long { VRType = VR::UL };
6030 enum { VMType = VM::VM1 };
6031 static const char* GetVMString() { return "1"; }
6032 };
6033 template <> struct TagToType<0x0018,0x6018> {
6034 static const char* GetVRString() { return "UL"; }
6035 typedef VRToType<VR::UL>::Type Type;
6036 enum : long long { VRType = VR::UL };
6037 enum { VMType = VM::VM1 };
6038 static const char* GetVMString() { return "1"; }
6039 };
6040 template <> struct TagToType<0x0018,0x601a> {
6041 static const char* GetVRString() { return "UL"; }
6042 typedef VRToType<VR::UL>::Type Type;
6043 enum : long long { VRType = VR::UL };
6044 enum { VMType = VM::VM1 };
6045 static const char* GetVMString() { return "1"; }
6046 };
6047 template <> struct TagToType<0x0018,0x601c> {
6048 static const char* GetVRString() { return "UL"; }
6049 typedef VRToType<VR::UL>::Type Type;
6050 enum : long long { VRType = VR::UL };
6051 enum { VMType = VM::VM1 };
6052 static const char* GetVMString() { return "1"; }
6053 };
6054 template <> struct TagToType<0x0018,0x601e> {
6055 static const char* GetVRString() { return "UL"; }
6056 typedef VRToType<VR::UL>::Type Type;
6057 enum : long long { VRType = VR::UL };
6058 enum { VMType = VM::VM1 };
6059 static const char* GetVMString() { return "1"; }
6060 };
6061 template <> struct TagToType<0x0018,0x6020> {
6062 static const char* GetVRString() { return "SL"; }
6063 typedef VRToType<VR::SL>::Type Type;
6064 enum : long long { VRType = VR::SL };
6065 enum { VMType = VM::VM1 };
6066 static const char* GetVMString() { return "1"; }
6067 };
6068 template <> struct TagToType<0x0018,0x6022> {
6069 static const char* GetVRString() { return "SL"; }
6070 typedef VRToType<VR::SL>::Type Type;
6071 enum : long long { VRType = VR::SL };
6072 enum { VMType = VM::VM1 };
6073 static const char* GetVMString() { return "1"; }
6074 };
6075 template <> struct TagToType<0x0018,0x6024> {
6076 static const char* GetVRString() { return "US"; }
6077 typedef VRToType<VR::US>::Type Type;
6078 enum : long long { VRType = VR::US };
6079 enum { VMType = VM::VM1 };
6080 static const char* GetVMString() { return "1"; }
6081 };
6082 template <> struct TagToType<0x0018,0x6026> {
6083 static const char* GetVRString() { return "US"; }
6084 typedef VRToType<VR::US>::Type Type;
6085 enum : long long { VRType = VR::US };
6086 enum { VMType = VM::VM1 };
6087 static const char* GetVMString() { return "1"; }
6088 };
6089 template <> struct TagToType<0x0018,0x6028> {
6090 static const char* GetVRString() { return "FD"; }
6091 typedef VRToType<VR::FD>::Type Type;
6092 enum : long long { VRType = VR::FD };
6093 enum { VMType = VM::VM1 };
6094 static const char* GetVMString() { return "1"; }
6095 };
6096 template <> struct TagToType<0x0018,0x602a> {
6097 static const char* GetVRString() { return "FD"; }
6098 typedef VRToType<VR::FD>::Type Type;
6099 enum : long long { VRType = VR::FD };
6100 enum { VMType = VM::VM1 };
6101 static const char* GetVMString() { return "1"; }
6102 };
6103 template <> struct TagToType<0x0018,0x602c> {
6104 static const char* GetVRString() { return "FD"; }
6105 typedef VRToType<VR::FD>::Type Type;
6106 enum : long long { VRType = VR::FD };
6107 enum { VMType = VM::VM1 };
6108 static const char* GetVMString() { return "1"; }
6109 };
6110 template <> struct TagToType<0x0018,0x602e> {
6111 static const char* GetVRString() { return "FD"; }
6112 typedef VRToType<VR::FD>::Type Type;
6113 enum : long long { VRType = VR::FD };
6114 enum { VMType = VM::VM1 };
6115 static const char* GetVMString() { return "1"; }
6116 };
6117 template <> struct TagToType<0x0018,0x6030> {
6118 static const char* GetVRString() { return "UL"; }
6119 typedef VRToType<VR::UL>::Type Type;
6120 enum : long long { VRType = VR::UL };
6121 enum { VMType = VM::VM1 };
6122 static const char* GetVMString() { return "1"; }
6123 };
6124 template <> struct TagToType<0x0018,0x6031> {
6125 static const char* GetVRString() { return "CS"; }
6126 typedef VRToType<VR::CS>::Type Type;
6127 enum : long long { VRType = VR::CS };
6128 enum { VMType = VM::VM1 };
6129 static const char* GetVMString() { return "1"; }
6130 };
6131 template <> struct TagToType<0x0018,0x6032> {
6132 static const char* GetVRString() { return "UL"; }
6133 typedef VRToType<VR::UL>::Type Type;
6134 enum : long long { VRType = VR::UL };
6135 enum { VMType = VM::VM1 };
6136 static const char* GetVMString() { return "1"; }
6137 };
6138 template <> struct TagToType<0x0018,0x6034> {
6139 static const char* GetVRString() { return "FD"; }
6140 typedef VRToType<VR::FD>::Type Type;
6141 enum : long long { VRType = VR::FD };
6142 enum { VMType = VM::VM1 };
6143 static const char* GetVMString() { return "1"; }
6144 };
6145 template <> struct TagToType<0x0018,0x6036> {
6146 static const char* GetVRString() { return "FD"; }
6147 typedef VRToType<VR::FD>::Type Type;
6148 enum : long long { VRType = VR::FD };
6149 enum { VMType = VM::VM1 };
6150 static const char* GetVMString() { return "1"; }
6151 };
6152 template <> struct TagToType<0x0018,0x6038> {
6153 static const char* GetVRString() { return "UL"; }
6154 typedef VRToType<VR::UL>::Type Type;
6155 enum : long long { VRType = VR::UL };
6156 enum { VMType = VM::VM1 };
6157 static const char* GetVMString() { return "1"; }
6158 };
6159 template <> struct TagToType<0x0018,0x6039> {
6160 static const char* GetVRString() { return "SL"; }
6161 typedef VRToType<VR::SL>::Type Type;
6162 enum : long long { VRType = VR::SL };
6163 enum { VMType = VM::VM1 };
6164 static const char* GetVMString() { return "1"; }
6165 };
6166 template <> struct TagToType<0x0018,0x603a> {
6167 static const char* GetVRString() { return "UL"; }
6168 typedef VRToType<VR::UL>::Type Type;
6169 enum : long long { VRType = VR::UL };
6170 enum { VMType = VM::VM1 };
6171 static const char* GetVMString() { return "1"; }
6172 };
6173 template <> struct TagToType<0x0018,0x603b> {
6174 static const char* GetVRString() { return "SL"; }
6175 typedef VRToType<VR::SL>::Type Type;
6176 enum : long long { VRType = VR::SL };
6177 enum { VMType = VM::VM1 };
6178 static const char* GetVMString() { return "1"; }
6179 };
6180 template <> struct TagToType<0x0018,0x603c> {
6181 static const char* GetVRString() { return "UL"; }
6182 typedef VRToType<VR::UL>::Type Type;
6183 enum : long long { VRType = VR::UL };
6184 enum { VMType = VM::VM1 };
6185 static const char* GetVMString() { return "1"; }
6186 };
6187 template <> struct TagToType<0x0018,0x603d> {
6188 static const char* GetVRString() { return "SL"; }
6189 typedef VRToType<VR::SL>::Type Type;
6190 enum : long long { VRType = VR::SL };
6191 enum { VMType = VM::VM1 };
6192 static const char* GetVMString() { return "1"; }
6193 };
6194 template <> struct TagToType<0x0018,0x603e> {
6195 static const char* GetVRString() { return "UL"; }
6196 typedef VRToType<VR::UL>::Type Type;
6197 enum : long long { VRType = VR::UL };
6198 enum { VMType = VM::VM1 };
6199 static const char* GetVMString() { return "1"; }
6200 };
6201 template <> struct TagToType<0x0018,0x603f> {
6202 static const char* GetVRString() { return "SL"; }
6203 typedef VRToType<VR::SL>::Type Type;
6204 enum : long long { VRType = VR::SL };
6205 enum { VMType = VM::VM1 };
6206 static const char* GetVMString() { return "1"; }
6207 };
6208 template <> struct TagToType<0x0018,0x6040> {
6209 static const char* GetVRString() { return "UL"; }
6210 typedef VRToType<VR::UL>::Type Type;
6211 enum : long long { VRType = VR::UL };
6212 enum { VMType = VM::VM1 };
6213 static const char* GetVMString() { return "1"; }
6214 };
6215 template <> struct TagToType<0x0018,0x6041> {
6216 static const char* GetVRString() { return "SL"; }
6217 typedef VRToType<VR::SL>::Type Type;
6218 enum : long long { VRType = VR::SL };
6219 enum { VMType = VM::VM1 };
6220 static const char* GetVMString() { return "1"; }
6221 };
6222 template <> struct TagToType<0x0018,0x6042> {
6223 static const char* GetVRString() { return "UL"; }
6224 typedef VRToType<VR::UL>::Type Type;
6225 enum : long long { VRType = VR::UL };
6226 enum { VMType = VM::VM1 };
6227 static const char* GetVMString() { return "1"; }
6228 };
6229 template <> struct TagToType<0x0018,0x6043> {
6230 static const char* GetVRString() { return "SL"; }
6231 typedef VRToType<VR::SL>::Type Type;
6232 enum : long long { VRType = VR::SL };
6233 enum { VMType = VM::VM1 };
6234 static const char* GetVMString() { return "1"; }
6235 };
6236 template <> struct TagToType<0x0018,0x6044> {
6237 static const char* GetVRString() { return "US"; }
6238 typedef VRToType<VR::US>::Type Type;
6239 enum : long long { VRType = VR::US };
6240 enum { VMType = VM::VM1 };
6241 static const char* GetVMString() { return "1"; }
6242 };
6243 template <> struct TagToType<0x0018,0x6046> {
6244 static const char* GetVRString() { return "UL"; }
6245 typedef VRToType<VR::UL>::Type Type;
6246 enum : long long { VRType = VR::UL };
6247 enum { VMType = VM::VM1 };
6248 static const char* GetVMString() { return "1"; }
6249 };
6250 template <> struct TagToType<0x0018,0x6048> {
6251 static const char* GetVRString() { return "UL"; }
6252 typedef VRToType<VR::UL>::Type Type;
6253 enum : long long { VRType = VR::UL };
6254 enum { VMType = VM::VM1 };
6255 static const char* GetVMString() { return "1"; }
6256 };
6257 template <> struct TagToType<0x0018,0x604a> {
6258 static const char* GetVRString() { return "UL"; }
6259 typedef VRToType<VR::UL>::Type Type;
6260 enum : long long { VRType = VR::UL };
6261 enum { VMType = VM::VM1 };
6262 static const char* GetVMString() { return "1"; }
6263 };
6264 template <> struct TagToType<0x0018,0x604c> {
6265 static const char* GetVRString() { return "US"; }
6266 typedef VRToType<VR::US>::Type Type;
6267 enum : long long { VRType = VR::US };
6268 enum { VMType = VM::VM1 };
6269 static const char* GetVMString() { return "1"; }
6270 };
6271 template <> struct TagToType<0x0018,0x604e> {
6272 static const char* GetVRString() { return "US"; }
6273 typedef VRToType<VR::US>::Type Type;
6274 enum : long long { VRType = VR::US };
6275 enum { VMType = VM::VM1 };
6276 static const char* GetVMString() { return "1"; }
6277 };
6278 template <> struct TagToType<0x0018,0x6050> {
6279 static const char* GetVRString() { return "UL"; }
6280 typedef VRToType<VR::UL>::Type Type;
6281 enum : long long { VRType = VR::UL };
6282 enum { VMType = VM::VM1 };
6283 static const char* GetVMString() { return "1"; }
6284 };
6285 template <> struct TagToType<0x0018,0x6052> {
6286 static const char* GetVRString() { return "UL"; }
6287 typedef VRToType<VR::UL>::Type Type;
6288 enum : long long { VRType = VR::UL };
6289 enum { VMType = VM::VM1_n };
6290 static const char* GetVMString() { return "1-n"; }
6291 };
6292 template <> struct TagToType<0x0018,0x6054> {
6293 static const char* GetVRString() { return "FD"; }
6294 typedef VRToType<VR::FD>::Type Type;
6295 enum : long long { VRType = VR::FD };
6296 enum { VMType = VM::VM1_n };
6297 static const char* GetVMString() { return "1-n"; }
6298 };
6299 template <> struct TagToType<0x0018,0x6056> {
6300 static const char* GetVRString() { return "UL"; }
6301 typedef VRToType<VR::UL>::Type Type;
6302 enum : long long { VRType = VR::UL };
6303 enum { VMType = VM::VM1 };
6304 static const char* GetVMString() { return "1"; }
6305 };
6306 template <> struct TagToType<0x0018,0x6058> {
6307 static const char* GetVRString() { return "UL"; }
6308 typedef VRToType<VR::UL>::Type Type;
6309 enum : long long { VRType = VR::UL };
6310 enum { VMType = VM::VM1_n };
6311 static const char* GetVMString() { return "1-n"; }
6312 };
6313 template <> struct TagToType<0x0018,0x605a> {
6314 static const char* GetVRString() { return "FL"; }
6315 typedef VRToType<VR::FL>::Type Type;
6316 enum : long long { VRType = VR::FL };
6317 enum { VMType = VM::VM1_n };
6318 static const char* GetVMString() { return "1-n"; }
6319 };
6320 template <> struct TagToType<0x0018,0x6060> {
6321 static const char* GetVRString() { return "FL"; }
6322 typedef VRToType<VR::FL>::Type Type;
6323 enum : long long { VRType = VR::FL };
6324 enum { VMType = VM::VM1_n };
6325 static const char* GetVMString() { return "1-n"; }
6326 };
6327 template <> struct TagToType<0x0018,0x7000> {
6328 static const char* GetVRString() { return "CS"; }
6329 typedef VRToType<VR::CS>::Type Type;
6330 enum : long long { VRType = VR::CS };
6331 enum { VMType = VM::VM1 };
6332 static const char* GetVMString() { return "1"; }
6333 };
6334 template <> struct TagToType<0x0018,0x7001> {
6335 static const char* GetVRString() { return "DS"; }
6336 typedef VRToType<VR::DS>::Type Type;
6337 enum : long long { VRType = VR::DS };
6338 enum { VMType = VM::VM1 };
6339 static const char* GetVMString() { return "1"; }
6340 };
6341 template <> struct TagToType<0x0018,0x7004> {
6342 static const char* GetVRString() { return "CS"; }
6343 typedef VRToType<VR::CS>::Type Type;
6344 enum : long long { VRType = VR::CS };
6345 enum { VMType = VM::VM1 };
6346 static const char* GetVMString() { return "1"; }
6347 };
6348 template <> struct TagToType<0x0018,0x7005> {
6349 static const char* GetVRString() { return "CS"; }
6350 typedef VRToType<VR::CS>::Type Type;
6351 enum : long long { VRType = VR::CS };
6352 enum { VMType = VM::VM1 };
6353 static const char* GetVMString() { return "1"; }
6354 };
6355 template <> struct TagToType<0x0018,0x7006> {
6356 static const char* GetVRString() { return "LT"; }
6357 typedef VRToType<VR::LT>::Type Type;
6358 enum : long long { VRType = VR::LT };
6359 enum { VMType = VM::VM1 };
6360 static const char* GetVMString() { return "1"; }
6361 };
6362 template <> struct TagToType<0x0018,0x7008> {
6363 static const char* GetVRString() { return "LT"; }
6364 typedef VRToType<VR::LT>::Type Type;
6365 enum : long long { VRType = VR::LT };
6366 enum { VMType = VM::VM1 };
6367 static const char* GetVMString() { return "1"; }
6368 };
6369 template <> struct TagToType<0x0018,0x700a> {
6370 static const char* GetVRString() { return "SH"; }
6371 typedef VRToType<VR::SH>::Type Type;
6372 enum : long long { VRType = VR::SH };
6373 enum { VMType = VM::VM1 };
6374 static const char* GetVMString() { return "1"; }
6375 };
6376 template <> struct TagToType<0x0018,0x700c> {
6377 static const char* GetVRString() { return "DA"; }
6378 typedef VRToType<VR::DA>::Type Type;
6379 enum : long long { VRType = VR::DA };
6380 enum { VMType = VM::VM1 };
6381 static const char* GetVMString() { return "1"; }
6382 };
6383 template <> struct TagToType<0x0018,0x700e> {
6384 static const char* GetVRString() { return "TM"; }
6385 typedef VRToType<VR::TM>::Type Type;
6386 enum : long long { VRType = VR::TM };
6387 enum { VMType = VM::VM1 };
6388 static const char* GetVMString() { return "1"; }
6389 };
6390 template <> struct TagToType<0x0018,0x7010> {
6391 static const char* GetVRString() { return "IS"; }
6392 typedef VRToType<VR::IS>::Type Type;
6393 enum : long long { VRType = VR::IS };
6394 enum { VMType = VM::VM1 };
6395 static const char* GetVMString() { return "1"; }
6396 };
6397 template <> struct TagToType<0x0018,0x7011> {
6398 static const char* GetVRString() { return "IS"; }
6399 typedef VRToType<VR::IS>::Type Type;
6400 enum : long long { VRType = VR::IS };
6401 enum { VMType = VM::VM1 };
6402 static const char* GetVMString() { return "1"; }
6403 };
6404 template <> struct TagToType<0x0018,0x7012> {
6405 static const char* GetVRString() { return "DS"; }
6406 typedef VRToType<VR::DS>::Type Type;
6407 enum : long long { VRType = VR::DS };
6408 enum { VMType = VM::VM1 };
6409 static const char* GetVMString() { return "1"; }
6410 };
6411 template <> struct TagToType<0x0018,0x7014> {
6412 static const char* GetVRString() { return "DS"; }
6413 typedef VRToType<VR::DS>::Type Type;
6414 enum : long long { VRType = VR::DS };
6415 enum { VMType = VM::VM1 };
6416 static const char* GetVMString() { return "1"; }
6417 };
6418 template <> struct TagToType<0x0018,0x7016> {
6419 static const char* GetVRString() { return "DS"; }
6420 typedef VRToType<VR::DS>::Type Type;
6421 enum : long long { VRType = VR::DS };
6422 enum { VMType = VM::VM1 };
6423 static const char* GetVMString() { return "1"; }
6424 };
6425 template <> struct TagToType<0x0018,0x701a> {
6426 static const char* GetVRString() { return "DS"; }
6427 typedef VRToType<VR::DS>::Type Type;
6428 enum : long long { VRType = VR::DS };
6429 enum { VMType = VM::VM2 };
6430 static const char* GetVMString() { return "2"; }
6431 };
6432 template <> struct TagToType<0x0018,0x7020> {
6433 static const char* GetVRString() { return "DS"; }
6434 typedef VRToType<VR::DS>::Type Type;
6435 enum : long long { VRType = VR::DS };
6436 enum { VMType = VM::VM2 };
6437 static const char* GetVMString() { return "2"; }
6438 };
6439 template <> struct TagToType<0x0018,0x7022> {
6440 static const char* GetVRString() { return "DS"; }
6441 typedef VRToType<VR::DS>::Type Type;
6442 enum : long long { VRType = VR::DS };
6443 enum { VMType = VM::VM2 };
6444 static const char* GetVMString() { return "2"; }
6445 };
6446 template <> struct TagToType<0x0018,0x7024> {
6447 static const char* GetVRString() { return "CS"; }
6448 typedef VRToType<VR::CS>::Type Type;
6449 enum : long long { VRType = VR::CS };
6450 enum { VMType = VM::VM1 };
6451 static const char* GetVMString() { return "1"; }
6452 };
6453 template <> struct TagToType<0x0018,0x7026> {
6454 static const char* GetVRString() { return "DS"; }
6455 typedef VRToType<VR::DS>::Type Type;
6456 enum : long long { VRType = VR::DS };
6457 enum { VMType = VM::VM1_2 };
6458 static const char* GetVMString() { return "1-2"; }
6459 };
6460 template <> struct TagToType<0x0018,0x7028> {
6461 static const char* GetVRString() { return "DS"; }
6462 typedef VRToType<VR::DS>::Type Type;
6463 enum : long long { VRType = VR::DS };
6464 enum { VMType = VM::VM2 };
6465 static const char* GetVMString() { return "2"; }
6466 };
6467 template <> struct TagToType<0x0018,0x702a> {
6468 static const char* GetVRString() { return "LO"; }
6469 typedef VRToType<VR::LO>::Type Type;
6470 enum : long long { VRType = VR::LO };
6471 enum { VMType = VM::VM1 };
6472 static const char* GetVMString() { return "1"; }
6473 };
6474 template <> struct TagToType<0x0018,0x702b> {
6475 static const char* GetVRString() { return "LO"; }
6476 typedef VRToType<VR::LO>::Type Type;
6477 enum : long long { VRType = VR::LO };
6478 enum { VMType = VM::VM1 };
6479 static const char* GetVMString() { return "1"; }
6480 };
6481 template <> struct TagToType<0x0018,0x7030> {
6482 static const char* GetVRString() { return "DS"; }
6483 typedef VRToType<VR::DS>::Type Type;
6484 enum : long long { VRType = VR::DS };
6485 enum { VMType = VM::VM2 };
6486 static const char* GetVMString() { return "2"; }
6487 };
6488 template <> struct TagToType<0x0018,0x7032> {
6489 static const char* GetVRString() { return "DS"; }
6490 typedef VRToType<VR::DS>::Type Type;
6491 enum : long long { VRType = VR::DS };
6492 enum { VMType = VM::VM1 };
6493 static const char* GetVMString() { return "1"; }
6494 };
6495 template <> struct TagToType<0x0018,0x7034> {
6496 static const char* GetVRString() { return "CS"; }
6497 typedef VRToType<VR::CS>::Type Type;
6498 enum : long long { VRType = VR::CS };
6499 enum { VMType = VM::VM1 };
6500 static const char* GetVMString() { return "1"; }
6501 };
6502 template <> struct TagToType<0x0018,0x7036> {
6503 static const char* GetVRString() { return "FL"; }
6504 typedef VRToType<VR::FL>::Type Type;
6505 enum : long long { VRType = VR::FL };
6506 enum { VMType = VM::VM2 };
6507 static const char* GetVMString() { return "2"; }
6508 };
6509 template <> struct TagToType<0x0018,0x7038> {
6510 static const char* GetVRString() { return "FL"; }
6511 typedef VRToType<VR::FL>::Type Type;
6512 enum : long long { VRType = VR::FL };
6513 enum { VMType = VM::VM1 };
6514 static const char* GetVMString() { return "1"; }
6515 };
6516 template <> struct TagToType<0x0018,0x7040> {
6517 static const char* GetVRString() { return "LT"; }
6518 typedef VRToType<VR::LT>::Type Type;
6519 enum : long long { VRType = VR::LT };
6520 enum { VMType = VM::VM1 };
6521 static const char* GetVMString() { return "1"; }
6522 };
6523 template <> struct TagToType<0x0018,0x7041> {
6524 static const char* GetVRString() { return "LT"; }
6525 typedef VRToType<VR::LT>::Type Type;
6526 enum : long long { VRType = VR::LT };
6527 enum { VMType = VM::VM1 };
6528 static const char* GetVMString() { return "1"; }
6529 };
6530 template <> struct TagToType<0x0018,0x7042> {
6531 static const char* GetVRString() { return "DS"; }
6532 typedef VRToType<VR::DS>::Type Type;
6533 enum : long long { VRType = VR::DS };
6534 enum { VMType = VM::VM1 };
6535 static const char* GetVMString() { return "1"; }
6536 };
6537 template <> struct TagToType<0x0018,0x7044> {
6538 static const char* GetVRString() { return "DS"; }
6539 typedef VRToType<VR::DS>::Type Type;
6540 enum : long long { VRType = VR::DS };
6541 enum { VMType = VM::VM1 };
6542 static const char* GetVMString() { return "1"; }
6543 };
6544 template <> struct TagToType<0x0018,0x7046> {
6545 static const char* GetVRString() { return "IS"; }
6546 typedef VRToType<VR::IS>::Type Type;
6547 enum : long long { VRType = VR::IS };
6548 enum { VMType = VM::VM2 };
6549 static const char* GetVMString() { return "2"; }
6550 };
6551 template <> struct TagToType<0x0018,0x7048> {
6552 static const char* GetVRString() { return "DS"; }
6553 typedef VRToType<VR::DS>::Type Type;
6554 enum : long long { VRType = VR::DS };
6555 enum { VMType = VM::VM1 };
6556 static const char* GetVMString() { return "1"; }
6557 };
6558 template <> struct TagToType<0x0018,0x704c> {
6559 static const char* GetVRString() { return "DS"; }
6560 typedef VRToType<VR::DS>::Type Type;
6561 enum : long long { VRType = VR::DS };
6562 enum { VMType = VM::VM1 };
6563 static const char* GetVMString() { return "1"; }
6564 };
6565 template <> struct TagToType<0x0018,0x7050> {
6566 static const char* GetVRString() { return "CS"; }
6567 typedef VRToType<VR::CS>::Type Type;
6568 enum : long long { VRType = VR::CS };
6569 enum { VMType = VM::VM1_n };
6570 static const char* GetVMString() { return "1-n"; }
6571 };
6572 template <> struct TagToType<0x0018,0x7052> {
6573 static const char* GetVRString() { return "DS"; }
6574 typedef VRToType<VR::DS>::Type Type;
6575 enum : long long { VRType = VR::DS };
6576 enum { VMType = VM::VM1_n };
6577 static const char* GetVMString() { return "1-n"; }
6578 };
6579 template <> struct TagToType<0x0018,0x7054> {
6580 static const char* GetVRString() { return "DS"; }
6581 typedef VRToType<VR::DS>::Type Type;
6582 enum : long long { VRType = VR::DS };
6583 enum { VMType = VM::VM1_n };
6584 static const char* GetVMString() { return "1-n"; }
6585 };
6586 template <> struct TagToType<0x0018,0x7056> {
6587 static const char* GetVRString() { return "FL"; }
6588 typedef VRToType<VR::FL>::Type Type;
6589 enum : long long { VRType = VR::FL };
6590 enum { VMType = VM::VM1_n };
6591 static const char* GetVMString() { return "1-n"; }
6592 };
6593 template <> struct TagToType<0x0018,0x7058> {
6594 static const char* GetVRString() { return "FL"; }
6595 typedef VRToType<VR::FL>::Type Type;
6596 enum : long long { VRType = VR::FL };
6597 enum { VMType = VM::VM1_n };
6598 static const char* GetVMString() { return "1-n"; }
6599 };
6600 template <> struct TagToType<0x0018,0x7060> {
6601 static const char* GetVRString() { return "CS"; }
6602 typedef VRToType<VR::CS>::Type Type;
6603 enum : long long { VRType = VR::CS };
6604 enum { VMType = VM::VM1 };
6605 static const char* GetVMString() { return "1"; }
6606 };
6607 template <> struct TagToType<0x0018,0x7062> {
6608 static const char* GetVRString() { return "LT"; }
6609 typedef VRToType<VR::LT>::Type Type;
6610 enum : long long { VRType = VR::LT };
6611 enum { VMType = VM::VM1 };
6612 static const char* GetVMString() { return "1"; }
6613 };
6614 template <> struct TagToType<0x0018,0x7064> {
6615 static const char* GetVRString() { return "CS"; }
6616 typedef VRToType<VR::CS>::Type Type;
6617 enum : long long { VRType = VR::CS };
6618 enum { VMType = VM::VM1 };
6619 static const char* GetVMString() { return "1"; }
6620 };
6621 template <> struct TagToType<0x0018,0x7065> {
6622 static const char* GetVRString() { return "DS"; }
6623 typedef VRToType<VR::DS>::Type Type;
6624 enum : long long { VRType = VR::DS };
6625 enum { VMType = VM::VM1 };
6626 static const char* GetVMString() { return "1"; }
6627 };
6628 template <> struct TagToType<0x0018,0x8150> {
6629 static const char* GetVRString() { return "DS"; }
6630 typedef VRToType<VR::DS>::Type Type;
6631 enum : long long { VRType = VR::DS };
6632 enum { VMType = VM::VM1 };
6633 static const char* GetVMString() { return "1"; }
6634 };
6635 template <> struct TagToType<0x0018,0x8151> {
6636 static const char* GetVRString() { return "DS"; }
6637 typedef VRToType<VR::DS>::Type Type;
6638 enum : long long { VRType = VR::DS };
6639 enum { VMType = VM::VM1 };
6640 static const char* GetVMString() { return "1"; }
6641 };
6642 template <> struct TagToType<0x0018,0x9004> {
6643 static const char* GetVRString() { return "CS"; }
6644 typedef VRToType<VR::CS>::Type Type;
6645 enum : long long { VRType = VR::CS };
6646 enum { VMType = VM::VM1 };
6647 static const char* GetVMString() { return "1"; }
6648 };
6649 template <> struct TagToType<0x0018,0x9005> {
6650 static const char* GetVRString() { return "SH"; }
6651 typedef VRToType<VR::SH>::Type Type;
6652 enum : long long { VRType = VR::SH };
6653 enum { VMType = VM::VM1 };
6654 static const char* GetVMString() { return "1"; }
6655 };
6656 template <> struct TagToType<0x0018,0x9006> {
6657 static const char* GetVRString() { return "SQ"; }
6658 typedef VRToType<VR::SQ>::Type Type;
6659 enum : long long { VRType = VR::SQ };
6660 enum { VMType = VM::VM1 };
6661 static const char* GetVMString() { return "1"; }
6662 };
6663 template <> struct TagToType<0x0018,0x9008> {
6664 static const char* GetVRString() { return "CS"; }
6665 typedef VRToType<VR::CS>::Type Type;
6666 enum : long long { VRType = VR::CS };
6667 enum { VMType = VM::VM1 };
6668 static const char* GetVMString() { return "1"; }
6669 };
6670 template <> struct TagToType<0x0018,0x9009> {
6671 static const char* GetVRString() { return "CS"; }
6672 typedef VRToType<VR::CS>::Type Type;
6673 enum : long long { VRType = VR::CS };
6674 enum { VMType = VM::VM1 };
6675 static const char* GetVMString() { return "1"; }
6676 };
6677 template <> struct TagToType<0x0018,0x9010> {
6678 static const char* GetVRString() { return "CS"; }
6679 typedef VRToType<VR::CS>::Type Type;
6680 enum : long long { VRType = VR::CS };
6681 enum { VMType = VM::VM1 };
6682 static const char* GetVMString() { return "1"; }
6683 };
6684 template <> struct TagToType<0x0018,0x9011> {
6685 static const char* GetVRString() { return "CS"; }
6686 typedef VRToType<VR::CS>::Type Type;
6687 enum : long long { VRType = VR::CS };
6688 enum { VMType = VM::VM1 };
6689 static const char* GetVMString() { return "1"; }
6690 };
6691 template <> struct TagToType<0x0018,0x9012> {
6692 static const char* GetVRString() { return "CS"; }
6693 typedef VRToType<VR::CS>::Type Type;
6694 enum : long long { VRType = VR::CS };
6695 enum { VMType = VM::VM1 };
6696 static const char* GetVMString() { return "1"; }
6697 };
6698 template <> struct TagToType<0x0018,0x9014> {
6699 static const char* GetVRString() { return "CS"; }
6700 typedef VRToType<VR::CS>::Type Type;
6701 enum : long long { VRType = VR::CS };
6702 enum { VMType = VM::VM1 };
6703 static const char* GetVMString() { return "1"; }
6704 };
6705 template <> struct TagToType<0x0018,0x9015> {
6706 static const char* GetVRString() { return "CS"; }
6707 typedef VRToType<VR::CS>::Type Type;
6708 enum : long long { VRType = VR::CS };
6709 enum { VMType = VM::VM1 };
6710 static const char* GetVMString() { return "1"; }
6711 };
6712 template <> struct TagToType<0x0018,0x9016> {
6713 static const char* GetVRString() { return "CS"; }
6714 typedef VRToType<VR::CS>::Type Type;
6715 enum : long long { VRType = VR::CS };
6716 enum { VMType = VM::VM1 };
6717 static const char* GetVMString() { return "1"; }
6718 };
6719 template <> struct TagToType<0x0018,0x9017> {
6720 static const char* GetVRString() { return "CS"; }
6721 typedef VRToType<VR::CS>::Type Type;
6722 enum : long long { VRType = VR::CS };
6723 enum { VMType = VM::VM1 };
6724 static const char* GetVMString() { return "1"; }
6725 };
6726 template <> struct TagToType<0x0018,0x9018> {
6727 static const char* GetVRString() { return "CS"; }
6728 typedef VRToType<VR::CS>::Type Type;
6729 enum : long long { VRType = VR::CS };
6730 enum { VMType = VM::VM1 };
6731 static const char* GetVMString() { return "1"; }
6732 };
6733 template <> struct TagToType<0x0018,0x9019> {
6734 static const char* GetVRString() { return "FD"; }
6735 typedef VRToType<VR::FD>::Type Type;
6736 enum : long long { VRType = VR::FD };
6737 enum { VMType = VM::VM1 };
6738 static const char* GetVMString() { return "1"; }
6739 };
6740 template <> struct TagToType<0x0018,0x9020> {
6741 static const char* GetVRString() { return "CS"; }
6742 typedef VRToType<VR::CS>::Type Type;
6743 enum : long long { VRType = VR::CS };
6744 enum { VMType = VM::VM1 };
6745 static const char* GetVMString() { return "1"; }
6746 };
6747 template <> struct TagToType<0x0018,0x9021> {
6748 static const char* GetVRString() { return "CS"; }
6749 typedef VRToType<VR::CS>::Type Type;
6750 enum : long long { VRType = VR::CS };
6751 enum { VMType = VM::VM1 };
6752 static const char* GetVMString() { return "1"; }
6753 };
6754 template <> struct TagToType<0x0018,0x9022> {
6755 static const char* GetVRString() { return "CS"; }
6756 typedef VRToType<VR::CS>::Type Type;
6757 enum : long long { VRType = VR::CS };
6758 enum { VMType = VM::VM1 };
6759 static const char* GetVMString() { return "1"; }
6760 };
6761 template <> struct TagToType<0x0018,0x9024> {
6762 static const char* GetVRString() { return "CS"; }
6763 typedef VRToType<VR::CS>::Type Type;
6764 enum : long long { VRType = VR::CS };
6765 enum { VMType = VM::VM1 };
6766 static const char* GetVMString() { return "1"; }
6767 };
6768 template <> struct TagToType<0x0018,0x9025> {
6769 static const char* GetVRString() { return "CS"; }
6770 typedef VRToType<VR::CS>::Type Type;
6771 enum : long long { VRType = VR::CS };
6772 enum { VMType = VM::VM1 };
6773 static const char* GetVMString() { return "1"; }
6774 };
6775 template <> struct TagToType<0x0018,0x9026> {
6776 static const char* GetVRString() { return "CS"; }
6777 typedef VRToType<VR::CS>::Type Type;
6778 enum : long long { VRType = VR::CS };
6779 enum { VMType = VM::VM1 };
6780 static const char* GetVMString() { return "1"; }
6781 };
6782 template <> struct TagToType<0x0018,0x9027> {
6783 static const char* GetVRString() { return "CS"; }
6784 typedef VRToType<VR::CS>::Type Type;
6785 enum : long long { VRType = VR::CS };
6786 enum { VMType = VM::VM1 };
6787 static const char* GetVMString() { return "1"; }
6788 };
6789 template <> struct TagToType<0x0018,0x9028> {
6790 static const char* GetVRString() { return "CS"; }
6791 typedef VRToType<VR::CS>::Type Type;
6792 enum : long long { VRType = VR::CS };
6793 enum { VMType = VM::VM1 };
6794 static const char* GetVMString() { return "1"; }
6795 };
6796 template <> struct TagToType<0x0018,0x9029> {
6797 static const char* GetVRString() { return "CS"; }
6798 typedef VRToType<VR::CS>::Type Type;
6799 enum : long long { VRType = VR::CS };
6800 enum { VMType = VM::VM1 };
6801 static const char* GetVMString() { return "1"; }
6802 };
6803 template <> struct TagToType<0x0018,0x9030> {
6804 static const char* GetVRString() { return "FD"; }
6805 typedef VRToType<VR::FD>::Type Type;
6806 enum : long long { VRType = VR::FD };
6807 enum { VMType = VM::VM1 };
6808 static const char* GetVMString() { return "1"; }
6809 };
6810 template <> struct TagToType<0x0018,0x9032> {
6811 static const char* GetVRString() { return "CS"; }
6812 typedef VRToType<VR::CS>::Type Type;
6813 enum : long long { VRType = VR::CS };
6814 enum { VMType = VM::VM1 };
6815 static const char* GetVMString() { return "1"; }
6816 };
6817 template <> struct TagToType<0x0018,0x9033> {
6818 static const char* GetVRString() { return "CS"; }
6819 typedef VRToType<VR::CS>::Type Type;
6820 enum : long long { VRType = VR::CS };
6821 enum { VMType = VM::VM1 };
6822 static const char* GetVMString() { return "1"; }
6823 };
6824 template <> struct TagToType<0x0018,0x9034> {
6825 static const char* GetVRString() { return "CS"; }
6826 typedef VRToType<VR::CS>::Type Type;
6827 enum : long long { VRType = VR::CS };
6828 enum { VMType = VM::VM1 };
6829 static const char* GetVMString() { return "1"; }
6830 };
6831 template <> struct TagToType<0x0018,0x9035> {
6832 static const char* GetVRString() { return "FD"; }
6833 typedef VRToType<VR::FD>::Type Type;
6834 enum : long long { VRType = VR::FD };
6835 enum { VMType = VM::VM1 };
6836 static const char* GetVMString() { return "1"; }
6837 };
6838 template <> struct TagToType<0x0018,0x9036> {
6839 static const char* GetVRString() { return "CS"; }
6840 typedef VRToType<VR::CS>::Type Type;
6841 enum : long long { VRType = VR::CS };
6842 enum { VMType = VM::VM1 };
6843 static const char* GetVMString() { return "1"; }
6844 };
6845 template <> struct TagToType<0x0018,0x9037> {
6846 static const char* GetVRString() { return "CS"; }
6847 typedef VRToType<VR::CS>::Type Type;
6848 enum : long long { VRType = VR::CS };
6849 enum { VMType = VM::VM1 };
6850 static const char* GetVMString() { return "1"; }
6851 };
6852 template <> struct TagToType<0x0018,0x9041> {
6853 static const char* GetVRString() { return "LO"; }
6854 typedef VRToType<VR::LO>::Type Type;
6855 enum : long long { VRType = VR::LO };
6856 enum { VMType = VM::VM1 };
6857 static const char* GetVMString() { return "1"; }
6858 };
6859 template <> struct TagToType<0x0018,0x9042> {
6860 static const char* GetVRString() { return "SQ"; }
6861 typedef VRToType<VR::SQ>::Type Type;
6862 enum : long long { VRType = VR::SQ };
6863 enum { VMType = VM::VM1 };
6864 static const char* GetVMString() { return "1"; }
6865 };
6866 template <> struct TagToType<0x0018,0x9043> {
6867 static const char* GetVRString() { return "CS"; }
6868 typedef VRToType<VR::CS>::Type Type;
6869 enum : long long { VRType = VR::CS };
6870 enum { VMType = VM::VM1 };
6871 static const char* GetVMString() { return "1"; }
6872 };
6873 template <> struct TagToType<0x0018,0x9044> {
6874 static const char* GetVRString() { return "CS"; }
6875 typedef VRToType<VR::CS>::Type Type;
6876 enum : long long { VRType = VR::CS };
6877 enum { VMType = VM::VM1 };
6878 static const char* GetVMString() { return "1"; }
6879 };
6880 template <> struct TagToType<0x0018,0x9045> {
6881 static const char* GetVRString() { return "SQ"; }
6882 typedef VRToType<VR::SQ>::Type Type;
6883 enum : long long { VRType = VR::SQ };
6884 enum { VMType = VM::VM1 };
6885 static const char* GetVMString() { return "1"; }
6886 };
6887 template <> struct TagToType<0x0018,0x9046> {
6888 static const char* GetVRString() { return "LO"; }
6889 typedef VRToType<VR::LO>::Type Type;
6890 enum : long long { VRType = VR::LO };
6891 enum { VMType = VM::VM1 };
6892 static const char* GetVMString() { return "1"; }
6893 };
6894 template <> struct TagToType<0x0018,0x9047> {
6895 static const char* GetVRString() { return "SH"; }
6896 typedef VRToType<VR::SH>::Type Type;
6897 enum : long long { VRType = VR::SH };
6898 enum { VMType = VM::VM1 };
6899 static const char* GetVMString() { return "1"; }
6900 };
6901 template <> struct TagToType<0x0018,0x9048> {
6902 static const char* GetVRString() { return "CS"; }
6903 typedef VRToType<VR::CS>::Type Type;
6904 enum : long long { VRType = VR::CS };
6905 enum { VMType = VM::VM1 };
6906 static const char* GetVMString() { return "1"; }
6907 };
6908 template <> struct TagToType<0x0018,0x9049> {
6909 static const char* GetVRString() { return "SQ"; }
6910 typedef VRToType<VR::SQ>::Type Type;
6911 enum : long long { VRType = VR::SQ };
6912 enum { VMType = VM::VM1 };
6913 static const char* GetVMString() { return "1"; }
6914 };
6915 template <> struct TagToType<0x0018,0x9050> {
6916 static const char* GetVRString() { return "LO"; }
6917 typedef VRToType<VR::LO>::Type Type;
6918 enum : long long { VRType = VR::LO };
6919 enum { VMType = VM::VM1 };
6920 static const char* GetVMString() { return "1"; }
6921 };
6922 template <> struct TagToType<0x0018,0x9051> {
6923 static const char* GetVRString() { return "CS"; }
6924 typedef VRToType<VR::CS>::Type Type;
6925 enum : long long { VRType = VR::CS };
6926 enum { VMType = VM::VM1 };
6927 static const char* GetVMString() { return "1"; }
6928 };
6929 template <> struct TagToType<0x0018,0x9052> {
6930 static const char* GetVRString() { return "FD"; }
6931 typedef VRToType<VR::FD>::Type Type;
6932 enum : long long { VRType = VR::FD };
6933 enum { VMType = VM::VM1_2 };
6934 static const char* GetVMString() { return "1-2"; }
6935 };
6936 template <> struct TagToType<0x0018,0x9053> {
6937 static const char* GetVRString() { return "FD"; }
6938 typedef VRToType<VR::FD>::Type Type;
6939 enum : long long { VRType = VR::FD };
6940 enum { VMType = VM::VM1_2 };
6941 static const char* GetVMString() { return "1-2"; }
6942 };
6943 template <> struct TagToType<0x0018,0x9054> {
6944 static const char* GetVRString() { return "CS"; }
6945 typedef VRToType<VR::CS>::Type Type;
6946 enum : long long { VRType = VR::CS };
6947 enum { VMType = VM::VM1 };
6948 static const char* GetVMString() { return "1"; }
6949 };
6950 template <> struct TagToType<0x0018,0x9058> {
6951 static const char* GetVRString() { return "US"; }
6952 typedef VRToType<VR::US>::Type Type;
6953 enum : long long { VRType = VR::US };
6954 enum { VMType = VM::VM1 };
6955 static const char* GetVMString() { return "1"; }
6956 };
6957 template <> struct TagToType<0x0018,0x9059> {
6958 static const char* GetVRString() { return "CS"; }
6959 typedef VRToType<VR::CS>::Type Type;
6960 enum : long long { VRType = VR::CS };
6961 enum { VMType = VM::VM1 };
6962 static const char* GetVMString() { return "1"; }
6963 };
6964 template <> struct TagToType<0x0018,0x9060> {
6965 static const char* GetVRString() { return "CS"; }
6966 typedef VRToType<VR::CS>::Type Type;
6967 enum : long long { VRType = VR::CS };
6968 enum { VMType = VM::VM1_2 };
6969 static const char* GetVMString() { return "1-2"; }
6970 };
6971 template <> struct TagToType<0x0018,0x9061> {
6972 static const char* GetVRString() { return "FD"; }
6973 typedef VRToType<VR::FD>::Type Type;
6974 enum : long long { VRType = VR::FD };
6975 enum { VMType = VM::VM1_2 };
6976 static const char* GetVMString() { return "1-2"; }
6977 };
6978 template <> struct TagToType<0x0018,0x9062> {
6979 static const char* GetVRString() { return "CS"; }
6980 typedef VRToType<VR::CS>::Type Type;
6981 enum : long long { VRType = VR::CS };
6982 enum { VMType = VM::VM1 };
6983 static const char* GetVMString() { return "1"; }
6984 };
6985 template <> struct TagToType<0x0018,0x9063> {
6986 static const char* GetVRString() { return "FD"; }
6987 typedef VRToType<VR::FD>::Type Type;
6988 enum : long long { VRType = VR::FD };
6989 enum { VMType = VM::VM1_2 };
6990 static const char* GetVMString() { return "1-2"; }
6991 };
6992 template <> struct TagToType<0x0018,0x9064> {
6993 static const char* GetVRString() { return "CS"; }
6994 typedef VRToType<VR::CS>::Type Type;
6995 enum : long long { VRType = VR::CS };
6996 enum { VMType = VM::VM1 };
6997 static const char* GetVMString() { return "1"; }
6998 };
6999 template <> struct TagToType<0x0018,0x9065> {
7000 static const char* GetVRString() { return "CS"; }
7001 typedef VRToType<VR::CS>::Type Type;
7002 enum : long long { VRType = VR::CS };
7003 enum { VMType = VM::VM1_2 };
7004 static const char* GetVMString() { return "1-2"; }
7005 };
7006 template <> struct TagToType<0x0018,0x9066> {
7007 static const char* GetVRString() { return "US"; }
7008 typedef VRToType<VR::US>::Type Type;
7009 enum : long long { VRType = VR::US };
7010 enum { VMType = VM::VM1_2 };
7011 static const char* GetVMString() { return "1-2"; }
7012 };
7013 template <> struct TagToType<0x0018,0x9067> {
7014 static const char* GetVRString() { return "CS"; }
7015 typedef VRToType<VR::CS>::Type Type;
7016 enum : long long { VRType = VR::CS };
7017 enum { VMType = VM::VM1 };
7018 static const char* GetVMString() { return "1"; }
7019 };
7020 template <> struct TagToType<0x0018,0x9069> {
7021 static const char* GetVRString() { return "FD"; }
7022 typedef VRToType<VR::FD>::Type Type;
7023 enum : long long { VRType = VR::FD };
7024 enum { VMType = VM::VM1 };
7025 static const char* GetVMString() { return "1"; }
7026 };
7027 template <> struct TagToType<0x0018,0x9070> {
7028 static const char* GetVRString() { return "FD"; }
7029 typedef VRToType<VR::FD>::Type Type;
7030 enum : long long { VRType = VR::FD };
7031 enum { VMType = VM::VM1 };
7032 static const char* GetVMString() { return "1"; }
7033 };
7034 template <> struct TagToType<0x0018,0x9073> {
7035 static const char* GetVRString() { return "FD"; }
7036 typedef VRToType<VR::FD>::Type Type;
7037 enum : long long { VRType = VR::FD };
7038 enum { VMType = VM::VM1 };
7039 static const char* GetVMString() { return "1"; }
7040 };
7041 template <> struct TagToType<0x0018,0x9074> {
7042 static const char* GetVRString() { return "DT"; }
7043 typedef VRToType<VR::DT>::Type Type;
7044 enum : long long { VRType = VR::DT };
7045 enum { VMType = VM::VM1 };
7046 static const char* GetVMString() { return "1"; }
7047 };
7048 template <> struct TagToType<0x0018,0x9075> {
7049 static const char* GetVRString() { return "CS"; }
7050 typedef VRToType<VR::CS>::Type Type;
7051 enum : long long { VRType = VR::CS };
7052 enum { VMType = VM::VM1 };
7053 static const char* GetVMString() { return "1"; }
7054 };
7055 template <> struct TagToType<0x0018,0x9076> {
7056 static const char* GetVRString() { return "SQ"; }
7057 typedef VRToType<VR::SQ>::Type Type;
7058 enum : long long { VRType = VR::SQ };
7059 enum { VMType = VM::VM1 };
7060 static const char* GetVMString() { return "1"; }
7061 };
7062 template <> struct TagToType<0x0018,0x9077> {
7063 static const char* GetVRString() { return "CS"; }
7064 typedef VRToType<VR::CS>::Type Type;
7065 enum : long long { VRType = VR::CS };
7066 enum { VMType = VM::VM1 };
7067 static const char* GetVMString() { return "1"; }
7068 };
7069 template <> struct TagToType<0x0018,0x9078> {
7070 static const char* GetVRString() { return "CS"; }
7071 typedef VRToType<VR::CS>::Type Type;
7072 enum : long long { VRType = VR::CS };
7073 enum { VMType = VM::VM1 };
7074 static const char* GetVMString() { return "1"; }
7075 };
7076 template <> struct TagToType<0x0018,0x9079> {
7077 static const char* GetVRString() { return "FD"; }
7078 typedef VRToType<VR::FD>::Type Type;
7079 enum : long long { VRType = VR::FD };
7080 enum { VMType = VM::VM1_n };
7081 static const char* GetVMString() { return "1-n"; }
7082 };
7083 template <> struct TagToType<0x0018,0x9080> {
7084 static const char* GetVRString() { return "ST"; }
7085 typedef VRToType<VR::ST>::Type Type;
7086 enum : long long { VRType = VR::ST };
7087 enum { VMType = VM::VM1 };
7088 static const char* GetVMString() { return "1"; }
7089 };
7090 template <> struct TagToType<0x0018,0x9081> {
7091 static const char* GetVRString() { return "CS"; }
7092 typedef VRToType<VR::CS>::Type Type;
7093 enum : long long { VRType = VR::CS };
7094 enum { VMType = VM::VM1 };
7095 static const char* GetVMString() { return "1"; }
7096 };
7097 template <> struct TagToType<0x0018,0x9082> {
7098 static const char* GetVRString() { return "FD"; }
7099 typedef VRToType<VR::FD>::Type Type;
7100 enum : long long { VRType = VR::FD };
7101 enum { VMType = VM::VM1 };
7102 static const char* GetVMString() { return "1"; }
7103 };
7104 template <> struct TagToType<0x0018,0x9083> {
7105 static const char* GetVRString() { return "SQ"; }
7106 typedef VRToType<VR::SQ>::Type Type;
7107 enum : long long { VRType = VR::SQ };
7108 enum { VMType = VM::VM1 };
7109 static const char* GetVMString() { return "1"; }
7110 };
7111 template <> struct TagToType<0x0018,0x9084> {
7112 static const char* GetVRString() { return "SQ"; }
7113 typedef VRToType<VR::SQ>::Type Type;
7114 enum : long long { VRType = VR::SQ };
7115 enum { VMType = VM::VM1 };
7116 static const char* GetVMString() { return "1"; }
7117 };
7118 template <> struct TagToType<0x0018,0x9085> {
7119 static const char* GetVRString() { return "CS"; }
7120 typedef VRToType<VR::CS>::Type Type;
7121 enum : long long { VRType = VR::CS };
7122 enum { VMType = VM::VM1 };
7123 static const char* GetVMString() { return "1"; }
7124 };
7125 template <> struct TagToType<0x0018,0x9087> {
7126 static const char* GetVRString() { return "FD"; }
7127 typedef VRToType<VR::FD>::Type Type;
7128 enum : long long { VRType = VR::FD };
7129 enum { VMType = VM::VM1 };
7130 static const char* GetVMString() { return "1"; }
7131 };
7132 template <> struct TagToType<0x0018,0x9089> {
7133 static const char* GetVRString() { return "FD"; }
7134 typedef VRToType<VR::FD>::Type Type;
7135 enum : long long { VRType = VR::FD };
7136 enum { VMType = VM::VM3 };
7137 static const char* GetVMString() { return "3"; }
7138 };
7139 template <> struct TagToType<0x0018,0x9090> {
7140 static const char* GetVRString() { return "FD"; }
7141 typedef VRToType<VR::FD>::Type Type;
7142 enum : long long { VRType = VR::FD };
7143 enum { VMType = VM::VM3 };
7144 static const char* GetVMString() { return "3"; }
7145 };
7146 template <> struct TagToType<0x0018,0x9091> {
7147 static const char* GetVRString() { return "FD"; }
7148 typedef VRToType<VR::FD>::Type Type;
7149 enum : long long { VRType = VR::FD };
7150 enum { VMType = VM::VM1 };
7151 static const char* GetVMString() { return "1"; }
7152 };
7153 template <> struct TagToType<0x0018,0x9092> {
7154 static const char* GetVRString() { return "SQ"; }
7155 typedef VRToType<VR::SQ>::Type Type;
7156 enum : long long { VRType = VR::SQ };
7157 enum { VMType = VM::VM1 };
7158 static const char* GetVMString() { return "1"; }
7159 };
7160 template <> struct TagToType<0x0018,0x9093> {
7161 static const char* GetVRString() { return "US"; }
7162 typedef VRToType<VR::US>::Type Type;
7163 enum : long long { VRType = VR::US };
7164 enum { VMType = VM::VM1 };
7165 static const char* GetVMString() { return "1"; }
7166 };
7167 template <> struct TagToType<0x0018,0x9094> {
7168 static const char* GetVRString() { return "CS"; }
7169 typedef VRToType<VR::CS>::Type Type;
7170 enum : long long { VRType = VR::CS };
7171 enum { VMType = VM::VM1 };
7172 static const char* GetVMString() { return "1"; }
7173 };
7174 template <> struct TagToType<0x0018,0x9095> {
7175 static const char* GetVRString() { return "UL"; }
7176 typedef VRToType<VR::UL>::Type Type;
7177 enum : long long { VRType = VR::UL };
7178 enum { VMType = VM::VM1 };
7179 static const char* GetVMString() { return "1"; }
7180 };
7181 template <> struct TagToType<0x0018,0x9096> {
7182 static const char* GetVRString() { return "FD"; }
7183 typedef VRToType<VR::FD>::Type Type;
7184 enum : long long { VRType = VR::FD };
7185 enum { VMType = VM::VM1 };
7186 static const char* GetVMString() { return "1"; }
7187 };
7188 template <> struct TagToType<0x0018,0x9098> {
7189 static const char* GetVRString() { return "FD"; }
7190 typedef VRToType<VR::FD>::Type Type;
7191 enum : long long { VRType = VR::FD };
7192 enum { VMType = VM::VM1_2 };
7193 static const char* GetVMString() { return "1-2"; }
7194 };
7195 template <> struct TagToType<0x0018,0x9100> {
7196 static const char* GetVRString() { return "CS"; }
7197 typedef VRToType<VR::CS>::Type Type;
7198 enum : long long { VRType = VR::CS };
7199 enum { VMType = VM::VM1_2 };
7200 static const char* GetVMString() { return "1-2"; }
7201 };
7202 template <> struct TagToType<0x0018,0x9101> {
7203 static const char* GetVRString() { return "CS"; }
7204 typedef VRToType<VR::CS>::Type Type;
7205 enum : long long { VRType = VR::CS };
7206 enum { VMType = VM::VM1 };
7207 static const char* GetVMString() { return "1"; }
7208 };
7209 template <> struct TagToType<0x0018,0x9103> {
7210 static const char* GetVRString() { return "SQ"; }
7211 typedef VRToType<VR::SQ>::Type Type;
7212 enum : long long { VRType = VR::SQ };
7213 enum { VMType = VM::VM1 };
7214 static const char* GetVMString() { return "1"; }
7215 };
7216 template <> struct TagToType<0x0018,0x9104> {
7217 static const char* GetVRString() { return "FD"; }
7218 typedef VRToType<VR::FD>::Type Type;
7219 enum : long long { VRType = VR::FD };
7220 enum { VMType = VM::VM1 };
7221 static const char* GetVMString() { return "1"; }
7222 };
7223 template <> struct TagToType<0x0018,0x9105> {
7224 static const char* GetVRString() { return "FD"; }
7225 typedef VRToType<VR::FD>::Type Type;
7226 enum : long long { VRType = VR::FD };
7227 enum { VMType = VM::VM3 };
7228 static const char* GetVMString() { return "3"; }
7229 };
7230 template <> struct TagToType<0x0018,0x9106> {
7231 static const char* GetVRString() { return "FD"; }
7232 typedef VRToType<VR::FD>::Type Type;
7233 enum : long long { VRType = VR::FD };
7234 enum { VMType = VM::VM3 };
7235 static const char* GetVMString() { return "3"; }
7236 };
7237 template <> struct TagToType<0x0018,0x9107> {
7238 static const char* GetVRString() { return "SQ"; }
7239 typedef VRToType<VR::SQ>::Type Type;
7240 enum : long long { VRType = VR::SQ };
7241 enum { VMType = VM::VM1 };
7242 static const char* GetVMString() { return "1"; }
7243 };
7244 template <> struct TagToType<0x0018,0x9112> {
7245 static const char* GetVRString() { return "SQ"; }
7246 typedef VRToType<VR::SQ>::Type Type;
7247 enum : long long { VRType = VR::SQ };
7248 enum { VMType = VM::VM1 };
7249 static const char* GetVMString() { return "1"; }
7250 };
7251 template <> struct TagToType<0x0018,0x9114> {
7252 static const char* GetVRString() { return "SQ"; }
7253 typedef VRToType<VR::SQ>::Type Type;
7254 enum : long long { VRType = VR::SQ };
7255 enum { VMType = VM::VM1 };
7256 static const char* GetVMString() { return "1"; }
7257 };
7258 template <> struct TagToType<0x0018,0x9115> {
7259 static const char* GetVRString() { return "SQ"; }
7260 typedef VRToType<VR::SQ>::Type Type;
7261 enum : long long { VRType = VR::SQ };
7262 enum { VMType = VM::VM1 };
7263 static const char* GetVMString() { return "1"; }
7264 };
7265 template <> struct TagToType<0x0018,0x9117> {
7266 static const char* GetVRString() { return "SQ"; }
7267 typedef VRToType<VR::SQ>::Type Type;
7268 enum : long long { VRType = VR::SQ };
7269 enum { VMType = VM::VM1 };
7270 static const char* GetVMString() { return "1"; }
7271 };
7272 template <> struct TagToType<0x0018,0x9118> {
7273 static const char* GetVRString() { return "SQ"; }
7274 typedef VRToType<VR::SQ>::Type Type;
7275 enum : long long { VRType = VR::SQ };
7276 enum { VMType = VM::VM1 };
7277 static const char* GetVMString() { return "1"; }
7278 };
7279 template <> struct TagToType<0x0018,0x9119> {
7280 static const char* GetVRString() { return "SQ"; }
7281 typedef VRToType<VR::SQ>::Type Type;
7282 enum : long long { VRType = VR::SQ };
7283 enum { VMType = VM::VM1 };
7284 static const char* GetVMString() { return "1"; }
7285 };
7286 template <> struct TagToType<0x0018,0x9125> {
7287 static const char* GetVRString() { return "SQ"; }
7288 typedef VRToType<VR::SQ>::Type Type;
7289 enum : long long { VRType = VR::SQ };
7290 enum { VMType = VM::VM1 };
7291 static const char* GetVMString() { return "1"; }
7292 };
7293 template <> struct TagToType<0x0018,0x9126> {
7294 static const char* GetVRString() { return "SQ"; }
7295 typedef VRToType<VR::SQ>::Type Type;
7296 enum : long long { VRType = VR::SQ };
7297 enum { VMType = VM::VM1 };
7298 static const char* GetVMString() { return "1"; }
7299 };
7300 template <> struct TagToType<0x0018,0x9127> {
7301 static const char* GetVRString() { return "UL"; }
7302 typedef VRToType<VR::UL>::Type Type;
7303 enum : long long { VRType = VR::UL };
7304 enum { VMType = VM::VM1 };
7305 static const char* GetVMString() { return "1"; }
7306 };
7307 template <> struct TagToType<0x0018,0x9147> {
7308 static const char* GetVRString() { return "CS"; }
7309 typedef VRToType<VR::CS>::Type Type;
7310 enum : long long { VRType = VR::CS };
7311 enum { VMType = VM::VM1 };
7312 static const char* GetVMString() { return "1"; }
7313 };
7314 template <> struct TagToType<0x0018,0x9151> {
7315 static const char* GetVRString() { return "DT"; }
7316 typedef VRToType<VR::DT>::Type Type;
7317 enum : long long { VRType = VR::DT };
7318 enum { VMType = VM::VM1 };
7319 static const char* GetVMString() { return "1"; }
7320 };
7321 template <> struct TagToType<0x0018,0x9152> {
7322 static const char* GetVRString() { return "SQ"; }
7323 typedef VRToType<VR::SQ>::Type Type;
7324 enum : long long { VRType = VR::SQ };
7325 enum { VMType = VM::VM1 };
7326 static const char* GetVMString() { return "1"; }
7327 };
7328 template <> struct TagToType<0x0018,0x9155> {
7329 static const char* GetVRString() { return "FD"; }
7330 typedef VRToType<VR::FD>::Type Type;
7331 enum : long long { VRType = VR::FD };
7332 enum { VMType = VM::VM1 };
7333 static const char* GetVMString() { return "1"; }
7334 };
7335 template <> struct TagToType<0x0018,0x9159> {
7336 static const char* GetVRString() { return "UL"; }
7337 typedef VRToType<VR::UL>::Type Type;
7338 enum : long long { VRType = VR::UL };
7339 enum { VMType = VM::VM1 };
7340 static const char* GetVMString() { return "1"; }
7341 };
7342 template <> struct TagToType<0x0018,0x9166> {
7343 static const char* GetVRString() { return "CS"; }
7344 typedef VRToType<VR::CS>::Type Type;
7345 enum : long long { VRType = VR::CS };
7346 enum { VMType = VM::VM1 };
7347 static const char* GetVMString() { return "1"; }
7348 };
7349 template <> struct TagToType<0x0018,0x9168> {
7350 static const char* GetVRString() { return "FD"; }
7351 typedef VRToType<VR::FD>::Type Type;
7352 enum : long long { VRType = VR::FD };
7353 enum { VMType = VM::VM1 };
7354 static const char* GetVMString() { return "1"; }
7355 };
7356 template <> struct TagToType<0x0018,0x9169> {
7357 static const char* GetVRString() { return "CS"; }
7358 typedef VRToType<VR::CS>::Type Type;
7359 enum : long long { VRType = VR::CS };
7360 enum { VMType = VM::VM1 };
7361 static const char* GetVMString() { return "1"; }
7362 };
7363 template <> struct TagToType<0x0018,0x9170> {
7364 static const char* GetVRString() { return "CS"; }
7365 typedef VRToType<VR::CS>::Type Type;
7366 enum : long long { VRType = VR::CS };
7367 enum { VMType = VM::VM1 };
7368 static const char* GetVMString() { return "1"; }
7369 };
7370 template <> struct TagToType<0x0018,0x9171> {
7371 static const char* GetVRString() { return "CS"; }
7372 typedef VRToType<VR::CS>::Type Type;
7373 enum : long long { VRType = VR::CS };
7374 enum { VMType = VM::VM1 };
7375 static const char* GetVMString() { return "1"; }
7376 };
7377 template <> struct TagToType<0x0018,0x9172> {
7378 static const char* GetVRString() { return "CS"; }
7379 typedef VRToType<VR::CS>::Type Type;
7380 enum : long long { VRType = VR::CS };
7381 enum { VMType = VM::VM1 };
7382 static const char* GetVMString() { return "1"; }
7383 };
7384 template <> struct TagToType<0x0018,0x9173> {
7385 static const char* GetVRString() { return "CS"; }
7386 typedef VRToType<VR::CS>::Type Type;
7387 enum : long long { VRType = VR::CS };
7388 enum { VMType = VM::VM1 };
7389 static const char* GetVMString() { return "1"; }
7390 };
7391 template <> struct TagToType<0x0018,0x9174> {
7392 static const char* GetVRString() { return "CS"; }
7393 typedef VRToType<VR::CS>::Type Type;
7394 enum : long long { VRType = VR::CS };
7395 enum { VMType = VM::VM1 };
7396 static const char* GetVMString() { return "1"; }
7397 };
7398 template <> struct TagToType<0x0018,0x9175> {
7399 static const char* GetVRString() { return "LO"; }
7400 typedef VRToType<VR::LO>::Type Type;
7401 enum : long long { VRType = VR::LO };
7402 enum { VMType = VM::VM1 };
7403 static const char* GetVMString() { return "1"; }
7404 };
7405 template <> struct TagToType<0x0018,0x9176> {
7406 static const char* GetVRString() { return "SQ"; }
7407 typedef VRToType<VR::SQ>::Type Type;
7408 enum : long long { VRType = VR::SQ };
7409 enum { VMType = VM::VM1 };
7410 static const char* GetVMString() { return "1"; }
7411 };
7412 template <> struct TagToType<0x0018,0x9177> {
7413 static const char* GetVRString() { return "CS"; }
7414 typedef VRToType<VR::CS>::Type Type;
7415 enum : long long { VRType = VR::CS };
7416 enum { VMType = VM::VM1 };
7417 static const char* GetVMString() { return "1"; }
7418 };
7419 template <> struct TagToType<0x0018,0x9178> {
7420 static const char* GetVRString() { return "CS"; }
7421 typedef VRToType<VR::CS>::Type Type;
7422 enum : long long { VRType = VR::CS };
7423 enum { VMType = VM::VM1 };
7424 static const char* GetVMString() { return "1"; }
7425 };
7426 template <> struct TagToType<0x0018,0x9179> {
7427 static const char* GetVRString() { return "CS"; }
7428 typedef VRToType<VR::CS>::Type Type;
7429 enum : long long { VRType = VR::CS };
7430 enum { VMType = VM::VM1 };
7431 static const char* GetVMString() { return "1"; }
7432 };
7433 template <> struct TagToType<0x0018,0x9180> {
7434 static const char* GetVRString() { return "CS"; }
7435 typedef VRToType<VR::CS>::Type Type;
7436 enum : long long { VRType = VR::CS };
7437 enum { VMType = VM::VM1 };
7438 static const char* GetVMString() { return "1"; }
7439 };
7440 template <> struct TagToType<0x0018,0x9181> {
7441 static const char* GetVRString() { return "FD"; }
7442 typedef VRToType<VR::FD>::Type Type;
7443 enum : long long { VRType = VR::FD };
7444 enum { VMType = VM::VM1 };
7445 static const char* GetVMString() { return "1"; }
7446 };
7447 template <> struct TagToType<0x0018,0x9182> {
7448 static const char* GetVRString() { return "FD"; }
7449 typedef VRToType<VR::FD>::Type Type;
7450 enum : long long { VRType = VR::FD };
7451 enum { VMType = VM::VM1 };
7452 static const char* GetVMString() { return "1"; }
7453 };
7454 template <> struct TagToType<0x0018,0x9183> {
7455 static const char* GetVRString() { return "CS"; }
7456 typedef VRToType<VR::CS>::Type Type;
7457 enum : long long { VRType = VR::CS };
7458 enum { VMType = VM::VM1 };
7459 static const char* GetVMString() { return "1"; }
7460 };
7461 template <> struct TagToType<0x0018,0x9184> {
7462 static const char* GetVRString() { return "FD"; }
7463 typedef VRToType<VR::FD>::Type Type;
7464 enum : long long { VRType = VR::FD };
7465 enum { VMType = VM::VM1 };
7466 static const char* GetVMString() { return "1"; }
7467 };
7468 template <> struct TagToType<0x0018,0x9185> {
7469 static const char* GetVRString() { return "ST"; }
7470 typedef VRToType<VR::ST>::Type Type;
7471 enum : long long { VRType = VR::ST };
7472 enum { VMType = VM::VM1 };
7473 static const char* GetVMString() { return "1"; }
7474 };
7475 template <> struct TagToType<0x0018,0x9186> {
7476 static const char* GetVRString() { return "SH"; }
7477 typedef VRToType<VR::SH>::Type Type;
7478 enum : long long { VRType = VR::SH };
7479 enum { VMType = VM::VM1 };
7480 static const char* GetVMString() { return "1"; }
7481 };
7482 template <> struct TagToType<0x0018,0x9195> {
7483 static const char* GetVRString() { return "FD"; }
7484 typedef VRToType<VR::FD>::Type Type;
7485 enum : long long { VRType = VR::FD };
7486 enum { VMType = VM::VM1 };
7487 static const char* GetVMString() { return "1"; }
7488 };
7489 template <> struct TagToType<0x0018,0x9196> {
7490 static const char* GetVRString() { return "FD"; }
7491 typedef VRToType<VR::FD>::Type Type;
7492 enum : long long { VRType = VR::FD };
7493 enum { VMType = VM::VM1 };
7494 static const char* GetVMString() { return "1"; }
7495 };
7496 template <> struct TagToType<0x0018,0x9197> {
7497 static const char* GetVRString() { return "SQ"; }
7498 typedef VRToType<VR::SQ>::Type Type;
7499 enum : long long { VRType = VR::SQ };
7500 enum { VMType = VM::VM1 };
7501 static const char* GetVMString() { return "1"; }
7502 };
7503 template <> struct TagToType<0x0018,0x9198> {
7504 static const char* GetVRString() { return "CS"; }
7505 typedef VRToType<VR::CS>::Type Type;
7506 enum : long long { VRType = VR::CS };
7507 enum { VMType = VM::VM1 };
7508 static const char* GetVMString() { return "1"; }
7509 };
7510 template <> struct TagToType<0x0018,0x9199> {
7511 static const char* GetVRString() { return "CS"; }
7512 typedef VRToType<VR::CS>::Type Type;
7513 enum : long long { VRType = VR::CS };
7514 enum { VMType = VM::VM1 };
7515 static const char* GetVMString() { return "1"; }
7516 };
7517 template <> struct TagToType<0x0018,0x9200> {
7518 static const char* GetVRString() { return "CS"; }
7519 typedef VRToType<VR::CS>::Type Type;
7520 enum : long long { VRType = VR::CS };
7521 enum { VMType = VM::VM1 };
7522 static const char* GetVMString() { return "1"; }
7523 };
7524 template <> struct TagToType<0x0018,0x9214> {
7525 static const char* GetVRString() { return "CS"; }
7526 typedef VRToType<VR::CS>::Type Type;
7527 enum : long long { VRType = VR::CS };
7528 enum { VMType = VM::VM1 };
7529 static const char* GetVMString() { return "1"; }
7530 };
7531 template <> struct TagToType<0x0018,0x9217> {
7532 static const char* GetVRString() { return "FD"; }
7533 typedef VRToType<VR::FD>::Type Type;
7534 enum : long long { VRType = VR::FD };
7535 enum { VMType = VM::VM1 };
7536 static const char* GetVMString() { return "1"; }
7537 };
7538 template <> struct TagToType<0x0018,0x9218> {
7539 static const char* GetVRString() { return "FD"; }
7540 typedef VRToType<VR::FD>::Type Type;
7541 enum : long long { VRType = VR::FD };
7542 enum { VMType = VM::VM1 };
7543 static const char* GetVMString() { return "1"; }
7544 };
7545 template <> struct TagToType<0x0018,0x9219> {
7546 static const char* GetVRString() { return "SS"; }
7547 typedef VRToType<VR::SS>::Type Type;
7548 enum : long long { VRType = VR::SS };
7549 enum { VMType = VM::VM1 };
7550 static const char* GetVMString() { return "1"; }
7551 };
7552 template <> struct TagToType<0x0018,0x9220> {
7553 static const char* GetVRString() { return "FD"; }
7554 typedef VRToType<VR::FD>::Type Type;
7555 enum : long long { VRType = VR::FD };
7556 enum { VMType = VM::VM1 };
7557 static const char* GetVMString() { return "1"; }
7558 };
7559 template <> struct TagToType<0x0018,0x9226> {
7560 static const char* GetVRString() { return "SQ"; }
7561 typedef VRToType<VR::SQ>::Type Type;
7562 enum : long long { VRType = VR::SQ };
7563 enum { VMType = VM::VM1 };
7564 static const char* GetVMString() { return "1"; }
7565 };
7566 template <> struct TagToType<0x0018,0x9227> {
7567 static const char* GetVRString() { return "SQ"; }
7568 typedef VRToType<VR::SQ>::Type Type;
7569 enum : long long { VRType = VR::SQ };
7570 enum { VMType = VM::VM1 };
7571 static const char* GetVMString() { return "1"; }
7572 };
7573 template <> struct TagToType<0x0018,0x9231> {
7574 static const char* GetVRString() { return "US"; }
7575 typedef VRToType<VR::US>::Type Type;
7576 enum : long long { VRType = VR::US };
7577 enum { VMType = VM::VM1 };
7578 static const char* GetVMString() { return "1"; }
7579 };
7580 template <> struct TagToType<0x0018,0x9232> {
7581 static const char* GetVRString() { return "US"; }
7582 typedef VRToType<VR::US>::Type Type;
7583 enum : long long { VRType = VR::US };
7584 enum { VMType = VM::VM1 };
7585 static const char* GetVMString() { return "1"; }
7586 };
7587 template <> struct TagToType<0x0018,0x9234> {
7588 static const char* GetVRString() { return "UL"; }
7589 typedef VRToType<VR::UL>::Type Type;
7590 enum : long long { VRType = VR::UL };
7591 enum { VMType = VM::VM1 };
7592 static const char* GetVMString() { return "1"; }
7593 };
7594 template <> struct TagToType<0x0018,0x9236> {
7595 static const char* GetVRString() { return "CS"; }
7596 typedef VRToType<VR::CS>::Type Type;
7597 enum : long long { VRType = VR::CS };
7598 enum { VMType = VM::VM1 };
7599 static const char* GetVMString() { return "1"; }
7600 };
7601 template <> struct TagToType<0x0018,0x9239> {
7602 static const char* GetVRString() { return "SQ"; }
7603 typedef VRToType<VR::SQ>::Type Type;
7604 enum : long long { VRType = VR::SQ };
7605 enum { VMType = VM::VM1 };
7606 static const char* GetVMString() { return "1"; }
7607 };
7608 template <> struct TagToType<0x0018,0x9240> {
7609 static const char* GetVRString() { return "US"; }
7610 typedef VRToType<VR::US>::Type Type;
7611 enum : long long { VRType = VR::US };
7612 enum { VMType = VM::VM1 };
7613 static const char* GetVMString() { return "1"; }
7614 };
7615 template <> struct TagToType<0x0018,0x9241> {
7616 static const char* GetVRString() { return "US"; }
7617 typedef VRToType<VR::US>::Type Type;
7618 enum : long long { VRType = VR::US };
7619 enum { VMType = VM::VM1 };
7620 static const char* GetVMString() { return "1"; }
7621 };
7622 template <> struct TagToType<0x0018,0x9250> {
7623 static const char* GetVRString() { return "CS"; }
7624 typedef VRToType<VR::CS>::Type Type;
7625 enum : long long { VRType = VR::CS };
7626 enum { VMType = VM::VM1 };
7627 static const char* GetVMString() { return "1"; }
7628 };
7629 template <> struct TagToType<0x0018,0x9251> {
7630 static const char* GetVRString() { return "SQ"; }
7631 typedef VRToType<VR::SQ>::Type Type;
7632 enum : long long { VRType = VR::SQ };
7633 enum { VMType = VM::VM1 };
7634 static const char* GetVMString() { return "1"; }
7635 };
7636 template <> struct TagToType<0x0018,0x9252> {
7637 static const char* GetVRString() { return "LO"; }
7638 typedef VRToType<VR::LO>::Type Type;
7639 enum : long long { VRType = VR::LO };
7640 enum { VMType = VM::VM1 };
7641 static const char* GetVMString() { return "1"; }
7642 };
7643 template <> struct TagToType<0x0018,0x9253> {
7644 static const char* GetVRString() { return "US"; }
7645 typedef VRToType<VR::US>::Type Type;
7646 enum : long long { VRType = VR::US };
7647 enum { VMType = VM::VM1 };
7648 static const char* GetVMString() { return "1"; }
7649 };
7650 template <> struct TagToType<0x0018,0x9254> {
7651 static const char* GetVRString() { return "FD"; }
7652 typedef VRToType<VR::FD>::Type Type;
7653 enum : long long { VRType = VR::FD };
7654 enum { VMType = VM::VM1 };
7655 static const char* GetVMString() { return "1"; }
7656 };
7657 template <> struct TagToType<0x0018,0x9255> {
7658 static const char* GetVRString() { return "FD"; }
7659 typedef VRToType<VR::FD>::Type Type;
7660 enum : long long { VRType = VR::FD };
7661 enum { VMType = VM::VM3 };
7662 static const char* GetVMString() { return "3"; }
7663 };
7664 template <> struct TagToType<0x0018,0x9256> {
7665 static const char* GetVRString() { return "FD"; }
7666 typedef VRToType<VR::FD>::Type Type;
7667 enum : long long { VRType = VR::FD };
7668 enum { VMType = VM::VM3 };
7669 static const char* GetVMString() { return "3"; }
7670 };
7671 template <> struct TagToType<0x0018,0x9257> {
7672 static const char* GetVRString() { return "CS"; }
7673 typedef VRToType<VR::CS>::Type Type;
7674 enum : long long { VRType = VR::CS };
7675 enum { VMType = VM::VM1 };
7676 static const char* GetVMString() { return "1"; }
7677 };
7678 template <> struct TagToType<0x0018,0x9258> {
7679 static const char* GetVRString() { return "UL"; }
7680 typedef VRToType<VR::UL>::Type Type;
7681 enum : long long { VRType = VR::UL };
7682 enum { VMType = VM::VM1 };
7683 static const char* GetVMString() { return "1"; }
7684 };
7685 template <> struct TagToType<0x0018,0x9259> {
7686 static const char* GetVRString() { return "CS"; }
7687 typedef VRToType<VR::CS>::Type Type;
7688 enum : long long { VRType = VR::CS };
7689 enum { VMType = VM::VM1 };
7690 static const char* GetVMString() { return "1"; }
7691 };
7692 template <> struct TagToType<0x0018,0x925a> {
7693 static const char* GetVRString() { return "FD"; }
7694 typedef VRToType<VR::FD>::Type Type;
7695 enum : long long { VRType = VR::FD };
7696 enum { VMType = VM::VM1 };
7697 static const char* GetVMString() { return "1"; }
7698 };
7699 template <> struct TagToType<0x0018,0x925b> {
7700 static const char* GetVRString() { return "LO"; }
7701 typedef VRToType<VR::LO>::Type Type;
7702 enum : long long { VRType = VR::LO };
7703 enum { VMType = VM::VM1 };
7704 static const char* GetVMString() { return "1"; }
7705 };
7706 template <> struct TagToType<0x0018,0x925c> {
7707 static const char* GetVRString() { return "CS"; }
7708 typedef VRToType<VR::CS>::Type Type;
7709 enum : long long { VRType = VR::CS };
7710 enum { VMType = VM::VM1 };
7711 static const char* GetVMString() { return "1"; }
7712 };
7713 template <> struct TagToType<0x0018,0x925d> {
7714 static const char* GetVRString() { return "SQ"; }
7715 typedef VRToType<VR::SQ>::Type Type;
7716 enum : long long { VRType = VR::SQ };
7717 enum { VMType = VM::VM1 };
7718 static const char* GetVMString() { return "1"; }
7719 };
7720 template <> struct TagToType<0x0018,0x925e> {
7721 static const char* GetVRString() { return "LO"; }
7722 typedef VRToType<VR::LO>::Type Type;
7723 enum : long long { VRType = VR::LO };
7724 enum { VMType = VM::VM1 };
7725 static const char* GetVMString() { return "1"; }
7726 };
7727 template <> struct TagToType<0x0018,0x925f> {
7728 static const char* GetVRString() { return "UL"; }
7729 typedef VRToType<VR::UL>::Type Type;
7730 enum : long long { VRType = VR::UL };
7731 enum { VMType = VM::VM1 };
7732 static const char* GetVMString() { return "1"; }
7733 };
7734 template <> struct TagToType<0x0018,0x9260> {
7735 static const char* GetVRString() { return "SQ"; }
7736 typedef VRToType<VR::SQ>::Type Type;
7737 enum : long long { VRType = VR::SQ };
7738 enum { VMType = VM::VM1 };
7739 static const char* GetVMString() { return "1"; }
7740 };
7741 template <> struct TagToType<0x0018,0x9295> {
7742 static const char* GetVRString() { return "FD"; }
7743 typedef VRToType<VR::FD>::Type Type;
7744 enum : long long { VRType = VR::FD };
7745 enum { VMType = VM::VM1 };
7746 static const char* GetVMString() { return "1"; }
7747 };
7748 template <> struct TagToType<0x0018,0x9296> {
7749 static const char* GetVRString() { return "FD"; }
7750 typedef VRToType<VR::FD>::Type Type;
7751 enum : long long { VRType = VR::FD };
7752 enum { VMType = VM::VM1 };
7753 static const char* GetVMString() { return "1"; }
7754 };
7755 template <> struct TagToType<0x0018,0x9297> {
7756 static const char* GetVRString() { return "CS"; }
7757 typedef VRToType<VR::CS>::Type Type;
7758 enum : long long { VRType = VR::CS };
7759 enum { VMType = VM::VM1 };
7760 static const char* GetVMString() { return "1"; }
7761 };
7762 template <> struct TagToType<0x0018,0x9298> {
7763 static const char* GetVRString() { return "IS"; }
7764 typedef VRToType<VR::IS>::Type Type;
7765 enum : long long { VRType = VR::IS };
7766 enum { VMType = VM::VM1 };
7767 static const char* GetVMString() { return "1"; }
7768 };
7769 template <> struct TagToType<0x0018,0x9301> {
7770 static const char* GetVRString() { return "SQ"; }
7771 typedef VRToType<VR::SQ>::Type Type;
7772 enum : long long { VRType = VR::SQ };
7773 enum { VMType = VM::VM1 };
7774 static const char* GetVMString() { return "1"; }
7775 };
7776 template <> struct TagToType<0x0018,0x9302> {
7777 static const char* GetVRString() { return "CS"; }
7778 typedef VRToType<VR::CS>::Type Type;
7779 enum : long long { VRType = VR::CS };
7780 enum { VMType = VM::VM1 };
7781 static const char* GetVMString() { return "1"; }
7782 };
7783 template <> struct TagToType<0x0018,0x9303> {
7784 static const char* GetVRString() { return "FD"; }
7785 typedef VRToType<VR::FD>::Type Type;
7786 enum : long long { VRType = VR::FD };
7787 enum { VMType = VM::VM1 };
7788 static const char* GetVMString() { return "1"; }
7789 };
7790 template <> struct TagToType<0x0018,0x9304> {
7791 static const char* GetVRString() { return "SQ"; }
7792 typedef VRToType<VR::SQ>::Type Type;
7793 enum : long long { VRType = VR::SQ };
7794 enum { VMType = VM::VM1 };
7795 static const char* GetVMString() { return "1"; }
7796 };
7797 template <> struct TagToType<0x0018,0x9305> {
7798 static const char* GetVRString() { return "FD"; }
7799 typedef VRToType<VR::FD>::Type Type;
7800 enum : long long { VRType = VR::FD };
7801 enum { VMType = VM::VM1 };
7802 static const char* GetVMString() { return "1"; }
7803 };
7804 template <> struct TagToType<0x0018,0x9306> {
7805 static const char* GetVRString() { return "FD"; }
7806 typedef VRToType<VR::FD>::Type Type;
7807 enum : long long { VRType = VR::FD };
7808 enum { VMType = VM::VM1 };
7809 static const char* GetVMString() { return "1"; }
7810 };
7811 template <> struct TagToType<0x0018,0x9307> {
7812 static const char* GetVRString() { return "FD"; }
7813 typedef VRToType<VR::FD>::Type Type;
7814 enum : long long { VRType = VR::FD };
7815 enum { VMType = VM::VM1 };
7816 static const char* GetVMString() { return "1"; }
7817 };
7818 template <> struct TagToType<0x0018,0x9308> {
7819 static const char* GetVRString() { return "SQ"; }
7820 typedef VRToType<VR::SQ>::Type Type;
7821 enum : long long { VRType = VR::SQ };
7822 enum { VMType = VM::VM1 };
7823 static const char* GetVMString() { return "1"; }
7824 };
7825 template <> struct TagToType<0x0018,0x9309> {
7826 static const char* GetVRString() { return "FD"; }
7827 typedef VRToType<VR::FD>::Type Type;
7828 enum : long long { VRType = VR::FD };
7829 enum { VMType = VM::VM1 };
7830 static const char* GetVMString() { return "1"; }
7831 };
7832 template <> struct TagToType<0x0018,0x9310> {
7833 static const char* GetVRString() { return "FD"; }
7834 typedef VRToType<VR::FD>::Type Type;
7835 enum : long long { VRType = VR::FD };
7836 enum { VMType = VM::VM1 };
7837 static const char* GetVMString() { return "1"; }
7838 };
7839 template <> struct TagToType<0x0018,0x9311> {
7840 static const char* GetVRString() { return "FD"; }
7841 typedef VRToType<VR::FD>::Type Type;
7842 enum : long long { VRType = VR::FD };
7843 enum { VMType = VM::VM1 };
7844 static const char* GetVMString() { return "1"; }
7845 };
7846 template <> struct TagToType<0x0018,0x9312> {
7847 static const char* GetVRString() { return "SQ"; }
7848 typedef VRToType<VR::SQ>::Type Type;
7849 enum : long long { VRType = VR::SQ };
7850 enum { VMType = VM::VM1 };
7851 static const char* GetVMString() { return "1"; }
7852 };
7853 template <> struct TagToType<0x0018,0x9313> {
7854 static const char* GetVRString() { return "FD"; }
7855 typedef VRToType<VR::FD>::Type Type;
7856 enum : long long { VRType = VR::FD };
7857 enum { VMType = VM::VM3 };
7858 static const char* GetVMString() { return "3"; }
7859 };
7860 template <> struct TagToType<0x0018,0x9314> {
7861 static const char* GetVRString() { return "SQ"; }
7862 typedef VRToType<VR::SQ>::Type Type;
7863 enum : long long { VRType = VR::SQ };
7864 enum { VMType = VM::VM1 };
7865 static const char* GetVMString() { return "1"; }
7866 };
7867 template <> struct TagToType<0x0018,0x9315> {
7868 static const char* GetVRString() { return "CS"; }
7869 typedef VRToType<VR::CS>::Type Type;
7870 enum : long long { VRType = VR::CS };
7871 enum { VMType = VM::VM1 };
7872 static const char* GetVMString() { return "1"; }
7873 };
7874 template <> struct TagToType<0x0018,0x9316> {
7875 static const char* GetVRString() { return "CS"; }
7876 typedef VRToType<VR::CS>::Type Type;
7877 enum : long long { VRType = VR::CS };
7878 enum { VMType = VM::VM1 };
7879 static const char* GetVMString() { return "1"; }
7880 };
7881 template <> struct TagToType<0x0018,0x9317> {
7882 static const char* GetVRString() { return "FD"; }
7883 typedef VRToType<VR::FD>::Type Type;
7884 enum : long long { VRType = VR::FD };
7885 enum { VMType = VM::VM2 };
7886 static const char* GetVMString() { return "2"; }
7887 };
7888 template <> struct TagToType<0x0018,0x9318> {
7889 static const char* GetVRString() { return "FD"; }
7890 typedef VRToType<VR::FD>::Type Type;
7891 enum : long long { VRType = VR::FD };
7892 enum { VMType = VM::VM3 };
7893 static const char* GetVMString() { return "3"; }
7894 };
7895 template <> struct TagToType<0x0018,0x9319> {
7896 static const char* GetVRString() { return "FD"; }
7897 typedef VRToType<VR::FD>::Type Type;
7898 enum : long long { VRType = VR::FD };
7899 enum { VMType = VM::VM1 };
7900 static const char* GetVMString() { return "1"; }
7901 };
7902 template <> struct TagToType<0x0018,0x9320> {
7903 static const char* GetVRString() { return "SH"; }
7904 typedef VRToType<VR::SH>::Type Type;
7905 enum : long long { VRType = VR::SH };
7906 enum { VMType = VM::VM1 };
7907 static const char* GetVMString() { return "1"; }
7908 };
7909 template <> struct TagToType<0x0018,0x9321> {
7910 static const char* GetVRString() { return "SQ"; }
7911 typedef VRToType<VR::SQ>::Type Type;
7912 enum : long long { VRType = VR::SQ };
7913 enum { VMType = VM::VM1 };
7914 static const char* GetVMString() { return "1"; }
7915 };
7916 template <> struct TagToType<0x0018,0x9322> {
7917 static const char* GetVRString() { return "FD"; }
7918 typedef VRToType<VR::FD>::Type Type;
7919 enum : long long { VRType = VR::FD };
7920 enum { VMType = VM::VM2 };
7921 static const char* GetVMString() { return "2"; }
7922 };
7923 template <> struct TagToType<0x0018,0x9323> {
7924 static const char* GetVRString() { return "CS"; }
7925 typedef VRToType<VR::CS>::Type Type;
7926 enum : long long { VRType = VR::CS };
7927 enum { VMType = VM::VM1_n };
7928 static const char* GetVMString() { return "1-n"; }
7929 };
7930 template <> struct TagToType<0x0018,0x9324> {
7931 static const char* GetVRString() { return "FD"; }
7932 typedef VRToType<VR::FD>::Type Type;
7933 enum : long long { VRType = VR::FD };
7934 enum { VMType = VM::VM1 };
7935 static const char* GetVMString() { return "1"; }
7936 };
7937 template <> struct TagToType<0x0018,0x9325> {
7938 static const char* GetVRString() { return "SQ"; }
7939 typedef VRToType<VR::SQ>::Type Type;
7940 enum : long long { VRType = VR::SQ };
7941 enum { VMType = VM::VM1 };
7942 static const char* GetVMString() { return "1"; }
7943 };
7944 template <> struct TagToType<0x0018,0x9326> {
7945 static const char* GetVRString() { return "SQ"; }
7946 typedef VRToType<VR::SQ>::Type Type;
7947 enum : long long { VRType = VR::SQ };
7948 enum { VMType = VM::VM1 };
7949 static const char* GetVMString() { return "1"; }
7950 };
7951 template <> struct TagToType<0x0018,0x9327> {
7952 static const char* GetVRString() { return "FD"; }
7953 typedef VRToType<VR::FD>::Type Type;
7954 enum : long long { VRType = VR::FD };
7955 enum { VMType = VM::VM1 };
7956 static const char* GetVMString() { return "1"; }
7957 };
7958 template <> struct TagToType<0x0018,0x9328> {
7959 static const char* GetVRString() { return "FD"; }
7960 typedef VRToType<VR::FD>::Type Type;
7961 enum : long long { VRType = VR::FD };
7962 enum { VMType = VM::VM1 };
7963 static const char* GetVMString() { return "1"; }
7964 };
7965 template <> struct TagToType<0x0018,0x9329> {
7966 static const char* GetVRString() { return "SQ"; }
7967 typedef VRToType<VR::SQ>::Type Type;
7968 enum : long long { VRType = VR::SQ };
7969 enum { VMType = VM::VM1 };
7970 static const char* GetVMString() { return "1"; }
7971 };
7972 template <> struct TagToType<0x0018,0x9330> {
7973 static const char* GetVRString() { return "FD"; }
7974 typedef VRToType<VR::FD>::Type Type;
7975 enum : long long { VRType = VR::FD };
7976 enum { VMType = VM::VM1 };
7977 static const char* GetVMString() { return "1"; }
7978 };
7979 template <> struct TagToType<0x0018,0x9332> {
7980 static const char* GetVRString() { return "FD"; }
7981 typedef VRToType<VR::FD>::Type Type;
7982 enum : long long { VRType = VR::FD };
7983 enum { VMType = VM::VM1 };
7984 static const char* GetVMString() { return "1"; }
7985 };
7986 template <> struct TagToType<0x0018,0x9333> {
7987 static const char* GetVRString() { return "CS"; }
7988 typedef VRToType<VR::CS>::Type Type;
7989 enum : long long { VRType = VR::CS };
7990 enum { VMType = VM::VM1 };
7991 static const char* GetVMString() { return "1"; }
7992 };
7993 template <> struct TagToType<0x0018,0x9334> {
7994 static const char* GetVRString() { return "CS"; }
7995 typedef VRToType<VR::CS>::Type Type;
7996 enum : long long { VRType = VR::CS };
7997 enum { VMType = VM::VM1 };
7998 static const char* GetVMString() { return "1"; }
7999 };
8000 template <> struct TagToType<0x0018,0x9335> {
8001 static const char* GetVRString() { return "FD"; }
8002 typedef VRToType<VR::FD>::Type Type;
8003 enum : long long { VRType = VR::FD };
8004 enum { VMType = VM::VM1 };
8005 static const char* GetVMString() { return "1"; }
8006 };
8007 template <> struct TagToType<0x0018,0x9337> {
8008 static const char* GetVRString() { return "US"; }
8009 typedef VRToType<VR::US>::Type Type;
8010 enum : long long { VRType = VR::US };
8011 enum { VMType = VM::VM1 };
8012 static const char* GetVMString() { return "1"; }
8013 };
8014 template <> struct TagToType<0x0018,0x9338> {
8015 static const char* GetVRString() { return "SQ"; }
8016 typedef VRToType<VR::SQ>::Type Type;
8017 enum : long long { VRType = VR::SQ };
8018 enum { VMType = VM::VM1 };
8019 static const char* GetVMString() { return "1"; }
8020 };
8021 template <> struct TagToType<0x0018,0x9340> {
8022 static const char* GetVRString() { return "SQ"; }
8023 typedef VRToType<VR::SQ>::Type Type;
8024 enum : long long { VRType = VR::SQ };
8025 enum { VMType = VM::VM1 };
8026 static const char* GetVMString() { return "1"; }
8027 };
8028 template <> struct TagToType<0x0018,0x9341> {
8029 static const char* GetVRString() { return "SQ"; }
8030 typedef VRToType<VR::SQ>::Type Type;
8031 enum : long long { VRType = VR::SQ };
8032 enum { VMType = VM::VM1 };
8033 static const char* GetVMString() { return "1"; }
8034 };
8035 template <> struct TagToType<0x0018,0x9342> {
8036 static const char* GetVRString() { return "CS"; }
8037 typedef VRToType<VR::CS>::Type Type;
8038 enum : long long { VRType = VR::CS };
8039 enum { VMType = VM::VM1 };
8040 static const char* GetVMString() { return "1"; }
8041 };
8042 template <> struct TagToType<0x0018,0x9343> {
8043 static const char* GetVRString() { return "CS"; }
8044 typedef VRToType<VR::CS>::Type Type;
8045 enum : long long { VRType = VR::CS };
8046 enum { VMType = VM::VM1 };
8047 static const char* GetVMString() { return "1"; }
8048 };
8049 template <> struct TagToType<0x0018,0x9344> {
8050 static const char* GetVRString() { return "CS"; }
8051 typedef VRToType<VR::CS>::Type Type;
8052 enum : long long { VRType = VR::CS };
8053 enum { VMType = VM::VM1 };
8054 static const char* GetVMString() { return "1"; }
8055 };
8056 template <> struct TagToType<0x0018,0x9345> {
8057 static const char* GetVRString() { return "FD"; }
8058 typedef VRToType<VR::FD>::Type Type;
8059 enum : long long { VRType = VR::FD };
8060 enum { VMType = VM::VM1 };
8061 static const char* GetVMString() { return "1"; }
8062 };
8063 template <> struct TagToType<0x0018,0x9346> {
8064 static const char* GetVRString() { return "SQ"; }
8065 typedef VRToType<VR::SQ>::Type Type;
8066 enum : long long { VRType = VR::SQ };
8067 enum { VMType = VM::VM1 };
8068 static const char* GetVMString() { return "1"; }
8069 };
8070 template <> struct TagToType<0x0018,0x9351> {
8071 static const char* GetVRString() { return "FL"; }
8072 typedef VRToType<VR::FL>::Type Type;
8073 enum : long long { VRType = VR::FL };
8074 enum { VMType = VM::VM1 };
8075 static const char* GetVMString() { return "1"; }
8076 };
8077 template <> struct TagToType<0x0018,0x9352> {
8078 static const char* GetVRString() { return "FL"; }
8079 typedef VRToType<VR::FL>::Type Type;
8080 enum : long long { VRType = VR::FL };
8081 enum { VMType = VM::VM3 };
8082 static const char* GetVMString() { return "3"; }
8083 };
8084 template <> struct TagToType<0x0018,0x9353> {
8085 static const char* GetVRString() { return "FL"; }
8086 typedef VRToType<VR::FL>::Type Type;
8087 enum : long long { VRType = VR::FL };
8088 enum { VMType = VM::VM1 };
8089 static const char* GetVMString() { return "1"; }
8090 };
8091 template <> struct TagToType<0x0018,0x9360> {
8092 static const char* GetVRString() { return "SQ"; }
8093 typedef VRToType<VR::SQ>::Type Type;
8094 enum : long long { VRType = VR::SQ };
8095 enum { VMType = VM::VM1 };
8096 static const char* GetVMString() { return "1"; }
8097 };
8098 template <> struct TagToType<0x0018,0x9401> {
8099 static const char* GetVRString() { return "SQ"; }
8100 typedef VRToType<VR::SQ>::Type Type;
8101 enum : long long { VRType = VR::SQ };
8102 enum { VMType = VM::VM1 };
8103 static const char* GetVMString() { return "1"; }
8104 };
8105 template <> struct TagToType<0x0018,0x9402> {
8106 static const char* GetVRString() { return "FL"; }
8107 typedef VRToType<VR::FL>::Type Type;
8108 enum : long long { VRType = VR::FL };
8109 enum { VMType = VM::VM1 };
8110 static const char* GetVMString() { return "1"; }
8111 };
8112 template <> struct TagToType<0x0018,0x9403> {
8113 static const char* GetVRString() { return "FL"; }
8114 typedef VRToType<VR::FL>::Type Type;
8115 enum : long long { VRType = VR::FL };
8116 enum { VMType = VM::VM1 };
8117 static const char* GetVMString() { return "1"; }
8118 };
8119 template <> struct TagToType<0x0018,0x9404> {
8120 static const char* GetVRString() { return "FL"; }
8121 typedef VRToType<VR::FL>::Type Type;
8122 enum : long long { VRType = VR::FL };
8123 enum { VMType = VM::VM2 };
8124 static const char* GetVMString() { return "2"; }
8125 };
8126 template <> struct TagToType<0x0018,0x9405> {
8127 static const char* GetVRString() { return "SQ"; }
8128 typedef VRToType<VR::SQ>::Type Type;
8129 enum : long long { VRType = VR::SQ };
8130 enum { VMType = VM::VM1 };
8131 static const char* GetVMString() { return "1"; }
8132 };
8133 template <> struct TagToType<0x0018,0x9406> {
8134 static const char* GetVRString() { return "SQ"; }
8135 typedef VRToType<VR::SQ>::Type Type;
8136 enum : long long { VRType = VR::SQ };
8137 enum { VMType = VM::VM1 };
8138 static const char* GetVMString() { return "1"; }
8139 };
8140 template <> struct TagToType<0x0018,0x9407> {
8141 static const char* GetVRString() { return "SQ"; }
8142 typedef VRToType<VR::SQ>::Type Type;
8143 enum : long long { VRType = VR::SQ };
8144 enum { VMType = VM::VM1 };
8145 static const char* GetVMString() { return "1"; }
8146 };
8147 template <> struct TagToType<0x0018,0x9410> {
8148 static const char* GetVRString() { return "CS"; }
8149 typedef VRToType<VR::CS>::Type Type;
8150 enum : long long { VRType = VR::CS };
8151 enum { VMType = VM::VM1 };
8152 static const char* GetVMString() { return "1"; }
8153 };
8154 template <> struct TagToType<0x0018,0x9412> {
8155 static const char* GetVRString() { return "SQ"; }
8156 typedef VRToType<VR::SQ>::Type Type;
8157 enum : long long { VRType = VR::SQ };
8158 enum { VMType = VM::VM1 };
8159 static const char* GetVMString() { return "1"; }
8160 };
8161 template <> struct TagToType<0x0018,0x9417> {
8162 static const char* GetVRString() { return "SQ"; }
8163 typedef VRToType<VR::SQ>::Type Type;
8164 enum : long long { VRType = VR::SQ };
8165 enum { VMType = VM::VM1 };
8166 static const char* GetVMString() { return "1"; }
8167 };
8168 template <> struct TagToType<0x0018,0x9420> {
8169 static const char* GetVRString() { return "CS"; }
8170 typedef VRToType<VR::CS>::Type Type;
8171 enum : long long { VRType = VR::CS };
8172 enum { VMType = VM::VM1 };
8173 static const char* GetVMString() { return "1"; }
8174 };
8175 template <> struct TagToType<0x0018,0x9423> {
8176 static const char* GetVRString() { return "LO"; }
8177 typedef VRToType<VR::LO>::Type Type;
8178 enum : long long { VRType = VR::LO };
8179 enum { VMType = VM::VM1 };
8180 static const char* GetVMString() { return "1"; }
8181 };
8182 template <> struct TagToType<0x0018,0x9424> {
8183 static const char* GetVRString() { return "LT"; }
8184 typedef VRToType<VR::LT>::Type Type;
8185 enum : long long { VRType = VR::LT };
8186 enum { VMType = VM::VM1 };
8187 static const char* GetVMString() { return "1"; }
8188 };
8189 template <> struct TagToType<0x0018,0x9425> {
8190 static const char* GetVRString() { return "CS"; }
8191 typedef VRToType<VR::CS>::Type Type;
8192 enum : long long { VRType = VR::CS };
8193 enum { VMType = VM::VM1 };
8194 static const char* GetVMString() { return "1"; }
8195 };
8196 template <> struct TagToType<0x0018,0x9426> {
8197 static const char* GetVRString() { return "FL"; }
8198 typedef VRToType<VR::FL>::Type Type;
8199 enum : long long { VRType = VR::FL };
8200 enum { VMType = VM::VM1 };
8201 static const char* GetVMString() { return "1"; }
8202 };
8203 template <> struct TagToType<0x0018,0x9427> {
8204 static const char* GetVRString() { return "CS"; }
8205 typedef VRToType<VR::CS>::Type Type;
8206 enum : long long { VRType = VR::CS };
8207 enum { VMType = VM::VM1 };
8208 static const char* GetVMString() { return "1"; }
8209 };
8210 template <> struct TagToType<0x0018,0x9428> {
8211 static const char* GetVRString() { return "FL"; }
8212 typedef VRToType<VR::FL>::Type Type;
8213 enum : long long { VRType = VR::FL };
8214 enum { VMType = VM::VM1_2 };
8215 static const char* GetVMString() { return "1-2"; }
8216 };
8217 template <> struct TagToType<0x0018,0x9429> {
8218 static const char* GetVRString() { return "FL"; }
8219 typedef VRToType<VR::FL>::Type Type;
8220 enum : long long { VRType = VR::FL };
8221 enum { VMType = VM::VM2 };
8222 static const char* GetVMString() { return "2"; }
8223 };
8224 template <> struct TagToType<0x0018,0x9430> {
8225 static const char* GetVRString() { return "FL"; }
8226 typedef VRToType<VR::FL>::Type Type;
8227 enum : long long { VRType = VR::FL };
8228 enum { VMType = VM::VM2 };
8229 static const char* GetVMString() { return "2"; }
8230 };
8231 template <> struct TagToType<0x0018,0x9432> {
8232 static const char* GetVRString() { return "SQ"; }
8233 typedef VRToType<VR::SQ>::Type Type;
8234 enum : long long { VRType = VR::SQ };
8235 enum { VMType = VM::VM1 };
8236 static const char* GetVMString() { return "1"; }
8237 };
8238 template <> struct TagToType<0x0018,0x9433> {
8239 static const char* GetVRString() { return "LO"; }
8240 typedef VRToType<VR::LO>::Type Type;
8241 enum : long long { VRType = VR::LO };
8242 enum { VMType = VM::VM1 };
8243 static const char* GetVMString() { return "1"; }
8244 };
8245 template <> struct TagToType<0x0018,0x9434> {
8246 static const char* GetVRString() { return "SQ"; }
8247 typedef VRToType<VR::SQ>::Type Type;
8248 enum : long long { VRType = VR::SQ };
8249 enum { VMType = VM::VM1 };
8250 static const char* GetVMString() { return "1"; }
8251 };
8252 template <> struct TagToType<0x0018,0x9435> {
8253 static const char* GetVRString() { return "CS"; }
8254 typedef VRToType<VR::CS>::Type Type;
8255 enum : long long { VRType = VR::CS };
8256 enum { VMType = VM::VM1 };
8257 static const char* GetVMString() { return "1"; }
8258 };
8259 template <> struct TagToType<0x0018,0x9436> {
8260 static const char* GetVRString() { return "SS"; }
8261 typedef VRToType<VR::SS>::Type Type;
8262 enum : long long { VRType = VR::SS };
8263 enum { VMType = VM::VM1 };
8264 static const char* GetVMString() { return "1"; }
8265 };
8266 template <> struct TagToType<0x0018,0x9437> {
8267 static const char* GetVRString() { return "SS"; }
8268 typedef VRToType<VR::SS>::Type Type;
8269 enum : long long { VRType = VR::SS };
8270 enum { VMType = VM::VM1 };
8271 static const char* GetVMString() { return "1"; }
8272 };
8273 template <> struct TagToType<0x0018,0x9438> {
8274 static const char* GetVRString() { return "SS"; }
8275 typedef VRToType<VR::SS>::Type Type;
8276 enum : long long { VRType = VR::SS };
8277 enum { VMType = VM::VM1 };
8278 static const char* GetVMString() { return "1"; }
8279 };
8280 template <> struct TagToType<0x0018,0x9439> {
8281 static const char* GetVRString() { return "SS"; }
8282 typedef VRToType<VR::SS>::Type Type;
8283 enum : long long { VRType = VR::SS };
8284 enum { VMType = VM::VM1 };
8285 static const char* GetVMString() { return "1"; }
8286 };
8287 template <> struct TagToType<0x0018,0x9440> {
8288 static const char* GetVRString() { return "SS"; }
8289 typedef VRToType<VR::SS>::Type Type;
8290 enum : long long { VRType = VR::SS };
8291 enum { VMType = VM::VM2 };
8292 static const char* GetVMString() { return "2"; }
8293 };
8294 template <> struct TagToType<0x0018,0x9441> {
8295 static const char* GetVRString() { return "US"; }
8296 typedef VRToType<VR::US>::Type Type;
8297 enum : long long { VRType = VR::US };
8298 enum { VMType = VM::VM1 };
8299 static const char* GetVMString() { return "1"; }
8300 };
8301 template <> struct TagToType<0x0018,0x9442> {
8302 static const char* GetVRString() { return "SS"; }
8303 typedef VRToType<VR::SS>::Type Type;
8304 enum : long long { VRType = VR::SS };
8305 enum { VMType = VM::VM2_n };
8306 static const char* GetVMString() { return "2-n"; }
8307 };
8308 template <> struct TagToType<0x0018,0x9447> {
8309 static const char* GetVRString() { return "FL"; }
8310 typedef VRToType<VR::FL>::Type Type;
8311 enum : long long { VRType = VR::FL };
8312 enum { VMType = VM::VM1 };
8313 static const char* GetVMString() { return "1"; }
8314 };
8315 template <> struct TagToType<0x0018,0x9449> {
8316 static const char* GetVRString() { return "FL"; }
8317 typedef VRToType<VR::FL>::Type Type;
8318 enum : long long { VRType = VR::FL };
8319 enum { VMType = VM::VM1 };
8320 static const char* GetVMString() { return "1"; }
8321 };
8322 template <> struct TagToType<0x0018,0x9451> {
8323 static const char* GetVRString() { return "SQ"; }
8324 typedef VRToType<VR::SQ>::Type Type;
8325 enum : long long { VRType = VR::SQ };
8326 enum { VMType = VM::VM1 };
8327 static const char* GetVMString() { return "1"; }
8328 };
8329 template <> struct TagToType<0x0018,0x9452> {
8330 static const char* GetVRString() { return "FL"; }
8331 typedef VRToType<VR::FL>::Type Type;
8332 enum : long long { VRType = VR::FL };
8333 enum { VMType = VM::VM1 };
8334 static const char* GetVMString() { return "1"; }
8335 };
8336 template <> struct TagToType<0x0018,0x9455> {
8337 static const char* GetVRString() { return "SQ"; }
8338 typedef VRToType<VR::SQ>::Type Type;
8339 enum : long long { VRType = VR::SQ };
8340 enum { VMType = VM::VM1 };
8341 static const char* GetVMString() { return "1"; }
8342 };
8343 template <> struct TagToType<0x0018,0x9456> {
8344 static const char* GetVRString() { return "SQ"; }
8345 typedef VRToType<VR::SQ>::Type Type;
8346 enum : long long { VRType = VR::SQ };
8347 enum { VMType = VM::VM1 };
8348 static const char* GetVMString() { return "1"; }
8349 };
8350 template <> struct TagToType<0x0018,0x9457> {
8351 static const char* GetVRString() { return "CS"; }
8352 typedef VRToType<VR::CS>::Type Type;
8353 enum : long long { VRType = VR::CS };
8354 enum { VMType = VM::VM1 };
8355 static const char* GetVMString() { return "1"; }
8356 };
8357 template <> struct TagToType<0x0018,0x9461> {
8358 static const char* GetVRString() { return "FL"; }
8359 typedef VRToType<VR::FL>::Type Type;
8360 enum : long long { VRType = VR::FL };
8361 enum { VMType = VM::VM1_2 };
8362 static const char* GetVMString() { return "1-2"; }
8363 };
8364 template <> struct TagToType<0x0018,0x9462> {
8365 static const char* GetVRString() { return "SQ"; }
8366 typedef VRToType<VR::SQ>::Type Type;
8367 enum : long long { VRType = VR::SQ };
8368 enum { VMType = VM::VM1 };
8369 static const char* GetVMString() { return "1"; }
8370 };
8371 template <> struct TagToType<0x0018,0x9463> {
8372 static const char* GetVRString() { return "FL"; }
8373 typedef VRToType<VR::FL>::Type Type;
8374 enum : long long { VRType = VR::FL };
8375 enum { VMType = VM::VM1 };
8376 static const char* GetVMString() { return "1"; }
8377 };
8378 template <> struct TagToType<0x0018,0x9464> {
8379 static const char* GetVRString() { return "FL"; }
8380 typedef VRToType<VR::FL>::Type Type;
8381 enum : long long { VRType = VR::FL };
8382 enum { VMType = VM::VM1 };
8383 static const char* GetVMString() { return "1"; }
8384 };
8385 template <> struct TagToType<0x0018,0x9465> {
8386 static const char* GetVRString() { return "FL"; }
8387 typedef VRToType<VR::FL>::Type Type;
8388 enum : long long { VRType = VR::FL };
8389 enum { VMType = VM::VM1 };
8390 static const char* GetVMString() { return "1"; }
8391 };
8392 template <> struct TagToType<0x0018,0x9466> {
8393 static const char* GetVRString() { return "FL"; }
8394 typedef VRToType<VR::FL>::Type Type;
8395 enum : long long { VRType = VR::FL };
8396 enum { VMType = VM::VM1 };
8397 static const char* GetVMString() { return "1"; }
8398 };
8399 template <> struct TagToType<0x0018,0x9467> {
8400 static const char* GetVRString() { return "FL"; }
8401 typedef VRToType<VR::FL>::Type Type;
8402 enum : long long { VRType = VR::FL };
8403 enum { VMType = VM::VM1 };
8404 static const char* GetVMString() { return "1"; }
8405 };
8406 template <> struct TagToType<0x0018,0x9468> {
8407 static const char* GetVRString() { return "FL"; }
8408 typedef VRToType<VR::FL>::Type Type;
8409 enum : long long { VRType = VR::FL };
8410 enum { VMType = VM::VM1 };
8411 static const char* GetVMString() { return "1"; }
8412 };
8413 template <> struct TagToType<0x0018,0x9469> {
8414 static const char* GetVRString() { return "FL"; }
8415 typedef VRToType<VR::FL>::Type Type;
8416 enum : long long { VRType = VR::FL };
8417 enum { VMType = VM::VM1 };
8418 static const char* GetVMString() { return "1"; }
8419 };
8420 template <> struct TagToType<0x0018,0x9470> {
8421 static const char* GetVRString() { return "FL"; }
8422 typedef VRToType<VR::FL>::Type Type;
8423 enum : long long { VRType = VR::FL };
8424 enum { VMType = VM::VM1 };
8425 static const char* GetVMString() { return "1"; }
8426 };
8427 template <> struct TagToType<0x0018,0x9471> {
8428 static const char* GetVRString() { return "FL"; }
8429 typedef VRToType<VR::FL>::Type Type;
8430 enum : long long { VRType = VR::FL };
8431 enum { VMType = VM::VM1 };
8432 static const char* GetVMString() { return "1"; }
8433 };
8434 template <> struct TagToType<0x0018,0x9472> {
8435 static const char* GetVRString() { return "SQ"; }
8436 typedef VRToType<VR::SQ>::Type Type;
8437 enum : long long { VRType = VR::SQ };
8438 enum { VMType = VM::VM1 };
8439 static const char* GetVMString() { return "1"; }
8440 };
8441 template <> struct TagToType<0x0018,0x9473> {
8442 static const char* GetVRString() { return "FL"; }
8443 typedef VRToType<VR::FL>::Type Type;
8444 enum : long long { VRType = VR::FL };
8445 enum { VMType = VM::VM1 };
8446 static const char* GetVMString() { return "1"; }
8447 };
8448 template <> struct TagToType<0x0018,0x9474> {
8449 static const char* GetVRString() { return "CS"; }
8450 typedef VRToType<VR::CS>::Type Type;
8451 enum : long long { VRType = VR::CS };
8452 enum { VMType = VM::VM1 };
8453 static const char* GetVMString() { return "1"; }
8454 };
8455 template <> struct TagToType<0x0018,0x9476> {
8456 static const char* GetVRString() { return "SQ"; }
8457 typedef VRToType<VR::SQ>::Type Type;
8458 enum : long long { VRType = VR::SQ };
8459 enum { VMType = VM::VM1 };
8460 static const char* GetVMString() { return "1"; }
8461 };
8462 template <> struct TagToType<0x0018,0x9477> {
8463 static const char* GetVRString() { return "SQ"; }
8464 typedef VRToType<VR::SQ>::Type Type;
8465 enum : long long { VRType = VR::SQ };
8466 enum { VMType = VM::VM1 };
8467 static const char* GetVMString() { return "1"; }
8468 };
8469 template <> struct TagToType<0x0018,0x9504> {
8470 static const char* GetVRString() { return "SQ"; }
8471 typedef VRToType<VR::SQ>::Type Type;
8472 enum : long long { VRType = VR::SQ };
8473 enum { VMType = VM::VM1 };
8474 static const char* GetVMString() { return "1"; }
8475 };
8476 template <> struct TagToType<0x0018,0x9506> {
8477 static const char* GetVRString() { return "SQ"; }
8478 typedef VRToType<VR::SQ>::Type Type;
8479 enum : long long { VRType = VR::SQ };
8480 enum { VMType = VM::VM1 };
8481 static const char* GetVMString() { return "1"; }
8482 };
8483 template <> struct TagToType<0x0018,0x9507> {
8484 static const char* GetVRString() { return "SQ"; }
8485 typedef VRToType<VR::SQ>::Type Type;
8486 enum : long long { VRType = VR::SQ };
8487 enum { VMType = VM::VM1 };
8488 static const char* GetVMString() { return "1"; }
8489 };
8490 template <> struct TagToType<0x0018,0x9508> {
8491 static const char* GetVRString() { return "FL"; }
8492 typedef VRToType<VR::FL>::Type Type;
8493 enum : long long { VRType = VR::FL };
8494 enum { VMType = VM::VM1 };
8495 static const char* GetVMString() { return "1"; }
8496 };
8497 template <> struct TagToType<0x0018,0x9509> {
8498 static const char* GetVRString() { return "FL"; }
8499 typedef VRToType<VR::FL>::Type Type;
8500 enum : long long { VRType = VR::FL };
8501 enum { VMType = VM::VM1 };
8502 static const char* GetVMString() { return "1"; }
8503 };
8504 template <> struct TagToType<0x0018,0x9510> {
8505 static const char* GetVRString() { return "FL"; }
8506 typedef VRToType<VR::FL>::Type Type;
8507 enum : long long { VRType = VR::FL };
8508 enum { VMType = VM::VM1 };
8509 static const char* GetVMString() { return "1"; }
8510 };
8511 template <> struct TagToType<0x0018,0x9511> {
8512 static const char* GetVRString() { return "FL"; }
8513 typedef VRToType<VR::FL>::Type Type;
8514 enum : long long { VRType = VR::FL };
8515 enum { VMType = VM::VM1 };
8516 static const char* GetVMString() { return "1"; }
8517 };
8518 template <> struct TagToType<0x0018,0x9514> {
8519 static const char* GetVRString() { return "FL"; }
8520 typedef VRToType<VR::FL>::Type Type;
8521 enum : long long { VRType = VR::FL };
8522 enum { VMType = VM::VM1 };
8523 static const char* GetVMString() { return "1"; }
8524 };
8525 template <> struct TagToType<0x0018,0x9515> {
8526 static const char* GetVRString() { return "FL"; }
8527 typedef VRToType<VR::FL>::Type Type;
8528 enum : long long { VRType = VR::FL };
8529 enum { VMType = VM::VM1 };
8530 static const char* GetVMString() { return "1"; }
8531 };
8532 template <> struct TagToType<0x0018,0x9516> {
8533 static const char* GetVRString() { return "DT"; }
8534 typedef VRToType<VR::DT>::Type Type;
8535 enum : long long { VRType = VR::DT };
8536 enum { VMType = VM::VM1 };
8537 static const char* GetVMString() { return "1"; }
8538 };
8539 template <> struct TagToType<0x0018,0x9517> {
8540 static const char* GetVRString() { return "DT"; }
8541 typedef VRToType<VR::DT>::Type Type;
8542 enum : long long { VRType = VR::DT };
8543 enum { VMType = VM::VM1 };
8544 static const char* GetVMString() { return "1"; }
8545 };
8546 template <> struct TagToType<0x0018,0x9518> {
8547 static const char* GetVRString() { return "SS"; }
8548 typedef VRToType<VR::SS>::Type Type;
8549 enum : long long { VRType = VR::SS };
8550 enum { VMType = VM::VM1 };
8551 static const char* GetVMString() { return "1"; }
8552 };
8553 template <> struct TagToType<0x0018,0x9519> {
8554 static const char* GetVRString() { return "SS"; }
8555 typedef VRToType<VR::SS>::Type Type;
8556 enum : long long { VRType = VR::SS };
8557 enum { VMType = VM::VM1 };
8558 static const char* GetVMString() { return "1"; }
8559 };
8560 template <> struct TagToType<0x0018,0x9524> {
8561 static const char* GetVRString() { return "LO"; }
8562 typedef VRToType<VR::LO>::Type Type;
8563 enum : long long { VRType = VR::LO };
8564 enum { VMType = VM::VM1 };
8565 static const char* GetVMString() { return "1"; }
8566 };
8567 template <> struct TagToType<0x0018,0x9525> {
8568 static const char* GetVRString() { return "LO"; }
8569 typedef VRToType<VR::LO>::Type Type;
8570 enum : long long { VRType = VR::LO };
8571 enum { VMType = VM::VM1 };
8572 static const char* GetVMString() { return "1"; }
8573 };
8574 template <> struct TagToType<0x0018,0x9526> {
8575 static const char* GetVRString() { return "LO"; }
8576 typedef VRToType<VR::LO>::Type Type;
8577 enum : long long { VRType = VR::LO };
8578 enum { VMType = VM::VM1 };
8579 static const char* GetVMString() { return "1"; }
8580 };
8581 template <> struct TagToType<0x0018,0x9527> {
8582 static const char* GetVRString() { return "CS"; }
8583 typedef VRToType<VR::CS>::Type Type;
8584 enum : long long { VRType = VR::CS };
8585 enum { VMType = VM::VM1 };
8586 static const char* GetVMString() { return "1"; }
8587 };
8588 template <> struct TagToType<0x0018,0x9528> {
8589 static const char* GetVRString() { return "LO"; }
8590 typedef VRToType<VR::LO>::Type Type;
8591 enum : long long { VRType = VR::LO };
8592 enum { VMType = VM::VM1 };
8593 static const char* GetVMString() { return "1"; }
8594 };
8595 template <> struct TagToType<0x0018,0x9530> {
8596 static const char* GetVRString() { return "SQ"; }
8597 typedef VRToType<VR::SQ>::Type Type;
8598 enum : long long { VRType = VR::SQ };
8599 enum { VMType = VM::VM1 };
8600 static const char* GetVMString() { return "1"; }
8601 };
8602 template <> struct TagToType<0x0018,0x9531> {
8603 static const char* GetVRString() { return "LO"; }
8604 typedef VRToType<VR::LO>::Type Type;
8605 enum : long long { VRType = VR::LO };
8606 enum { VMType = VM::VM1 };
8607 static const char* GetVMString() { return "1"; }
8608 };
8609 template <> struct TagToType<0x0018,0x9538> {
8610 static const char* GetVRString() { return "SQ"; }
8611 typedef VRToType<VR::SQ>::Type Type;
8612 enum : long long { VRType = VR::SQ };
8613 enum { VMType = VM::VM1 };
8614 static const char* GetVMString() { return "1"; }
8615 };
8616 template <> struct TagToType<0x0018,0x9541> {
8617 static const char* GetVRString() { return "SQ"; }
8618 typedef VRToType<VR::SQ>::Type Type;
8619 enum : long long { VRType = VR::SQ };
8620 enum { VMType = VM::VM1 };
8621 static const char* GetVMString() { return "1"; }
8622 };
8623 template <> struct TagToType<0x0018,0x9542> {
8624 static const char* GetVRString() { return "SQ"; }
8625 typedef VRToType<VR::SQ>::Type Type;
8626 enum : long long { VRType = VR::SQ };
8627 enum { VMType = VM::VM1 };
8628 static const char* GetVMString() { return "1"; }
8629 };
8630 template <> struct TagToType<0x0018,0x9543> {
8631 static const char* GetVRString() { return "FD"; }
8632 typedef VRToType<VR::FD>::Type Type;
8633 enum : long long { VRType = VR::FD };
8634 enum { VMType = VM::VM1 };
8635 static const char* GetVMString() { return "1"; }
8636 };
8637 template <> struct TagToType<0x0018,0x9544> {
8638 static const char* GetVRString() { return "FD"; }
8639 typedef VRToType<VR::FD>::Type Type;
8640 enum : long long { VRType = VR::FD };
8641 enum { VMType = VM::VM1 };
8642 static const char* GetVMString() { return "1"; }
8643 };
8644 template <> struct TagToType<0x0018,0x9545> {
8645 static const char* GetVRString() { return "FD"; }
8646 typedef VRToType<VR::FD>::Type Type;
8647 enum : long long { VRType = VR::FD };
8648 enum { VMType = VM::VM1 };
8649 static const char* GetVMString() { return "1"; }
8650 };
8651 template <> struct TagToType<0x0018,0x9546> {
8652 static const char* GetVRString() { return "FD"; }
8653 typedef VRToType<VR::FD>::Type Type;
8654 enum : long long { VRType = VR::FD };
8655 enum { VMType = VM::VM1 };
8656 static const char* GetVMString() { return "1"; }
8657 };
8658 template <> struct TagToType<0x0018,0x9547> {
8659 static const char* GetVRString() { return "FD"; }
8660 typedef VRToType<VR::FD>::Type Type;
8661 enum : long long { VRType = VR::FD };
8662 enum { VMType = VM::VM1 };
8663 static const char* GetVMString() { return "1"; }
8664 };
8665 template <> struct TagToType<0x0018,0x9548> {
8666 static const char* GetVRString() { return "FD"; }
8667 typedef VRToType<VR::FD>::Type Type;
8668 enum : long long { VRType = VR::FD };
8669 enum { VMType = VM::VM1 };
8670 static const char* GetVMString() { return "1"; }
8671 };
8672 template <> struct TagToType<0x0018,0x9549> {
8673 static const char* GetVRString() { return "FD"; }
8674 typedef VRToType<VR::FD>::Type Type;
8675 enum : long long { VRType = VR::FD };
8676 enum { VMType = VM::VM1 };
8677 static const char* GetVMString() { return "1"; }
8678 };
8679 template <> struct TagToType<0x0018,0x9550> {
8680 static const char* GetVRString() { return "FD"; }
8681 typedef VRToType<VR::FD>::Type Type;
8682 enum : long long { VRType = VR::FD };
8683 enum { VMType = VM::VM1 };
8684 static const char* GetVMString() { return "1"; }
8685 };
8686 template <> struct TagToType<0x0018,0x9551> {
8687 static const char* GetVRString() { return "FD"; }
8688 typedef VRToType<VR::FD>::Type Type;
8689 enum : long long { VRType = VR::FD };
8690 enum { VMType = VM::VM1 };
8691 static const char* GetVMString() { return "1"; }
8692 };
8693 template <> struct TagToType<0x0018,0x9552> {
8694 static const char* GetVRString() { return "FD"; }
8695 typedef VRToType<VR::FD>::Type Type;
8696 enum : long long { VRType = VR::FD };
8697 enum { VMType = VM::VM1 };
8698 static const char* GetVMString() { return "1"; }
8699 };
8700 template <> struct TagToType<0x0018,0x9553> {
8701 static const char* GetVRString() { return "FD"; }
8702 typedef VRToType<VR::FD>::Type Type;
8703 enum : long long { VRType = VR::FD };
8704 enum { VMType = VM::VM1 };
8705 static const char* GetVMString() { return "1"; }
8706 };
8707 template <> struct TagToType<0x0018,0x9554> {
8708 static const char* GetVRString() { return "FD"; }
8709 typedef VRToType<VR::FD>::Type Type;
8710 enum : long long { VRType = VR::FD };
8711 enum { VMType = VM::VM1 };
8712 static const char* GetVMString() { return "1"; }
8713 };
8714 template <> struct TagToType<0x0018,0x9555> {
8715 static const char* GetVRString() { return "SQ"; }
8716 typedef VRToType<VR::SQ>::Type Type;
8717 enum : long long { VRType = VR::SQ };
8718 enum { VMType = VM::VM1 };
8719 static const char* GetVMString() { return "1"; }
8720 };
8721 template <> struct TagToType<0x0018,0x9556> {
8722 static const char* GetVRString() { return "SQ"; }
8723 typedef VRToType<VR::SQ>::Type Type;
8724 enum : long long { VRType = VR::SQ };
8725 enum { VMType = VM::VM1 };
8726 static const char* GetVMString() { return "1"; }
8727 };
8728 template <> struct TagToType<0x0018,0x9557> {
8729 static const char* GetVRString() { return "FD"; }
8730 typedef VRToType<VR::FD>::Type Type;
8731 enum : long long { VRType = VR::FD };
8732 enum { VMType = VM::VM3 };
8733 static const char* GetVMString() { return "3"; }
8734 };
8735 template <> struct TagToType<0x0018,0x9558> {
8736 static const char* GetVRString() { return "FD"; }
8737 typedef VRToType<VR::FD>::Type Type;
8738 enum : long long { VRType = VR::FD };
8739 enum { VMType = VM::VM6 };
8740 static const char* GetVMString() { return "6"; }
8741 };
8742 template <> struct TagToType<0x0018,0x9559> {
8743 static const char* GetVRString() { return "CS"; }
8744 typedef VRToType<VR::CS>::Type Type;
8745 enum : long long { VRType = VR::CS };
8746 enum { VMType = VM::VM1 };
8747 static const char* GetVMString() { return "1"; }
8748 };
8749 template <> struct TagToType<0x0018,0x9601> {
8750 static const char* GetVRString() { return "SQ"; }
8751 typedef VRToType<VR::SQ>::Type Type;
8752 enum : long long { VRType = VR::SQ };
8753 enum { VMType = VM::VM1 };
8754 static const char* GetVMString() { return "1"; }
8755 };
8756 template <> struct TagToType<0x0018,0x9602> {
8757 static const char* GetVRString() { return "FD"; }
8758 typedef VRToType<VR::FD>::Type Type;
8759 enum : long long { VRType = VR::FD };
8760 enum { VMType = VM::VM1 };
8761 static const char* GetVMString() { return "1"; }
8762 };
8763 template <> struct TagToType<0x0018,0x9603> {
8764 static const char* GetVRString() { return "FD"; }
8765 typedef VRToType<VR::FD>::Type Type;
8766 enum : long long { VRType = VR::FD };
8767 enum { VMType = VM::VM1 };
8768 static const char* GetVMString() { return "1"; }
8769 };
8770 template <> struct TagToType<0x0018,0x9604> {
8771 static const char* GetVRString() { return "FD"; }
8772 typedef VRToType<VR::FD>::Type Type;
8773 enum : long long { VRType = VR::FD };
8774 enum { VMType = VM::VM1 };
8775 static const char* GetVMString() { return "1"; }
8776 };
8777 template <> struct TagToType<0x0018,0x9605> {
8778 static const char* GetVRString() { return "FD"; }
8779 typedef VRToType<VR::FD>::Type Type;
8780 enum : long long { VRType = VR::FD };
8781 enum { VMType = VM::VM1 };
8782 static const char* GetVMString() { return "1"; }
8783 };
8784 template <> struct TagToType<0x0018,0x9606> {
8785 static const char* GetVRString() { return "FD"; }
8786 typedef VRToType<VR::FD>::Type Type;
8787 enum : long long { VRType = VR::FD };
8788 enum { VMType = VM::VM1 };
8789 static const char* GetVMString() { return "1"; }
8790 };
8791 template <> struct TagToType<0x0018,0x9607> {
8792 static const char* GetVRString() { return "FD"; }
8793 typedef VRToType<VR::FD>::Type Type;
8794 enum : long long { VRType = VR::FD };
8795 enum { VMType = VM::VM1 };
8796 static const char* GetVMString() { return "1"; }
8797 };
8798 template <> struct TagToType<0x0018,0x9621> {
8799 static const char* GetVRString() { return "SQ"; }
8800 typedef VRToType<VR::SQ>::Type Type;
8801 enum : long long { VRType = VR::SQ };
8802 enum { VMType = VM::VM1 };
8803 static const char* GetVMString() { return "1"; }
8804 };
8805 template <> struct TagToType<0x0018,0x9622> {
8806 static const char* GetVRString() { return "CS"; }
8807 typedef VRToType<VR::CS>::Type Type;
8808 enum : long long { VRType = VR::CS };
8809 enum { VMType = VM::VM1 };
8810 static const char* GetVMString() { return "1"; }
8811 };
8812 template <> struct TagToType<0x0018,0x9623> {
8813 static const char* GetVRString() { return "DT"; }
8814 typedef VRToType<VR::DT>::Type Type;
8815 enum : long long { VRType = VR::DT };
8816 enum { VMType = VM::VM1 };
8817 static const char* GetVMString() { return "1"; }
8818 };
8819 template <> struct TagToType<0x0018,0x9624> {
8820 static const char* GetVRString() { return "CS"; }
8821 typedef VRToType<VR::CS>::Type Type;
8822 enum : long long { VRType = VR::CS };
8823 enum { VMType = VM::VM1 };
8824 static const char* GetVMString() { return "1"; }
8825 };
8826 template <> struct TagToType<0x0018,0x9701> {
8827 static const char* GetVRString() { return "DT"; }
8828 typedef VRToType<VR::DT>::Type Type;
8829 enum : long long { VRType = VR::DT };
8830 enum { VMType = VM::VM1 };
8831 static const char* GetVMString() { return "1"; }
8832 };
8833 template <> struct TagToType<0x0018,0x9715> {
8834 static const char* GetVRString() { return "FD"; }
8835 typedef VRToType<VR::FD>::Type Type;
8836 enum : long long { VRType = VR::FD };
8837 enum { VMType = VM::VM1 };
8838 static const char* GetVMString() { return "1"; }
8839 };
8840 template <> struct TagToType<0x0018,0x9716> {
8841 static const char* GetVRString() { return "FD"; }
8842 typedef VRToType<VR::FD>::Type Type;
8843 enum : long long { VRType = VR::FD };
8844 enum { VMType = VM::VM1 };
8845 static const char* GetVMString() { return "1"; }
8846 };
8847 template <> struct TagToType<0x0018,0x9717> {
8848 static const char* GetVRString() { return "FD"; }
8849 typedef VRToType<VR::FD>::Type Type;
8850 enum : long long { VRType = VR::FD };
8851 enum { VMType = VM::VM1 };
8852 static const char* GetVMString() { return "1"; }
8853 };
8854 template <> struct TagToType<0x0018,0x9718> {
8855 static const char* GetVRString() { return "FD"; }
8856 typedef VRToType<VR::FD>::Type Type;
8857 enum : long long { VRType = VR::FD };
8858 enum { VMType = VM::VM1 };
8859 static const char* GetVMString() { return "1"; }
8860 };
8861 template <> struct TagToType<0x0018,0x9719> {
8862 static const char* GetVRString() { return "FD"; }
8863 typedef VRToType<VR::FD>::Type Type;
8864 enum : long long { VRType = VR::FD };
8865 enum { VMType = VM::VM1 };
8866 static const char* GetVMString() { return "1"; }
8867 };
8868 template <> struct TagToType<0x0018,0x9720> {
8869 static const char* GetVRString() { return "FD"; }
8870 typedef VRToType<VR::FD>::Type Type;
8871 enum : long long { VRType = VR::FD };
8872 enum { VMType = VM::VM1 };
8873 static const char* GetVMString() { return "1"; }
8874 };
8875 template <> struct TagToType<0x0018,0x9721> {
8876 static const char* GetVRString() { return "FD"; }
8877 typedef VRToType<VR::FD>::Type Type;
8878 enum : long long { VRType = VR::FD };
8879 enum { VMType = VM::VM1 };
8880 static const char* GetVMString() { return "1"; }
8881 };
8882 template <> struct TagToType<0x0018,0x9722> {
8883 static const char* GetVRString() { return "FD"; }
8884 typedef VRToType<VR::FD>::Type Type;
8885 enum : long long { VRType = VR::FD };
8886 enum { VMType = VM::VM1 };
8887 static const char* GetVMString() { return "1"; }
8888 };
8889 template <> struct TagToType<0x0018,0x9723> {
8890 static const char* GetVRString() { return "FD"; }
8891 typedef VRToType<VR::FD>::Type Type;
8892 enum : long long { VRType = VR::FD };
8893 enum { VMType = VM::VM1 };
8894 static const char* GetVMString() { return "1"; }
8895 };
8896 template <> struct TagToType<0x0018,0x9724> {
8897 static const char* GetVRString() { return "FD"; }
8898 typedef VRToType<VR::FD>::Type Type;
8899 enum : long long { VRType = VR::FD };
8900 enum { VMType = VM::VM1 };
8901 static const char* GetVMString() { return "1"; }
8902 };
8903 template <> struct TagToType<0x0018,0x9725> {
8904 static const char* GetVRString() { return "CS"; }
8905 typedef VRToType<VR::CS>::Type Type;
8906 enum : long long { VRType = VR::CS };
8907 enum { VMType = VM::VM1 };
8908 static const char* GetVMString() { return "1"; }
8909 };
8910 template <> struct TagToType<0x0018,0x9726> {
8911 static const char* GetVRString() { return "FD"; }
8912 typedef VRToType<VR::FD>::Type Type;
8913 enum : long long { VRType = VR::FD };
8914 enum { VMType = VM::VM1 };
8915 static const char* GetVMString() { return "1"; }
8916 };
8917 template <> struct TagToType<0x0018,0x9727> {
8918 static const char* GetVRString() { return "FD"; }
8919 typedef VRToType<VR::FD>::Type Type;
8920 enum : long long { VRType = VR::FD };
8921 enum { VMType = VM::VM1 };
8922 static const char* GetVMString() { return "1"; }
8923 };
8924 template <> struct TagToType<0x0018,0x9729> {
8925 static const char* GetVRString() { return "US"; }
8926 typedef VRToType<VR::US>::Type Type;
8927 enum : long long { VRType = VR::US };
8928 enum { VMType = VM::VM1 };
8929 static const char* GetVMString() { return "1"; }
8930 };
8931 template <> struct TagToType<0x0018,0x9732> {
8932 static const char* GetVRString() { return "SQ"; }
8933 typedef VRToType<VR::SQ>::Type Type;
8934 enum : long long { VRType = VR::SQ };
8935 enum { VMType = VM::VM1 };
8936 static const char* GetVMString() { return "1"; }
8937 };
8938 template <> struct TagToType<0x0018,0x9733> {
8939 static const char* GetVRString() { return "SQ"; }
8940 typedef VRToType<VR::SQ>::Type Type;
8941 enum : long long { VRType = VR::SQ };
8942 enum { VMType = VM::VM1 };
8943 static const char* GetVMString() { return "1"; }
8944 };
8945 template <> struct TagToType<0x0018,0x9734> {
8946 static const char* GetVRString() { return "SQ"; }
8947 typedef VRToType<VR::SQ>::Type Type;
8948 enum : long long { VRType = VR::SQ };
8949 enum { VMType = VM::VM1 };
8950 static const char* GetVMString() { return "1"; }
8951 };
8952 template <> struct TagToType<0x0018,0x9735> {
8953 static const char* GetVRString() { return "SQ"; }
8954 typedef VRToType<VR::SQ>::Type Type;
8955 enum : long long { VRType = VR::SQ };
8956 enum { VMType = VM::VM1 };
8957 static const char* GetVMString() { return "1"; }
8958 };
8959 template <> struct TagToType<0x0018,0x9736> {
8960 static const char* GetVRString() { return "SQ"; }
8961 typedef VRToType<VR::SQ>::Type Type;
8962 enum : long long { VRType = VR::SQ };
8963 enum { VMType = VM::VM1 };
8964 static const char* GetVMString() { return "1"; }
8965 };
8966 template <> struct TagToType<0x0018,0x9737> {
8967 static const char* GetVRString() { return "SQ"; }
8968 typedef VRToType<VR::SQ>::Type Type;
8969 enum : long long { VRType = VR::SQ };
8970 enum { VMType = VM::VM1 };
8971 static const char* GetVMString() { return "1"; }
8972 };
8973 template <> struct TagToType<0x0018,0x9738> {
8974 static const char* GetVRString() { return "CS"; }
8975 typedef VRToType<VR::CS>::Type Type;
8976 enum : long long { VRType = VR::CS };
8977 enum { VMType = VM::VM1 };
8978 static const char* GetVMString() { return "1"; }
8979 };
8980 template <> struct TagToType<0x0018,0x9739> {
8981 static const char* GetVRString() { return "US"; }
8982 typedef VRToType<VR::US>::Type Type;
8983 enum : long long { VRType = VR::US };
8984 enum { VMType = VM::VM1 };
8985 static const char* GetVMString() { return "1"; }
8986 };
8987 template <> struct TagToType<0x0018,0x9740> {
8988 static const char* GetVRString() { return "US"; }
8989 typedef VRToType<VR::US>::Type Type;
8990 enum : long long { VRType = VR::US };
8991 enum { VMType = VM::VM1 };
8992 static const char* GetVMString() { return "1"; }
8993 };
8994 template <> struct TagToType<0x0018,0x9749> {
8995 static const char* GetVRString() { return "SQ"; }
8996 typedef VRToType<VR::SQ>::Type Type;
8997 enum : long long { VRType = VR::SQ };
8998 enum { VMType = VM::VM1 };
8999 static const char* GetVMString() { return "1"; }
9000 };
9001 template <> struct TagToType<0x0018,0x9751> {
9002 static const char* GetVRString() { return "SQ"; }
9003 typedef VRToType<VR::SQ>::Type Type;
9004 enum : long long { VRType = VR::SQ };
9005 enum { VMType = VM::VM1 };
9006 static const char* GetVMString() { return "1"; }
9007 };
9008 template <> struct TagToType<0x0018,0x9755> {
9009 static const char* GetVRString() { return "CS"; }
9010 typedef VRToType<VR::CS>::Type Type;
9011 enum : long long { VRType = VR::CS };
9012 enum { VMType = VM::VM1 };
9013 static const char* GetVMString() { return "1"; }
9014 };
9015 template <> struct TagToType<0x0018,0x9756> {
9016 static const char* GetVRString() { return "CS"; }
9017 typedef VRToType<VR::CS>::Type Type;
9018 enum : long long { VRType = VR::CS };
9019 enum { VMType = VM::VM1 };
9020 static const char* GetVMString() { return "1"; }
9021 };
9022 template <> struct TagToType<0x0018,0x9758> {
9023 static const char* GetVRString() { return "CS"; }
9024 typedef VRToType<VR::CS>::Type Type;
9025 enum : long long { VRType = VR::CS };
9026 enum { VMType = VM::VM1 };
9027 static const char* GetVMString() { return "1"; }
9028 };
9029 template <> struct TagToType<0x0018,0x9759> {
9030 static const char* GetVRString() { return "CS"; }
9031 typedef VRToType<VR::CS>::Type Type;
9032 enum : long long { VRType = VR::CS };
9033 enum { VMType = VM::VM1 };
9034 static const char* GetVMString() { return "1"; }
9035 };
9036 template <> struct TagToType<0x0018,0x9760> {
9037 static const char* GetVRString() { return "CS"; }
9038 typedef VRToType<VR::CS>::Type Type;
9039 enum : long long { VRType = VR::CS };
9040 enum { VMType = VM::VM1 };
9041 static const char* GetVMString() { return "1"; }
9042 };
9043 template <> struct TagToType<0x0018,0x9761> {
9044 static const char* GetVRString() { return "CS"; }
9045 typedef VRToType<VR::CS>::Type Type;
9046 enum : long long { VRType = VR::CS };
9047 enum { VMType = VM::VM1 };
9048 static const char* GetVMString() { return "1"; }
9049 };
9050 template <> struct TagToType<0x0018,0x9762> {
9051 static const char* GetVRString() { return "CS"; }
9052 typedef VRToType<VR::CS>::Type Type;
9053 enum : long long { VRType = VR::CS };
9054 enum { VMType = VM::VM1 };
9055 static const char* GetVMString() { return "1"; }
9056 };
9057 template <> struct TagToType<0x0018,0x9763> {
9058 static const char* GetVRString() { return "CS"; }
9059 typedef VRToType<VR::CS>::Type Type;
9060 enum : long long { VRType = VR::CS };
9061 enum { VMType = VM::VM1 };
9062 static const char* GetVMString() { return "1"; }
9063 };
9064 template <> struct TagToType<0x0018,0x9764> {
9065 static const char* GetVRString() { return "CS"; }
9066 typedef VRToType<VR::CS>::Type Type;
9067 enum : long long { VRType = VR::CS };
9068 enum { VMType = VM::VM1 };
9069 static const char* GetVMString() { return "1"; }
9070 };
9071 template <> struct TagToType<0x0018,0x9765> {
9072 static const char* GetVRString() { return "CS"; }
9073 typedef VRToType<VR::CS>::Type Type;
9074 enum : long long { VRType = VR::CS };
9075 enum { VMType = VM::VM1 };
9076 static const char* GetVMString() { return "1"; }
9077 };
9078 template <> struct TagToType<0x0018,0x9766> {
9079 static const char* GetVRString() { return "CS"; }
9080 typedef VRToType<VR::CS>::Type Type;
9081 enum : long long { VRType = VR::CS };
9082 enum { VMType = VM::VM1 };
9083 static const char* GetVMString() { return "1"; }
9084 };
9085 template <> struct TagToType<0x0018,0x9767> {
9086 static const char* GetVRString() { return "CS"; }
9087 typedef VRToType<VR::CS>::Type Type;
9088 enum : long long { VRType = VR::CS };
9089 enum { VMType = VM::VM1 };
9090 static const char* GetVMString() { return "1"; }
9091 };
9092 template <> struct TagToType<0x0018,0x9768> {
9093 static const char* GetVRString() { return "CS"; }
9094 typedef VRToType<VR::CS>::Type Type;
9095 enum : long long { VRType = VR::CS };
9096 enum { VMType = VM::VM1 };
9097 static const char* GetVMString() { return "1"; }
9098 };
9099 template <> struct TagToType<0x0018,0x9769> {
9100 static const char* GetVRString() { return "CS"; }
9101 typedef VRToType<VR::CS>::Type Type;
9102 enum : long long { VRType = VR::CS };
9103 enum { VMType = VM::VM1 };
9104 static const char* GetVMString() { return "1"; }
9105 };
9106 template <> struct TagToType<0x0018,0x9770> {
9107 static const char* GetVRString() { return "CS"; }
9108 typedef VRToType<VR::CS>::Type Type;
9109 enum : long long { VRType = VR::CS };
9110 enum { VMType = VM::VM1 };
9111 static const char* GetVMString() { return "1"; }
9112 };
9113 template <> struct TagToType<0x0018,0x9771> {
9114 static const char* GetVRString() { return "SQ"; }
9115 typedef VRToType<VR::SQ>::Type Type;
9116 enum : long long { VRType = VR::SQ };
9117 enum { VMType = VM::VM1 };
9118 static const char* GetVMString() { return "1"; }
9119 };
9120 template <> struct TagToType<0x0018,0x9772> {
9121 static const char* GetVRString() { return "SQ"; }
9122 typedef VRToType<VR::SQ>::Type Type;
9123 enum : long long { VRType = VR::SQ };
9124 enum { VMType = VM::VM1 };
9125 static const char* GetVMString() { return "1"; }
9126 };
9127 template <> struct TagToType<0x0018,0x9801> {
9128 static const char* GetVRString() { return "FD"; }
9129 typedef VRToType<VR::FD>::Type Type;
9130 enum : long long { VRType = VR::FD };
9131 enum { VMType = VM::VM1_n };
9132 static const char* GetVMString() { return "1-n"; }
9133 };
9134 template <> struct TagToType<0x0018,0x9803> {
9135 static const char* GetVRString() { return "SQ"; }
9136 typedef VRToType<VR::SQ>::Type Type;
9137 enum : long long { VRType = VR::SQ };
9138 enum { VMType = VM::VM1 };
9139 static const char* GetVMString() { return "1"; }
9140 };
9141 template <> struct TagToType<0x0018,0x9804> {
9142 static const char* GetVRString() { return "DT"; }
9143 typedef VRToType<VR::DT>::Type Type;
9144 enum : long long { VRType = VR::DT };
9145 enum { VMType = VM::VM1 };
9146 static const char* GetVMString() { return "1"; }
9147 };
9148 template <> struct TagToType<0x0018,0x9805> {
9149 static const char* GetVRString() { return "FD"; }
9150 typedef VRToType<VR::FD>::Type Type;
9151 enum : long long { VRType = VR::FD };
9152 enum { VMType = VM::VM1 };
9153 static const char* GetVMString() { return "1"; }
9154 };
9155 template <> struct TagToType<0x0018,0x9806> {
9156 static const char* GetVRString() { return "SQ"; }
9157 typedef VRToType<VR::SQ>::Type Type;
9158 enum : long long { VRType = VR::SQ };
9159 enum { VMType = VM::VM1 };
9160 static const char* GetVMString() { return "1"; }
9161 };
9162 template <> struct TagToType<0x0018,0x9807> {
9163 static const char* GetVRString() { return "SQ"; }
9164 typedef VRToType<VR::SQ>::Type Type;
9165 enum : long long { VRType = VR::SQ };
9166 enum { VMType = VM::VM1 };
9167 static const char* GetVMString() { return "1"; }
9168 };
9169 template <> struct TagToType<0x0018,0x9808> {
9170 static const char* GetVRString() { return "CS"; }
9171 typedef VRToType<VR::CS>::Type Type;
9172 enum : long long { VRType = VR::CS };
9173 enum { VMType = VM::VM1 };
9174 static const char* GetVMString() { return "1"; }
9175 };
9176 template <> struct TagToType<0x0018,0x9809> {
9177 static const char* GetVRString() { return "SQ"; }
9178 typedef VRToType<VR::SQ>::Type Type;
9179 enum : long long { VRType = VR::SQ };
9180 enum { VMType = VM::VM1 };
9181 static const char* GetVMString() { return "1"; }
9182 };
9183 template <> struct TagToType<0x0018,0x980b> {
9184 static const char* GetVRString() { return "CS"; }
9185 typedef VRToType<VR::CS>::Type Type;
9186 enum : long long { VRType = VR::CS };
9187 enum { VMType = VM::VM1 };
9188 static const char* GetVMString() { return "1"; }
9189 };
9190 template <> struct TagToType<0x0018,0x980c> {
9191 static const char* GetVRString() { return "CS"; }
9192 typedef VRToType<VR::CS>::Type Type;
9193 enum : long long { VRType = VR::CS };
9194 enum { VMType = VM::VM1 };
9195 static const char* GetVMString() { return "1"; }
9196 };
9197 template <> struct TagToType<0x0018,0x980d> {
9198 static const char* GetVRString() { return "SQ"; }
9199 typedef VRToType<VR::SQ>::Type Type;
9200 enum : long long { VRType = VR::SQ };
9201 enum { VMType = VM::VM1 };
9202 static const char* GetVMString() { return "1"; }
9203 };
9204 template <> struct TagToType<0x0018,0x980e> {
9205 static const char* GetVRString() { return "SQ"; }
9206 typedef VRToType<VR::SQ>::Type Type;
9207 enum : long long { VRType = VR::SQ };
9208 enum { VMType = VM::VM1 };
9209 static const char* GetVMString() { return "1"; }
9210 };
9211 template <> struct TagToType<0x0018,0x980f> {
9212 static const char* GetVRString() { return "SQ"; }
9213 typedef VRToType<VR::SQ>::Type Type;
9214 enum : long long { VRType = VR::SQ };
9215 enum { VMType = VM::VM1 };
9216 static const char* GetVMString() { return "1"; }
9217 };
9218 template <> struct TagToType<0x0018,0x9900> {
9219 static const char* GetVRString() { return "LO"; }
9220 typedef VRToType<VR::LO>::Type Type;
9221 enum : long long { VRType = VR::LO };
9222 enum { VMType = VM::VM1 };
9223 static const char* GetVMString() { return "1"; }
9224 };
9225 template <> struct TagToType<0x0018,0x9901> {
9226 static const char* GetVRString() { return "UT"; }
9227 typedef VRToType<VR::UT>::Type Type;
9228 enum : long long { VRType = VR::UT };
9229 enum { VMType = VM::VM1 };
9230 static const char* GetVMString() { return "1"; }
9231 };
9232 template <> struct TagToType<0x0018,0x9902> {
9233 static const char* GetVRString() { return "SQ"; }
9234 typedef VRToType<VR::SQ>::Type Type;
9235 enum : long long { VRType = VR::SQ };
9236 enum { VMType = VM::VM1 };
9237 static const char* GetVMString() { return "1"; }
9238 };
9239 template <> struct TagToType<0x0018,0x9903> {
9240 static const char* GetVRString() { return "SQ"; }
9241 typedef VRToType<VR::SQ>::Type Type;
9242 enum : long long { VRType = VR::SQ };
9243 enum { VMType = VM::VM1 };
9244 static const char* GetVMString() { return "1"; }
9245 };
9246 template <> struct TagToType<0x0018,0x9904> {
9247 static const char* GetVRString() { return "DS"; }
9248 typedef VRToType<VR::DS>::Type Type;
9249 enum : long long { VRType = VR::DS };
9250 enum { VMType = VM::VM1 };
9251 static const char* GetVMString() { return "1"; }
9252 };
9253 template <> struct TagToType<0x0018,0x9905> {
9254 static const char* GetVRString() { return "CS"; }
9255 typedef VRToType<VR::CS>::Type Type;
9256 enum : long long { VRType = VR::CS };
9257 enum { VMType = VM::VM1 };
9258 static const char* GetVMString() { return "1"; }
9259 };
9260 template <> struct TagToType<0x0018,0x9906> {
9261 static const char* GetVRString() { return "SQ"; }
9262 typedef VRToType<VR::SQ>::Type Type;
9263 enum : long long { VRType = VR::SQ };
9264 enum { VMType = VM::VM1 };
9265 static const char* GetVMString() { return "1"; }
9266 };
9267 template <> struct TagToType<0x0018,0x9907> {
9268 static const char* GetVRString() { return "SQ"; }
9269 typedef VRToType<VR::SQ>::Type Type;
9270 enum : long long { VRType = VR::SQ };
9271 enum { VMType = VM::VM1 };
9272 static const char* GetVMString() { return "1"; }
9273 };
9274 template <> struct TagToType<0x0018,0x9908> {
9275 static const char* GetVRString() { return "UC"; }
9276 typedef VRToType<VR::UC>::Type Type;
9277 enum : long long { VRType = VR::UC };
9278 enum { VMType = VM::VM1_n };
9279 static const char* GetVMString() { return "1-n"; }
9280 };
9281 template <> struct TagToType<0x0018,0x9909> {
9282 static const char* GetVRString() { return "SQ"; }
9283 typedef VRToType<VR::SQ>::Type Type;
9284 enum : long long { VRType = VR::SQ };
9285 enum { VMType = VM::VM1 };
9286 static const char* GetVMString() { return "1"; }
9287 };
9288 template <> struct TagToType<0x0018,0x990a> {
9289 static const char* GetVRString() { return "UC"; }
9290 typedef VRToType<VR::UC>::Type Type;
9291 enum : long long { VRType = VR::UC };
9292 enum { VMType = VM::VM1_n };
9293 static const char* GetVMString() { return "1-n"; }
9294 };
9295 template <> struct TagToType<0x0018,0x990b> {
9296 static const char* GetVRString() { return "SQ"; }
9297 typedef VRToType<VR::SQ>::Type Type;
9298 enum : long long { VRType = VR::SQ };
9299 enum { VMType = VM::VM1 };
9300 static const char* GetVMString() { return "1"; }
9301 };
9302 template <> struct TagToType<0x0018,0x990c> {
9303 static const char* GetVRString() { return "SQ"; }
9304 typedef VRToType<VR::SQ>::Type Type;
9305 enum : long long { VRType = VR::SQ };
9306 enum { VMType = VM::VM1 };
9307 static const char* GetVMString() { return "1"; }
9308 };
9309 template <> struct TagToType<0x0018,0x990d> {
9310 static const char* GetVRString() { return "SQ"; }
9311 typedef VRToType<VR::SQ>::Type Type;
9312 enum : long long { VRType = VR::SQ };
9313 enum { VMType = VM::VM1 };
9314 static const char* GetVMString() { return "1"; }
9315 };
9316 template <> struct TagToType<0x0018,0x990e> {
9317 static const char* GetVRString() { return "SQ"; }
9318 typedef VRToType<VR::SQ>::Type Type;
9319 enum : long long { VRType = VR::SQ };
9320 enum { VMType = VM::VM1 };
9321 static const char* GetVMString() { return "1"; }
9322 };
9323 template <> struct TagToType<0x0018,0x990f> {
9324 static const char* GetVRString() { return "UT"; }
9325 typedef VRToType<VR::UT>::Type Type;
9326 enum : long long { VRType = VR::UT };
9327 enum { VMType = VM::VM1 };
9328 static const char* GetVMString() { return "1"; }
9329 };
9330 template <> struct TagToType<0x0018,0x9910> {
9331 static const char* GetVRString() { return "UT"; }
9332 typedef VRToType<VR::UT>::Type Type;
9333 enum : long long { VRType = VR::UT };
9334 enum { VMType = VM::VM1 };
9335 static const char* GetVMString() { return "1"; }
9336 };
9337 template <> struct TagToType<0x0018,0x9911> {
9338 static const char* GetVRString() { return "SQ"; }
9339 typedef VRToType<VR::SQ>::Type Type;
9340 enum : long long { VRType = VR::SQ };
9341 enum { VMType = VM::VM1 };
9342 static const char* GetVMString() { return "1"; }
9343 };
9344 template <> struct TagToType<0x0018,0x9912> {
9345 static const char* GetVRString() { return "SQ"; }
9346 typedef VRToType<VR::SQ>::Type Type;
9347 enum : long long { VRType = VR::SQ };
9348 enum { VMType = VM::VM1 };
9349 static const char* GetVMString() { return "1"; }
9350 };
9351 template <> struct TagToType<0x0018,0x9913> {
9352 static const char* GetVRString() { return "SQ"; }
9353 typedef VRToType<VR::SQ>::Type Type;
9354 enum : long long { VRType = VR::SQ };
9355 enum { VMType = VM::VM1 };
9356 static const char* GetVMString() { return "1"; }
9357 };
9358 template <> struct TagToType<0x0018,0x9914> {
9359 static const char* GetVRString() { return "SQ"; }
9360 typedef VRToType<VR::SQ>::Type Type;
9361 enum : long long { VRType = VR::SQ };
9362 enum { VMType = VM::VM1 };
9363 static const char* GetVMString() { return "1"; }
9364 };
9365 template <> struct TagToType<0x0018,0x9915> {
9366 static const char* GetVRString() { return "US"; }
9367 typedef VRToType<VR::US>::Type Type;
9368 enum : long long { VRType = VR::US };
9369 enum { VMType = VM::VM1 };
9370 static const char* GetVMString() { return "1"; }
9371 };
9372 template <> struct TagToType<0x0018,0x9916> {
9373 static const char* GetVRString() { return "LO"; }
9374 typedef VRToType<VR::LO>::Type Type;
9375 enum : long long { VRType = VR::LO };
9376 enum { VMType = VM::VM1 };
9377 static const char* GetVMString() { return "1"; }
9378 };
9379 template <> struct TagToType<0x0018,0x9917> {
9380 static const char* GetVRString() { return "UT"; }
9381 typedef VRToType<VR::UT>::Type Type;
9382 enum : long long { VRType = VR::UT };
9383 enum { VMType = VM::VM1 };
9384 static const char* GetVMString() { return "1"; }
9385 };
9386 template <> struct TagToType<0x0018,0x9918> {
9387 static const char* GetVRString() { return "CS"; }
9388 typedef VRToType<VR::CS>::Type Type;
9389 enum : long long { VRType = VR::CS };
9390 enum { VMType = VM::VM1 };
9391 static const char* GetVMString() { return "1"; }
9392 };
9393 template <> struct TagToType<0x0018,0x9919> {
9394 static const char* GetVRString() { return "DT"; }
9395 typedef VRToType<VR::DT>::Type Type;
9396 enum : long long { VRType = VR::DT };
9397 enum { VMType = VM::VM1 };
9398 static const char* GetVMString() { return "1"; }
9399 };
9400 template <> struct TagToType<0x0018,0x991a> {
9401 static const char* GetVRString() { return "UT"; }
9402 typedef VRToType<VR::UT>::Type Type;
9403 enum : long long { VRType = VR::UT };
9404 enum { VMType = VM::VM1 };
9405 static const char* GetVMString() { return "1"; }
9406 };
9407 template <> struct TagToType<0x0018,0x991b> {
9408 static const char* GetVRString() { return "SQ"; }
9409 typedef VRToType<VR::SQ>::Type Type;
9410 enum : long long { VRType = VR::SQ };
9411 enum { VMType = VM::VM1 };
9412 static const char* GetVMString() { return "1"; }
9413 };
9414 template <> struct TagToType<0x0018,0x991c> {
9415 static const char* GetVRString() { return "SQ"; }
9416 typedef VRToType<VR::SQ>::Type Type;
9417 enum : long long { VRType = VR::SQ };
9418 enum { VMType = VM::VM1 };
9419 static const char* GetVMString() { return "1"; }
9420 };
9421 template <> struct TagToType<0x0018,0x991d> {
9422 static const char* GetVRString() { return "SQ"; }
9423 typedef VRToType<VR::SQ>::Type Type;
9424 enum : long long { VRType = VR::SQ };
9425 enum { VMType = VM::VM1 };
9426 static const char* GetVMString() { return "1"; }
9427 };
9428 template <> struct TagToType<0x0018,0x991e> {
9429 static const char* GetVRString() { return "UI"; }
9430 typedef VRToType<VR::UI>::Type Type;
9431 enum : long long { VRType = VR::UI };
9432 enum { VMType = VM::VM1 };
9433 static const char* GetVMString() { return "1"; }
9434 };
9435 template <> struct TagToType<0x0018,0x991f> {
9436 static const char* GetVRString() { return "SQ"; }
9437 typedef VRToType<VR::SQ>::Type Type;
9438 enum : long long { VRType = VR::SQ };
9439 enum { VMType = VM::VM1 };
9440 static const char* GetVMString() { return "1"; }
9441 };
9442 template <> struct TagToType<0x0018,0x9920> {
9443 static const char* GetVRString() { return "SQ"; }
9444 typedef VRToType<VR::SQ>::Type Type;
9445 enum : long long { VRType = VR::SQ };
9446 enum { VMType = VM::VM1 };
9447 static const char* GetVMString() { return "1"; }
9448 };
9449 template <> struct TagToType<0x0018,0x9921> {
9450 static const char* GetVRString() { return "US"; }
9451 typedef VRToType<VR::US>::Type Type;
9452 enum : long long { VRType = VR::US };
9453 enum { VMType = VM::VM1 };
9454 static const char* GetVMString() { return "1"; }
9455 };
9456 template <> struct TagToType<0x0018,0x9922> {
9457 static const char* GetVRString() { return "LO"; }
9458 typedef VRToType<VR::LO>::Type Type;
9459 enum : long long { VRType = VR::LO };
9460 enum { VMType = VM::VM1 };
9461 static const char* GetVMString() { return "1"; }
9462 };
9463 template <> struct TagToType<0x0018,0x9923> {
9464 static const char* GetVRString() { return "UT"; }
9465 typedef VRToType<VR::UT>::Type Type;
9466 enum : long long { VRType = VR::UT };
9467 enum { VMType = VM::VM1 };
9468 static const char* GetVMString() { return "1"; }
9469 };
9470 template <> struct TagToType<0x0018,0x9924> {
9471 static const char* GetVRString() { return "UT"; }
9472 typedef VRToType<VR::UT>::Type Type;
9473 enum : long long { VRType = VR::UT };
9474 enum { VMType = VM::VM1 };
9475 static const char* GetVMString() { return "1"; }
9476 };
9477 template <> struct TagToType<0x0018,0x9930> {
9478 static const char* GetVRString() { return "CS"; }
9479 typedef VRToType<VR::CS>::Type Type;
9480 enum : long long { VRType = VR::CS };
9481 enum { VMType = VM::VM1 };
9482 static const char* GetVMString() { return "1"; }
9483 };
9484 template <> struct TagToType<0x0018,0x9931> {
9485 static const char* GetVRString() { return "SQ"; }
9486 typedef VRToType<VR::SQ>::Type Type;
9487 enum : long long { VRType = VR::SQ };
9488 enum { VMType = VM::VM1 };
9489 static const char* GetVMString() { return "1"; }
9490 };
9491 template <> struct TagToType<0x0018,0x9932> {
9492 static const char* GetVRString() { return "SQ"; }
9493 typedef VRToType<VR::SQ>::Type Type;
9494 enum : long long { VRType = VR::SQ };
9495 enum { VMType = VM::VM1 };
9496 static const char* GetVMString() { return "1"; }
9497 };
9498 template <> struct TagToType<0x0018,0x9933> {
9499 static const char* GetVRString() { return "SQ"; }
9500 typedef VRToType<VR::SQ>::Type Type;
9501 enum : long long { VRType = VR::SQ };
9502 enum { VMType = VM::VM1 };
9503 static const char* GetVMString() { return "1"; }
9504 };
9505 template <> struct TagToType<0x0018,0x9934> {
9506 static const char* GetVRString() { return "SQ"; }
9507 typedef VRToType<VR::SQ>::Type Type;
9508 enum : long long { VRType = VR::SQ };
9509 enum { VMType = VM::VM1 };
9510 static const char* GetVMString() { return "1"; }
9511 };
9512 template <> struct TagToType<0x0018,0x9935> {
9513 static const char* GetVRString() { return "SQ"; }
9514 typedef VRToType<VR::SQ>::Type Type;
9515 enum : long long { VRType = VR::SQ };
9516 enum { VMType = VM::VM1 };
9517 static const char* GetVMString() { return "1"; }
9518 };
9519 template <> struct TagToType<0x0018,0x9936> {
9520 static const char* GetVRString() { return "SQ"; }
9521 typedef VRToType<VR::SQ>::Type Type;
9522 enum : long long { VRType = VR::SQ };
9523 enum { VMType = VM::VM1 };
9524 static const char* GetVMString() { return "1"; }
9525 };
9526 template <> struct TagToType<0x0018,0x9937> {
9527 static const char* GetVRString() { return "LO"; }
9528 typedef VRToType<VR::LO>::Type Type;
9529 enum : long long { VRType = VR::LO };
9530 enum { VMType = VM::VM1 };
9531 static const char* GetVMString() { return "1"; }
9532 };
9533 template <> struct TagToType<0x0018,0x9938> {
9534 static const char* GetVRString() { return "US"; }
9535 typedef VRToType<VR::US>::Type Type;
9536 enum : long long { VRType = VR::US };
9537 enum { VMType = VM::VM1_n };
9538 static const char* GetVMString() { return "1-n"; }
9539 };
9540 template <> struct TagToType<0x0018,0x9939> {
9541 static const char* GetVRString() { return "US"; }
9542 typedef VRToType<VR::US>::Type Type;
9543 enum : long long { VRType = VR::US };
9544 enum { VMType = VM::VM1_n };
9545 static const char* GetVMString() { return "1-n"; }
9546 };
9547 template <> struct TagToType<0x0018,0x993a> {
9548 static const char* GetVRString() { return "US"; }
9549 typedef VRToType<VR::US>::Type Type;
9550 enum : long long { VRType = VR::US };
9551 enum { VMType = VM::VM1_n };
9552 static const char* GetVMString() { return "1-n"; }
9553 };
9554 template <> struct TagToType<0x0018,0x993b> {
9555 static const char* GetVRString() { return "SQ"; }
9556 typedef VRToType<VR::SQ>::Type Type;
9557 enum : long long { VRType = VR::SQ };
9558 enum { VMType = VM::VM1 };
9559 static const char* GetVMString() { return "1"; }
9560 };
9561 template <> struct TagToType<0x0018,0x993c> {
9562 static const char* GetVRString() { return "SQ"; }
9563 typedef VRToType<VR::SQ>::Type Type;
9564 enum : long long { VRType = VR::SQ };
9565 enum { VMType = VM::VM1 };
9566 static const char* GetVMString() { return "1"; }
9567 };
9568 template <> struct TagToType<0x0018,0x993d> {
9569 static const char* GetVRString() { return "SQ"; }
9570 typedef VRToType<VR::SQ>::Type Type;
9571 enum : long long { VRType = VR::SQ };
9572 enum { VMType = VM::VM1 };
9573 static const char* GetVMString() { return "1"; }
9574 };
9575 template <> struct TagToType<0x0018,0x993e> {
9576 static const char* GetVRString() { return "SQ"; }
9577 typedef VRToType<VR::SQ>::Type Type;
9578 enum : long long { VRType = VR::SQ };
9579 enum { VMType = VM::VM1 };
9580 static const char* GetVMString() { return "1"; }
9581 };
9582 template <> struct TagToType<0x0018,0x9941> {
9583 static const char* GetVRString() { return "UT"; }
9584 typedef VRToType<VR::UT>::Type Type;
9585 enum : long long { VRType = VR::UT };
9586 enum { VMType = VM::VM1 };
9587 static const char* GetVMString() { return "1"; }
9588 };
9589 template <> struct TagToType<0x0018,0x9942> {
9590 static const char* GetVRString() { return "FD"; }
9591 typedef VRToType<VR::FD>::Type Type;
9592 enum : long long { VRType = VR::FD };
9593 enum { VMType = VM::VM1 };
9594 static const char* GetVMString() { return "1"; }
9595 };
9596 template <> struct TagToType<0x0018,0x9943> {
9597 static const char* GetVRString() { return "FD"; }
9598 typedef VRToType<VR::FD>::Type Type;
9599 enum : long long { VRType = VR::FD };
9600 enum { VMType = VM::VM1 };
9601 static const char* GetVMString() { return "1"; }
9602 };
9603 template <> struct TagToType<0x0018,0x9944> {
9604 static const char* GetVRString() { return "CS"; }
9605 typedef VRToType<VR::CS>::Type Type;
9606 enum : long long { VRType = VR::CS };
9607 enum { VMType = VM::VM1 };
9608 static const char* GetVMString() { return "1"; }
9609 };
9610 template <> struct TagToType<0x0018,0x9945> {
9611 static const char* GetVRString() { return "FD"; }
9612 typedef VRToType<VR::FD>::Type Type;
9613 enum : long long { VRType = VR::FD };
9614 enum { VMType = VM::VM1 };
9615 static const char* GetVMString() { return "1"; }
9616 };
9617 template <> struct TagToType<0x0018,0x9946> {
9618 static const char* GetVRString() { return "FD"; }
9619 typedef VRToType<VR::FD>::Type Type;
9620 enum : long long { VRType = VR::FD };
9621 enum { VMType = VM::VM1 };
9622 static const char* GetVMString() { return "1"; }
9623 };
9624 template <> struct TagToType<0x0018,0x9947> {
9625 static const char* GetVRString() { return "CS"; }
9626 typedef VRToType<VR::CS>::Type Type;
9627 enum : long long { VRType = VR::CS };
9628 enum { VMType = VM::VM1 };
9629 static const char* GetVMString() { return "1"; }
9630 };
9631 template <> struct TagToType<0x0018,0xa001> {
9632 static const char* GetVRString() { return "SQ"; }
9633 typedef VRToType<VR::SQ>::Type Type;
9634 enum : long long { VRType = VR::SQ };
9635 enum { VMType = VM::VM1 };
9636 static const char* GetVMString() { return "1"; }
9637 };
9638 template <> struct TagToType<0x0018,0xa002> {
9639 static const char* GetVRString() { return "DT"; }
9640 typedef VRToType<VR::DT>::Type Type;
9641 enum : long long { VRType = VR::DT };
9642 enum { VMType = VM::VM1 };
9643 static const char* GetVMString() { return "1"; }
9644 };
9645 template <> struct TagToType<0x0018,0xa003> {
9646 static const char* GetVRString() { return "ST"; }
9647 typedef VRToType<VR::ST>::Type Type;
9648 enum : long long { VRType = VR::ST };
9649 enum { VMType = VM::VM1 };
9650 static const char* GetVMString() { return "1"; }
9651 };
9652 template <> struct TagToType<0x0020,0x000d> {
9653 static const char* GetVRString() { return "UI"; }
9654 typedef VRToType<VR::UI>::Type Type;
9655 enum : long long { VRType = VR::UI };
9656 enum { VMType = VM::VM1 };
9657 static const char* GetVMString() { return "1"; }
9658 };
9659 template <> struct TagToType<0x0020,0x000e> {
9660 static const char* GetVRString() { return "UI"; }
9661 typedef VRToType<VR::UI>::Type Type;
9662 enum : long long { VRType = VR::UI };
9663 enum { VMType = VM::VM1 };
9664 static const char* GetVMString() { return "1"; }
9665 };
9666 template <> struct TagToType<0x0020,0x0010> {
9667 static const char* GetVRString() { return "SH"; }
9668 typedef VRToType<VR::SH>::Type Type;
9669 enum : long long { VRType = VR::SH };
9670 enum { VMType = VM::VM1 };
9671 static const char* GetVMString() { return "1"; }
9672 };
9673 template <> struct TagToType<0x0020,0x0011> {
9674 static const char* GetVRString() { return "IS"; }
9675 typedef VRToType<VR::IS>::Type Type;
9676 enum : long long { VRType = VR::IS };
9677 enum { VMType = VM::VM1 };
9678 static const char* GetVMString() { return "1"; }
9679 };
9680 template <> struct TagToType<0x0020,0x0012> {
9681 static const char* GetVRString() { return "IS"; }
9682 typedef VRToType<VR::IS>::Type Type;
9683 enum : long long { VRType = VR::IS };
9684 enum { VMType = VM::VM1 };
9685 static const char* GetVMString() { return "1"; }
9686 };
9687 template <> struct TagToType<0x0020,0x0013> {
9688 static const char* GetVRString() { return "IS"; }
9689 typedef VRToType<VR::IS>::Type Type;
9690 enum : long long { VRType = VR::IS };
9691 enum { VMType = VM::VM1 };
9692 static const char* GetVMString() { return "1"; }
9693 };
9694 template <> struct TagToType<0x0020,0x0014> {
9695 static const char* GetVRString() { return "IS"; }
9696 typedef VRToType<VR::IS>::Type Type;
9697 enum : long long { VRType = VR::IS };
9698 enum { VMType = VM::VM1 };
9699 static const char* GetVMString() { return "1"; }
9700 };
9701 template <> struct TagToType<0x0020,0x0015> {
9702 static const char* GetVRString() { return "IS"; }
9703 typedef VRToType<VR::IS>::Type Type;
9704 enum : long long { VRType = VR::IS };
9705 enum { VMType = VM::VM1 };
9706 static const char* GetVMString() { return "1"; }
9707 };
9708 template <> struct TagToType<0x0020,0x0016> {
9709 static const char* GetVRString() { return "IS"; }
9710 typedef VRToType<VR::IS>::Type Type;
9711 enum : long long { VRType = VR::IS };
9712 enum { VMType = VM::VM1 };
9713 static const char* GetVMString() { return "1"; }
9714 };
9715 template <> struct TagToType<0x0020,0x0017> {
9716 static const char* GetVRString() { return "IS"; }
9717 typedef VRToType<VR::IS>::Type Type;
9718 enum : long long { VRType = VR::IS };
9719 enum { VMType = VM::VM1 };
9720 static const char* GetVMString() { return "1"; }
9721 };
9722 template <> struct TagToType<0x0020,0x0018> {
9723 static const char* GetVRString() { return "IS"; }
9724 typedef VRToType<VR::IS>::Type Type;
9725 enum : long long { VRType = VR::IS };
9726 enum { VMType = VM::VM1 };
9727 static const char* GetVMString() { return "1"; }
9728 };
9729 template <> struct TagToType<0x0020,0x0019> {
9730 static const char* GetVRString() { return "IS"; }
9731 typedef VRToType<VR::IS>::Type Type;
9732 enum : long long { VRType = VR::IS };
9733 enum { VMType = VM::VM1 };
9734 static const char* GetVMString() { return "1"; }
9735 };
9736 template <> struct TagToType<0x0020,0x0020> {
9737 static const char* GetVRString() { return "CS"; }
9738 typedef VRToType<VR::CS>::Type Type;
9739 enum : long long { VRType = VR::CS };
9740 enum { VMType = VM::VM2 };
9741 static const char* GetVMString() { return "2"; }
9742 };
9743 template <> struct TagToType<0x0020,0x0022> {
9744 static const char* GetVRString() { return "IS"; }
9745 typedef VRToType<VR::IS>::Type Type;
9746 enum : long long { VRType = VR::IS };
9747 enum { VMType = VM::VM1 };
9748 static const char* GetVMString() { return "1"; }
9749 };
9750 template <> struct TagToType<0x0020,0x0024> {
9751 static const char* GetVRString() { return "IS"; }
9752 typedef VRToType<VR::IS>::Type Type;
9753 enum : long long { VRType = VR::IS };
9754 enum { VMType = VM::VM1 };
9755 static const char* GetVMString() { return "1"; }
9756 };
9757 template <> struct TagToType<0x0020,0x0026> {
9758 static const char* GetVRString() { return "IS"; }
9759 typedef VRToType<VR::IS>::Type Type;
9760 enum : long long { VRType = VR::IS };
9761 enum { VMType = VM::VM1 };
9762 static const char* GetVMString() { return "1"; }
9763 };
9764 template <> struct TagToType<0x0020,0x0030> {
9765 static const char* GetVRString() { return "DS"; }
9766 typedef VRToType<VR::DS>::Type Type;
9767 enum : long long { VRType = VR::DS };
9768 enum { VMType = VM::VM3 };
9769 static const char* GetVMString() { return "3"; }
9770 };
9771 template <> struct TagToType<0x0020,0x0032> {
9772 static const char* GetVRString() { return "DS"; }
9773 typedef VRToType<VR::DS>::Type Type;
9774 enum : long long { VRType = VR::DS };
9775 enum { VMType = VM::VM3 };
9776 static const char* GetVMString() { return "3"; }
9777 };
9778 template <> struct TagToType<0x0020,0x0035> {
9779 static const char* GetVRString() { return "DS"; }
9780 typedef VRToType<VR::DS>::Type Type;
9781 enum : long long { VRType = VR::DS };
9782 enum { VMType = VM::VM6 };
9783 static const char* GetVMString() { return "6"; }
9784 };
9785 template <> struct TagToType<0x0020,0x0037> {
9786 static const char* GetVRString() { return "DS"; }
9787 typedef VRToType<VR::DS>::Type Type;
9788 enum : long long { VRType = VR::DS };
9789 enum { VMType = VM::VM6 };
9790 static const char* GetVMString() { return "6"; }
9791 };
9792 template <> struct TagToType<0x0020,0x0050> {
9793 static const char* GetVRString() { return "DS"; }
9794 typedef VRToType<VR::DS>::Type Type;
9795 enum : long long { VRType = VR::DS };
9796 enum { VMType = VM::VM1 };
9797 static const char* GetVMString() { return "1"; }
9798 };
9799 template <> struct TagToType<0x0020,0x0052> {
9800 static const char* GetVRString() { return "UI"; }
9801 typedef VRToType<VR::UI>::Type Type;
9802 enum : long long { VRType = VR::UI };
9803 enum { VMType = VM::VM1 };
9804 static const char* GetVMString() { return "1"; }
9805 };
9806 template <> struct TagToType<0x0020,0x0060> {
9807 static const char* GetVRString() { return "CS"; }
9808 typedef VRToType<VR::CS>::Type Type;
9809 enum : long long { VRType = VR::CS };
9810 enum { VMType = VM::VM1 };
9811 static const char* GetVMString() { return "1"; }
9812 };
9813 template <> struct TagToType<0x0020,0x0062> {
9814 static const char* GetVRString() { return "CS"; }
9815 typedef VRToType<VR::CS>::Type Type;
9816 enum : long long { VRType = VR::CS };
9817 enum { VMType = VM::VM1 };
9818 static const char* GetVMString() { return "1"; }
9819 };
9820 template <> struct TagToType<0x0020,0x0070> {
9821 static const char* GetVRString() { return "LO"; }
9822 typedef VRToType<VR::LO>::Type Type;
9823 enum : long long { VRType = VR::LO };
9824 enum { VMType = VM::VM1 };
9825 static const char* GetVMString() { return "1"; }
9826 };
9827 template <> struct TagToType<0x0020,0x0080> {
9828 static const char* GetVRString() { return "CS"; }
9829 typedef VRToType<VR::CS>::Type Type;
9830 enum : long long { VRType = VR::CS };
9831 enum { VMType = VM::VM1_n };
9832 static const char* GetVMString() { return "1-n"; }
9833 };
9834 template <> struct TagToType<0x0020,0x00aa> {
9835 static const char* GetVRString() { return "IS"; }
9836 typedef VRToType<VR::IS>::Type Type;
9837 enum : long long { VRType = VR::IS };
9838 enum { VMType = VM::VM1 };
9839 static const char* GetVMString() { return "1"; }
9840 };
9841 template <> struct TagToType<0x0020,0x0100> {
9842 static const char* GetVRString() { return "IS"; }
9843 typedef VRToType<VR::IS>::Type Type;
9844 enum : long long { VRType = VR::IS };
9845 enum { VMType = VM::VM1 };
9846 static const char* GetVMString() { return "1"; }
9847 };
9848 template <> struct TagToType<0x0020,0x0105> {
9849 static const char* GetVRString() { return "IS"; }
9850 typedef VRToType<VR::IS>::Type Type;
9851 enum : long long { VRType = VR::IS };
9852 enum { VMType = VM::VM1 };
9853 static const char* GetVMString() { return "1"; }
9854 };
9855 template <> struct TagToType<0x0020,0x0110> {
9856 static const char* GetVRString() { return "DS"; }
9857 typedef VRToType<VR::DS>::Type Type;
9858 enum : long long { VRType = VR::DS };
9859 enum { VMType = VM::VM1 };
9860 static const char* GetVMString() { return "1"; }
9861 };
9862 template <> struct TagToType<0x0020,0x0200> {
9863 static const char* GetVRString() { return "UI"; }
9864 typedef VRToType<VR::UI>::Type Type;
9865 enum : long long { VRType = VR::UI };
9866 enum { VMType = VM::VM1 };
9867 static const char* GetVMString() { return "1"; }
9868 };
9869 template <> struct TagToType<0x0020,0x0242> {
9870 static const char* GetVRString() { return "UI"; }
9871 typedef VRToType<VR::UI>::Type Type;
9872 enum : long long { VRType = VR::UI };
9873 enum { VMType = VM::VM1 };
9874 static const char* GetVMString() { return "1"; }
9875 };
9876 template <> struct TagToType<0x0020,0x1000> {
9877 static const char* GetVRString() { return "IS"; }
9878 typedef VRToType<VR::IS>::Type Type;
9879 enum : long long { VRType = VR::IS };
9880 enum { VMType = VM::VM1 };
9881 static const char* GetVMString() { return "1"; }
9882 };
9883 template <> struct TagToType<0x0020,0x1001> {
9884 static const char* GetVRString() { return "IS"; }
9885 typedef VRToType<VR::IS>::Type Type;
9886 enum : long long { VRType = VR::IS };
9887 enum { VMType = VM::VM1 };
9888 static const char* GetVMString() { return "1"; }
9889 };
9890 template <> struct TagToType<0x0020,0x1002> {
9891 static const char* GetVRString() { return "IS"; }
9892 typedef VRToType<VR::IS>::Type Type;
9893 enum : long long { VRType = VR::IS };
9894 enum { VMType = VM::VM1 };
9895 static const char* GetVMString() { return "1"; }
9896 };
9897 template <> struct TagToType<0x0020,0x1003> {
9898 static const char* GetVRString() { return "IS"; }
9899 typedef VRToType<VR::IS>::Type Type;
9900 enum : long long { VRType = VR::IS };
9901 enum { VMType = VM::VM1 };
9902 static const char* GetVMString() { return "1"; }
9903 };
9904 template <> struct TagToType<0x0020,0x1004> {
9905 static const char* GetVRString() { return "IS"; }
9906 typedef VRToType<VR::IS>::Type Type;
9907 enum : long long { VRType = VR::IS };
9908 enum { VMType = VM::VM1 };
9909 static const char* GetVMString() { return "1"; }
9910 };
9911 template <> struct TagToType<0x0020,0x1005> {
9912 static const char* GetVRString() { return "IS"; }
9913 typedef VRToType<VR::IS>::Type Type;
9914 enum : long long { VRType = VR::IS };
9915 enum { VMType = VM::VM1 };
9916 static const char* GetVMString() { return "1"; }
9917 };
9918 template <> struct TagToType<0x0020,0x1020> {
9919 static const char* GetVRString() { return "LO"; }
9920 typedef VRToType<VR::LO>::Type Type;
9921 enum : long long { VRType = VR::LO };
9922 enum { VMType = VM::VM1_n };
9923 static const char* GetVMString() { return "1-n"; }
9924 };
9925 template <> struct TagToType<0x0020,0x103f> {
9926 static const char* GetVRString() { return "LO"; }
9927 typedef VRToType<VR::LO>::Type Type;
9928 enum : long long { VRType = VR::LO };
9929 enum { VMType = VM::VM1 };
9930 static const char* GetVMString() { return "1"; }
9931 };
9932 template <> struct TagToType<0x0020,0x1040> {
9933 static const char* GetVRString() { return "LO"; }
9934 typedef VRToType<VR::LO>::Type Type;
9935 enum : long long { VRType = VR::LO };
9936 enum { VMType = VM::VM1 };
9937 static const char* GetVMString() { return "1"; }
9938 };
9939 template <> struct TagToType<0x0020,0x1041> {
9940 static const char* GetVRString() { return "DS"; }
9941 typedef VRToType<VR::DS>::Type Type;
9942 enum : long long { VRType = VR::DS };
9943 enum { VMType = VM::VM1 };
9944 static const char* GetVMString() { return "1"; }
9945 };
9946 template <> struct TagToType<0x0020,0x1070> {
9947 static const char* GetVRString() { return "IS"; }
9948 typedef VRToType<VR::IS>::Type Type;
9949 enum : long long { VRType = VR::IS };
9950 enum { VMType = VM::VM1_n };
9951 static const char* GetVMString() { return "1-n"; }
9952 };
9953 template <> struct TagToType<0x0020,0x1200> {
9954 static const char* GetVRString() { return "IS"; }
9955 typedef VRToType<VR::IS>::Type Type;
9956 enum : long long { VRType = VR::IS };
9957 enum { VMType = VM::VM1 };
9958 static const char* GetVMString() { return "1"; }
9959 };
9960 template <> struct TagToType<0x0020,0x1202> {
9961 static const char* GetVRString() { return "IS"; }
9962 typedef VRToType<VR::IS>::Type Type;
9963 enum : long long { VRType = VR::IS };
9964 enum { VMType = VM::VM1 };
9965 static const char* GetVMString() { return "1"; }
9966 };
9967 template <> struct TagToType<0x0020,0x1204> {
9968 static const char* GetVRString() { return "IS"; }
9969 typedef VRToType<VR::IS>::Type Type;
9970 enum : long long { VRType = VR::IS };
9971 enum { VMType = VM::VM1 };
9972 static const char* GetVMString() { return "1"; }
9973 };
9974 template <> struct TagToType<0x0020,0x1206> {
9975 static const char* GetVRString() { return "IS"; }
9976 typedef VRToType<VR::IS>::Type Type;
9977 enum : long long { VRType = VR::IS };
9978 enum { VMType = VM::VM1 };
9979 static const char* GetVMString() { return "1"; }
9980 };
9981 template <> struct TagToType<0x0020,0x1208> {
9982 static const char* GetVRString() { return "IS"; }
9983 typedef VRToType<VR::IS>::Type Type;
9984 enum : long long { VRType = VR::IS };
9985 enum { VMType = VM::VM1 };
9986 static const char* GetVMString() { return "1"; }
9987 };
9988 template <> struct TagToType<0x0020,0x1209> {
9989 static const char* GetVRString() { return "IS"; }
9990 typedef VRToType<VR::IS>::Type Type;
9991 enum : long long { VRType = VR::IS };
9992 enum { VMType = VM::VM1 };
9993 static const char* GetVMString() { return "1"; }
9994 };
9995 template <> struct TagToType<0x0020,0x3401> {
9996 static const char* GetVRString() { return "CS"; }
9997 typedef VRToType<VR::CS>::Type Type;
9998 enum : long long { VRType = VR::CS };
9999 enum { VMType = VM::VM1 };
10000 static const char* GetVMString() { return "1"; }
10001 };
10002 template <> struct TagToType<0x0020,0x3402> {
10003 static const char* GetVRString() { return "CS"; }
10004 typedef VRToType<VR::CS>::Type Type;
10005 enum : long long { VRType = VR::CS };
10006 enum { VMType = VM::VM1 };
10007 static const char* GetVMString() { return "1"; }
10008 };
10009 template <> struct TagToType<0x0020,0x3403> {
10010 static const char* GetVRString() { return "DA"; }
10011 typedef VRToType<VR::DA>::Type Type;
10012 enum : long long { VRType = VR::DA };
10013 enum { VMType = VM::VM1 };
10014 static const char* GetVMString() { return "1"; }
10015 };
10016 template <> struct TagToType<0x0020,0x3404> {
10017 static const char* GetVRString() { return "LO"; }
10018 typedef VRToType<VR::LO>::Type Type;
10019 enum : long long { VRType = VR::LO };
10020 enum { VMType = VM::VM1 };
10021 static const char* GetVMString() { return "1"; }
10022 };
10023 template <> struct TagToType<0x0020,0x3405> {
10024 static const char* GetVRString() { return "TM"; }
10025 typedef VRToType<VR::TM>::Type Type;
10026 enum : long long { VRType = VR::TM };
10027 enum { VMType = VM::VM1 };
10028 static const char* GetVMString() { return "1"; }
10029 };
10030 template <> struct TagToType<0x0020,0x3406> {
10031 static const char* GetVRString() { return "LO"; }
10032 typedef VRToType<VR::LO>::Type Type;
10033 enum : long long { VRType = VR::LO };
10034 enum { VMType = VM::VM1 };
10035 static const char* GetVMString() { return "1"; }
10036 };
10037 template <> struct TagToType<0x0020,0x4000> {
10038 static const char* GetVRString() { return "LT"; }
10039 typedef VRToType<VR::LT>::Type Type;
10040 enum : long long { VRType = VR::LT };
10041 enum { VMType = VM::VM1 };
10042 static const char* GetVMString() { return "1"; }
10043 };
10044 template <> struct TagToType<0x0020,0x5000> {
10045 static const char* GetVRString() { return "AT"; }
10046 typedef VRToType<VR::AT>::Type Type;
10047 enum : long long { VRType = VR::AT };
10048 enum { VMType = VM::VM1_n };
10049 static const char* GetVMString() { return "1-n"; }
10050 };
10051 template <> struct TagToType<0x0020,0x5002> {
10052 static const char* GetVRString() { return "LO"; }
10053 typedef VRToType<VR::LO>::Type Type;
10054 enum : long long { VRType = VR::LO };
10055 enum { VMType = VM::VM1_n };
10056 static const char* GetVMString() { return "1-n"; }
10057 };
10058 template <> struct TagToType<0x0020,0x9056> {
10059 static const char* GetVRString() { return "SH"; }
10060 typedef VRToType<VR::SH>::Type Type;
10061 enum : long long { VRType = VR::SH };
10062 enum { VMType = VM::VM1 };
10063 static const char* GetVMString() { return "1"; }
10064 };
10065 template <> struct TagToType<0x0020,0x9057> {
10066 static const char* GetVRString() { return "UL"; }
10067 typedef VRToType<VR::UL>::Type Type;
10068 enum : long long { VRType = VR::UL };
10069 enum { VMType = VM::VM1 };
10070 static const char* GetVMString() { return "1"; }
10071 };
10072 template <> struct TagToType<0x0020,0x9071> {
10073 static const char* GetVRString() { return "SQ"; }
10074 typedef VRToType<VR::SQ>::Type Type;
10075 enum : long long { VRType = VR::SQ };
10076 enum { VMType = VM::VM1 };
10077 static const char* GetVMString() { return "1"; }
10078 };
10079 template <> struct TagToType<0x0020,0x9072> {
10080 static const char* GetVRString() { return "CS"; }
10081 typedef VRToType<VR::CS>::Type Type;
10082 enum : long long { VRType = VR::CS };
10083 enum { VMType = VM::VM1 };
10084 static const char* GetVMString() { return "1"; }
10085 };
10086 template <> struct TagToType<0x0020,0x9111> {
10087 static const char* GetVRString() { return "SQ"; }
10088 typedef VRToType<VR::SQ>::Type Type;
10089 enum : long long { VRType = VR::SQ };
10090 enum { VMType = VM::VM1 };
10091 static const char* GetVMString() { return "1"; }
10092 };
10093 template <> struct TagToType<0x0020,0x9113> {
10094 static const char* GetVRString() { return "SQ"; }
10095 typedef VRToType<VR::SQ>::Type Type;
10096 enum : long long { VRType = VR::SQ };
10097 enum { VMType = VM::VM1 };
10098 static const char* GetVMString() { return "1"; }
10099 };
10100 template <> struct TagToType<0x0020,0x9116> {
10101 static const char* GetVRString() { return "SQ"; }
10102 typedef VRToType<VR::SQ>::Type Type;
10103 enum : long long { VRType = VR::SQ };
10104 enum { VMType = VM::VM1 };
10105 static const char* GetVMString() { return "1"; }
10106 };
10107 template <> struct TagToType<0x0020,0x9128> {
10108 static const char* GetVRString() { return "UL"; }
10109 typedef VRToType<VR::UL>::Type Type;
10110 enum : long long { VRType = VR::UL };
10111 enum { VMType = VM::VM1 };
10112 static const char* GetVMString() { return "1"; }
10113 };
10114 template <> struct TagToType<0x0020,0x9153> {
10115 static const char* GetVRString() { return "FD"; }
10116 typedef VRToType<VR::FD>::Type Type;
10117 enum : long long { VRType = VR::FD };
10118 enum { VMType = VM::VM1 };
10119 static const char* GetVMString() { return "1"; }
10120 };
10121 template <> struct TagToType<0x0020,0x9154> {
10122 static const char* GetVRString() { return "FL"; }
10123 typedef VRToType<VR::FL>::Type Type;
10124 enum : long long { VRType = VR::FL };
10125 enum { VMType = VM::VM1 };
10126 static const char* GetVMString() { return "1"; }
10127 };
10128 template <> struct TagToType<0x0020,0x9155> {
10129 static const char* GetVRString() { return "FL"; }
10130 typedef VRToType<VR::FL>::Type Type;
10131 enum : long long { VRType = VR::FL };
10132 enum { VMType = VM::VM1 };
10133 static const char* GetVMString() { return "1"; }
10134 };
10135 template <> struct TagToType<0x0020,0x9156> {
10136 static const char* GetVRString() { return "US"; }
10137 typedef VRToType<VR::US>::Type Type;
10138 enum : long long { VRType = VR::US };
10139 enum { VMType = VM::VM1 };
10140 static const char* GetVMString() { return "1"; }
10141 };
10142 template <> struct TagToType<0x0020,0x9157> {
10143 static const char* GetVRString() { return "UL"; }
10144 typedef VRToType<VR::UL>::Type Type;
10145 enum : long long { VRType = VR::UL };
10146 enum { VMType = VM::VM1_n };
10147 static const char* GetVMString() { return "1-n"; }
10148 };
10149 template <> struct TagToType<0x0020,0x9158> {
10150 static const char* GetVRString() { return "LT"; }
10151 typedef VRToType<VR::LT>::Type Type;
10152 enum : long long { VRType = VR::LT };
10153 enum { VMType = VM::VM1 };
10154 static const char* GetVMString() { return "1"; }
10155 };
10156 template <> struct TagToType<0x0020,0x9161> {
10157 static const char* GetVRString() { return "UI"; }
10158 typedef VRToType<VR::UI>::Type Type;
10159 enum : long long { VRType = VR::UI };
10160 enum { VMType = VM::VM1 };
10161 static const char* GetVMString() { return "1"; }
10162 };
10163 template <> struct TagToType<0x0020,0x9162> {
10164 static const char* GetVRString() { return "US"; }
10165 typedef VRToType<VR::US>::Type Type;
10166 enum : long long { VRType = VR::US };
10167 enum { VMType = VM::VM1 };
10168 static const char* GetVMString() { return "1"; }
10169 };
10170 template <> struct TagToType<0x0020,0x9163> {
10171 static const char* GetVRString() { return "US"; }
10172 typedef VRToType<VR::US>::Type Type;
10173 enum : long long { VRType = VR::US };
10174 enum { VMType = VM::VM1 };
10175 static const char* GetVMString() { return "1"; }
10176 };
10177 template <> struct TagToType<0x0020,0x9164> {
10178 static const char* GetVRString() { return "UI"; }
10179 typedef VRToType<VR::UI>::Type Type;
10180 enum : long long { VRType = VR::UI };
10181 enum { VMType = VM::VM1 };
10182 static const char* GetVMString() { return "1"; }
10183 };
10184 template <> struct TagToType<0x0020,0x9165> {
10185 static const char* GetVRString() { return "AT"; }
10186 typedef VRToType<VR::AT>::Type Type;
10187 enum : long long { VRType = VR::AT };
10188 enum { VMType = VM::VM1 };
10189 static const char* GetVMString() { return "1"; }
10190 };
10191 template <> struct TagToType<0x0020,0x9167> {
10192 static const char* GetVRString() { return "AT"; }
10193 typedef VRToType<VR::AT>::Type Type;
10194 enum : long long { VRType = VR::AT };
10195 enum { VMType = VM::VM1 };
10196 static const char* GetVMString() { return "1"; }
10197 };
10198 template <> struct TagToType<0x0020,0x9170> {
10199 static const char* GetVRString() { return "SQ"; }
10200 typedef VRToType<VR::SQ>::Type Type;
10201 enum : long long { VRType = VR::SQ };
10202 enum { VMType = VM::VM1 };
10203 static const char* GetVMString() { return "1"; }
10204 };
10205 template <> struct TagToType<0x0020,0x9171> {
10206 static const char* GetVRString() { return "SQ"; }
10207 typedef VRToType<VR::SQ>::Type Type;
10208 enum : long long { VRType = VR::SQ };
10209 enum { VMType = VM::VM1 };
10210 static const char* GetVMString() { return "1"; }
10211 };
10212 template <> struct TagToType<0x0020,0x9172> {
10213 static const char* GetVRString() { return "SQ"; }
10214 typedef VRToType<VR::SQ>::Type Type;
10215 enum : long long { VRType = VR::SQ };
10216 enum { VMType = VM::VM1 };
10217 static const char* GetVMString() { return "1"; }
10218 };
10219 template <> struct TagToType<0x0020,0x9213> {
10220 static const char* GetVRString() { return "LO"; }
10221 typedef VRToType<VR::LO>::Type Type;
10222 enum : long long { VRType = VR::LO };
10223 enum { VMType = VM::VM1 };
10224 static const char* GetVMString() { return "1"; }
10225 };
10226 template <> struct TagToType<0x0020,0x9221> {
10227 static const char* GetVRString() { return "SQ"; }
10228 typedef VRToType<VR::SQ>::Type Type;
10229 enum : long long { VRType = VR::SQ };
10230 enum { VMType = VM::VM1 };
10231 static const char* GetVMString() { return "1"; }
10232 };
10233 template <> struct TagToType<0x0020,0x9222> {
10234 static const char* GetVRString() { return "SQ"; }
10235 typedef VRToType<VR::SQ>::Type Type;
10236 enum : long long { VRType = VR::SQ };
10237 enum { VMType = VM::VM1 };
10238 static const char* GetVMString() { return "1"; }
10239 };
10240 template <> struct TagToType<0x0020,0x9228> {
10241 static const char* GetVRString() { return "UL"; }
10242 typedef VRToType<VR::UL>::Type Type;
10243 enum : long long { VRType = VR::UL };
10244 enum { VMType = VM::VM1 };
10245 static const char* GetVMString() { return "1"; }
10246 };
10247 template <> struct TagToType<0x0020,0x9238> {
10248 static const char* GetVRString() { return "LO"; }
10249 typedef VRToType<VR::LO>::Type Type;
10250 enum : long long { VRType = VR::LO };
10251 enum { VMType = VM::VM1 };
10252 static const char* GetVMString() { return "1"; }
10253 };
10254 template <> struct TagToType<0x0020,0x9241> {
10255 static const char* GetVRString() { return "FL"; }
10256 typedef VRToType<VR::FL>::Type Type;
10257 enum : long long { VRType = VR::FL };
10258 enum { VMType = VM::VM1 };
10259 static const char* GetVMString() { return "1"; }
10260 };
10261 template <> struct TagToType<0x0020,0x9245> {
10262 static const char* GetVRString() { return "FL"; }
10263 typedef VRToType<VR::FL>::Type Type;
10264 enum : long long { VRType = VR::FL };
10265 enum { VMType = VM::VM1 };
10266 static const char* GetVMString() { return "1"; }
10267 };
10268 template <> struct TagToType<0x0020,0x9246> {
10269 static const char* GetVRString() { return "FL"; }
10270 typedef VRToType<VR::FL>::Type Type;
10271 enum : long long { VRType = VR::FL };
10272 enum { VMType = VM::VM1 };
10273 static const char* GetVMString() { return "1"; }
10274 };
10275 template <> struct TagToType<0x0020,0x9247> {
10276 static const char* GetVRString() { return "CS"; }
10277 typedef VRToType<VR::CS>::Type Type;
10278 enum : long long { VRType = VR::CS };
10279 enum { VMType = VM::VM1 };
10280 static const char* GetVMString() { return "1"; }
10281 };
10282 template <> struct TagToType<0x0020,0x9248> {
10283 static const char* GetVRString() { return "FL"; }
10284 typedef VRToType<VR::FL>::Type Type;
10285 enum : long long { VRType = VR::FL };
10286 enum { VMType = VM::VM1 };
10287 static const char* GetVMString() { return "1"; }
10288 };
10289 template <> struct TagToType<0x0020,0x9249> {
10290 static const char* GetVRString() { return "CS"; }
10291 typedef VRToType<VR::CS>::Type Type;
10292 enum : long long { VRType = VR::CS };
10293 enum { VMType = VM::VM1 };
10294 static const char* GetVMString() { return "1"; }
10295 };
10296 template <> struct TagToType<0x0020,0x9250> {
10297 static const char* GetVRString() { return "CS"; }
10298 typedef VRToType<VR::CS>::Type Type;
10299 enum : long long { VRType = VR::CS };
10300 enum { VMType = VM::VM1 };
10301 static const char* GetVMString() { return "1"; }
10302 };
10303 template <> struct TagToType<0x0020,0x9251> {
10304 static const char* GetVRString() { return "FD"; }
10305 typedef VRToType<VR::FD>::Type Type;
10306 enum : long long { VRType = VR::FD };
10307 enum { VMType = VM::VM1 };
10308 static const char* GetVMString() { return "1"; }
10309 };
10310 template <> struct TagToType<0x0020,0x9252> {
10311 static const char* GetVRString() { return "FD"; }
10312 typedef VRToType<VR::FD>::Type Type;
10313 enum : long long { VRType = VR::FD };
10314 enum { VMType = VM::VM1 };
10315 static const char* GetVMString() { return "1"; }
10316 };
10317 template <> struct TagToType<0x0020,0x9253> {
10318 static const char* GetVRString() { return "SQ"; }
10319 typedef VRToType<VR::SQ>::Type Type;
10320 enum : long long { VRType = VR::SQ };
10321 enum { VMType = VM::VM1 };
10322 static const char* GetVMString() { return "1"; }
10323 };
10324 template <> struct TagToType<0x0020,0x9254> {
10325 static const char* GetVRString() { return "FD"; }
10326 typedef VRToType<VR::FD>::Type Type;
10327 enum : long long { VRType = VR::FD };
10328 enum { VMType = VM::VM1 };
10329 static const char* GetVMString() { return "1"; }
10330 };
10331 template <> struct TagToType<0x0020,0x9255> {
10332 static const char* GetVRString() { return "FD"; }
10333 typedef VRToType<VR::FD>::Type Type;
10334 enum : long long { VRType = VR::FD };
10335 enum { VMType = VM::VM1 };
10336 static const char* GetVMString() { return "1"; }
10337 };
10338 template <> struct TagToType<0x0020,0x9256> {
10339 static const char* GetVRString() { return "FD"; }
10340 typedef VRToType<VR::FD>::Type Type;
10341 enum : long long { VRType = VR::FD };
10342 enum { VMType = VM::VM1 };
10343 static const char* GetVMString() { return "1"; }
10344 };
10345 template <> struct TagToType<0x0020,0x9257> {
10346 static const char* GetVRString() { return "FD"; }
10347 typedef VRToType<VR::FD>::Type Type;
10348 enum : long long { VRType = VR::FD };
10349 enum { VMType = VM::VM1 };
10350 static const char* GetVMString() { return "1"; }
10351 };
10352 template <> struct TagToType<0x0020,0x9301> {
10353 static const char* GetVRString() { return "FD"; }
10354 typedef VRToType<VR::FD>::Type Type;
10355 enum : long long { VRType = VR::FD };
10356 enum { VMType = VM::VM3 };
10357 static const char* GetVMString() { return "3"; }
10358 };
10359 template <> struct TagToType<0x0020,0x9302> {
10360 static const char* GetVRString() { return "FD"; }
10361 typedef VRToType<VR::FD>::Type Type;
10362 enum : long long { VRType = VR::FD };
10363 enum { VMType = VM::VM6 };
10364 static const char* GetVMString() { return "6"; }
10365 };
10366 template <> struct TagToType<0x0020,0x9307> {
10367 static const char* GetVRString() { return "CS"; }
10368 typedef VRToType<VR::CS>::Type Type;
10369 enum : long long { VRType = VR::CS };
10370 enum { VMType = VM::VM1 };
10371 static const char* GetVMString() { return "1"; }
10372 };
10373 template <> struct TagToType<0x0020,0x9308> {
10374 static const char* GetVRString() { return "FD"; }
10375 typedef VRToType<VR::FD>::Type Type;
10376 enum : long long { VRType = VR::FD };
10377 enum { VMType = VM::VM3 };
10378 static const char* GetVMString() { return "3"; }
10379 };
10380 template <> struct TagToType<0x0020,0x9309> {
10381 static const char* GetVRString() { return "FD"; }
10382 typedef VRToType<VR::FD>::Type Type;
10383 enum : long long { VRType = VR::FD };
10384 enum { VMType = VM::VM16 };
10385 static const char* GetVMString() { return "16"; }
10386 };
10387 template <> struct TagToType<0x0020,0x930a> {
10388 static const char* GetVRString() { return "FD"; }
10389 typedef VRToType<VR::FD>::Type Type;
10390 enum : long long { VRType = VR::FD };
10391 enum { VMType = VM::VM16 };
10392 static const char* GetVMString() { return "16"; }
10393 };
10394 template <> struct TagToType<0x0020,0x930b> {
10395 static const char* GetVRString() { return "CS"; }
10396 typedef VRToType<VR::CS>::Type Type;
10397 enum : long long { VRType = VR::CS };
10398 enum { VMType = VM::VM1 };
10399 static const char* GetVMString() { return "1"; }
10400 };
10401 template <> struct TagToType<0x0020,0x930c> {
10402 static const char* GetVRString() { return "CS"; }
10403 typedef VRToType<VR::CS>::Type Type;
10404 enum : long long { VRType = VR::CS };
10405 enum { VMType = VM::VM1 };
10406 static const char* GetVMString() { return "1"; }
10407 };
10408 template <> struct TagToType<0x0020,0x930d> {
10409 static const char* GetVRString() { return "FD"; }
10410 typedef VRToType<VR::FD>::Type Type;
10411 enum : long long { VRType = VR::FD };
10412 enum { VMType = VM::VM1 };
10413 static const char* GetVMString() { return "1"; }
10414 };
10415 template <> struct TagToType<0x0020,0x930e> {
10416 static const char* GetVRString() { return "SQ"; }
10417 typedef VRToType<VR::SQ>::Type Type;
10418 enum : long long { VRType = VR::SQ };
10419 enum { VMType = VM::VM1 };
10420 static const char* GetVMString() { return "1"; }
10421 };
10422 template <> struct TagToType<0x0020,0x930f> {
10423 static const char* GetVRString() { return "SQ"; }
10424 typedef VRToType<VR::SQ>::Type Type;
10425 enum : long long { VRType = VR::SQ };
10426 enum { VMType = VM::VM1 };
10427 static const char* GetVMString() { return "1"; }
10428 };
10429 template <> struct TagToType<0x0020,0x9310> {
10430 static const char* GetVRString() { return "SQ"; }
10431 typedef VRToType<VR::SQ>::Type Type;
10432 enum : long long { VRType = VR::SQ };
10433 enum { VMType = VM::VM1 };
10434 static const char* GetVMString() { return "1"; }
10435 };
10436 template <> struct TagToType<0x0020,0x9311> {
10437 static const char* GetVRString() { return "CS"; }
10438 typedef VRToType<VR::CS>::Type Type;
10439 enum : long long { VRType = VR::CS };
10440 enum { VMType = VM::VM1 };
10441 static const char* GetVMString() { return "1"; }
10442 };
10443 template <> struct TagToType<0x0020,0x9312> {
10444 static const char* GetVRString() { return "UI"; }
10445 typedef VRToType<VR::UI>::Type Type;
10446 enum : long long { VRType = VR::UI };
10447 enum { VMType = VM::VM1 };
10448 static const char* GetVMString() { return "1"; }
10449 };
10450 template <> struct TagToType<0x0020,0x9313> {
10451 static const char* GetVRString() { return "UI"; }
10452 typedef VRToType<VR::UI>::Type Type;
10453 enum : long long { VRType = VR::UI };
10454 enum { VMType = VM::VM1 };
10455 static const char* GetVMString() { return "1"; }
10456 };
10457 template <> struct TagToType<0x0020,0x9421> {
10458 static const char* GetVRString() { return "LO"; }
10459 typedef VRToType<VR::LO>::Type Type;
10460 enum : long long { VRType = VR::LO };
10461 enum { VMType = VM::VM1 };
10462 static const char* GetVMString() { return "1"; }
10463 };
10464 template <> struct TagToType<0x0020,0x9450> {
10465 static const char* GetVRString() { return "SQ"; }
10466 typedef VRToType<VR::SQ>::Type Type;
10467 enum : long long { VRType = VR::SQ };
10468 enum { VMType = VM::VM1 };
10469 static const char* GetVMString() { return "1"; }
10470 };
10471 template <> struct TagToType<0x0020,0x9453> {
10472 static const char* GetVRString() { return "LO"; }
10473 typedef VRToType<VR::LO>::Type Type;
10474 enum : long long { VRType = VR::LO };
10475 enum { VMType = VM::VM1 };
10476 static const char* GetVMString() { return "1"; }
10477 };
10478 template <> struct TagToType<0x0020,0x9518> {
10479 static const char* GetVRString() { return "US"; }
10480 typedef VRToType<VR::US>::Type Type;
10481 enum : long long { VRType = VR::US };
10482 enum { VMType = VM::VM1_n };
10483 static const char* GetVMString() { return "1-n"; }
10484 };
10485 template <> struct TagToType<0x0020,0x9529> {
10486 static const char* GetVRString() { return "SQ"; }
10487 typedef VRToType<VR::SQ>::Type Type;
10488 enum : long long { VRType = VR::SQ };
10489 enum { VMType = VM::VM1 };
10490 static const char* GetVMString() { return "1"; }
10491 };
10492 template <> struct TagToType<0x0020,0x9536> {
10493 static const char* GetVRString() { return "US"; }
10494 typedef VRToType<VR::US>::Type Type;
10495 enum : long long { VRType = VR::US };
10496 enum { VMType = VM::VM1 };
10497 static const char* GetVMString() { return "1"; }
10498 };
10499 template <> struct TagToType<0x0022,0x0001> {
10500 static const char* GetVRString() { return "US"; }
10501 typedef VRToType<VR::US>::Type Type;
10502 enum : long long { VRType = VR::US };
10503 enum { VMType = VM::VM1 };
10504 static const char* GetVMString() { return "1"; }
10505 };
10506 template <> struct TagToType<0x0022,0x0002> {
10507 static const char* GetVRString() { return "US"; }
10508 typedef VRToType<VR::US>::Type Type;
10509 enum : long long { VRType = VR::US };
10510 enum { VMType = VM::VM2 };
10511 static const char* GetVMString() { return "2"; }
10512 };
10513 template <> struct TagToType<0x0022,0x0003> {
10514 static const char* GetVRString() { return "US"; }
10515 typedef VRToType<VR::US>::Type Type;
10516 enum : long long { VRType = VR::US };
10517 enum { VMType = VM::VM1 };
10518 static const char* GetVMString() { return "1"; }
10519 };
10520 template <> struct TagToType<0x0022,0x0004> {
10521 static const char* GetVRString() { return "US"; }
10522 typedef VRToType<VR::US>::Type Type;
10523 enum : long long { VRType = VR::US };
10524 enum { VMType = VM::VM2 };
10525 static const char* GetVMString() { return "2"; }
10526 };
10527 template <> struct TagToType<0x0022,0x0005> {
10528 static const char* GetVRString() { return "CS"; }
10529 typedef VRToType<VR::CS>::Type Type;
10530 enum : long long { VRType = VR::CS };
10531 enum { VMType = VM::VM1 };
10532 static const char* GetVMString() { return "1"; }
10533 };
10534 template <> struct TagToType<0x0022,0x0006> {
10535 static const char* GetVRString() { return "SQ"; }
10536 typedef VRToType<VR::SQ>::Type Type;
10537 enum : long long { VRType = VR::SQ };
10538 enum { VMType = VM::VM1 };
10539 static const char* GetVMString() { return "1"; }
10540 };
10541 template <> struct TagToType<0x0022,0x0007> {
10542 static const char* GetVRString() { return "FL"; }
10543 typedef VRToType<VR::FL>::Type Type;
10544 enum : long long { VRType = VR::FL };
10545 enum { VMType = VM::VM1 };
10546 static const char* GetVMString() { return "1"; }
10547 };
10548 template <> struct TagToType<0x0022,0x0008> {
10549 static const char* GetVRString() { return "FL"; }
10550 typedef VRToType<VR::FL>::Type Type;
10551 enum : long long { VRType = VR::FL };
10552 enum { VMType = VM::VM1 };
10553 static const char* GetVMString() { return "1"; }
10554 };
10555 template <> struct TagToType<0x0022,0x0009> {
10556 static const char* GetVRString() { return "FL"; }
10557 typedef VRToType<VR::FL>::Type Type;
10558 enum : long long { VRType = VR::FL };
10559 enum { VMType = VM::VM1 };
10560 static const char* GetVMString() { return "1"; }
10561 };
10562 template <> struct TagToType<0x0022,0x000a> {
10563 static const char* GetVRString() { return "FL"; }
10564 typedef VRToType<VR::FL>::Type Type;
10565 enum : long long { VRType = VR::FL };
10566 enum { VMType = VM::VM1 };
10567 static const char* GetVMString() { return "1"; }
10568 };
10569 template <> struct TagToType<0x0022,0x000b> {
10570 static const char* GetVRString() { return "FL"; }
10571 typedef VRToType<VR::FL>::Type Type;
10572 enum : long long { VRType = VR::FL };
10573 enum { VMType = VM::VM1 };
10574 static const char* GetVMString() { return "1"; }
10575 };
10576 template <> struct TagToType<0x0022,0x000c> {
10577 static const char* GetVRString() { return "FL"; }
10578 typedef VRToType<VR::FL>::Type Type;
10579 enum : long long { VRType = VR::FL };
10580 enum { VMType = VM::VM1 };
10581 static const char* GetVMString() { return "1"; }
10582 };
10583 template <> struct TagToType<0x0022,0x000d> {
10584 static const char* GetVRString() { return "CS"; }
10585 typedef VRToType<VR::CS>::Type Type;
10586 enum : long long { VRType = VR::CS };
10587 enum { VMType = VM::VM1 };
10588 static const char* GetVMString() { return "1"; }
10589 };
10590 template <> struct TagToType<0x0022,0x000e> {
10591 static const char* GetVRString() { return "FL"; }
10592 typedef VRToType<VR::FL>::Type Type;
10593 enum : long long { VRType = VR::FL };
10594 enum { VMType = VM::VM1 };
10595 static const char* GetVMString() { return "1"; }
10596 };
10597 template <> struct TagToType<0x0022,0x0010> {
10598 static const char* GetVRString() { return "FL"; }
10599 typedef VRToType<VR::FL>::Type Type;
10600 enum : long long { VRType = VR::FL };
10601 enum { VMType = VM::VM1 };
10602 static const char* GetVMString() { return "1"; }
10603 };
10604 template <> struct TagToType<0x0022,0x0011> {
10605 static const char* GetVRString() { return "FL"; }
10606 typedef VRToType<VR::FL>::Type Type;
10607 enum : long long { VRType = VR::FL };
10608 enum { VMType = VM::VM1 };
10609 static const char* GetVMString() { return "1"; }
10610 };
10611 template <> struct TagToType<0x0022,0x0012> {
10612 static const char* GetVRString() { return "FL"; }
10613 typedef VRToType<VR::FL>::Type Type;
10614 enum : long long { VRType = VR::FL };
10615 enum { VMType = VM::VM1 };
10616 static const char* GetVMString() { return "1"; }
10617 };
10618 template <> struct TagToType<0x0022,0x0013> {
10619 static const char* GetVRString() { return "FL"; }
10620 typedef VRToType<VR::FL>::Type Type;
10621 enum : long long { VRType = VR::FL };
10622 enum { VMType = VM::VM1 };
10623 static const char* GetVMString() { return "1"; }
10624 };
10625 template <> struct TagToType<0x0022,0x0014> {
10626 static const char* GetVRString() { return "FL"; }
10627 typedef VRToType<VR::FL>::Type Type;
10628 enum : long long { VRType = VR::FL };
10629 enum { VMType = VM::VM1 };
10630 static const char* GetVMString() { return "1"; }
10631 };
10632 template <> struct TagToType<0x0022,0x0015> {
10633 static const char* GetVRString() { return "SQ"; }
10634 typedef VRToType<VR::SQ>::Type Type;
10635 enum : long long { VRType = VR::SQ };
10636 enum { VMType = VM::VM1 };
10637 static const char* GetVMString() { return "1"; }
10638 };
10639 template <> struct TagToType<0x0022,0x0016> {
10640 static const char* GetVRString() { return "SQ"; }
10641 typedef VRToType<VR::SQ>::Type Type;
10642 enum : long long { VRType = VR::SQ };
10643 enum { VMType = VM::VM1 };
10644 static const char* GetVMString() { return "1"; }
10645 };
10646 template <> struct TagToType<0x0022,0x0017> {
10647 static const char* GetVRString() { return "SQ"; }
10648 typedef VRToType<VR::SQ>::Type Type;
10649 enum : long long { VRType = VR::SQ };
10650 enum { VMType = VM::VM1 };
10651 static const char* GetVMString() { return "1"; }
10652 };
10653 template <> struct TagToType<0x0022,0x0018> {
10654 static const char* GetVRString() { return "SQ"; }
10655 typedef VRToType<VR::SQ>::Type Type;
10656 enum : long long { VRType = VR::SQ };
10657 enum { VMType = VM::VM1 };
10658 static const char* GetVMString() { return "1"; }
10659 };
10660 template <> struct TagToType<0x0022,0x0019> {
10661 static const char* GetVRString() { return "SQ"; }
10662 typedef VRToType<VR::SQ>::Type Type;
10663 enum : long long { VRType = VR::SQ };
10664 enum { VMType = VM::VM1 };
10665 static const char* GetVMString() { return "1"; }
10666 };
10667 template <> struct TagToType<0x0022,0x001a> {
10668 static const char* GetVRString() { return "SQ"; }
10669 typedef VRToType<VR::SQ>::Type Type;
10670 enum : long long { VRType = VR::SQ };
10671 enum { VMType = VM::VM1 };
10672 static const char* GetVMString() { return "1"; }
10673 };
10674 template <> struct TagToType<0x0022,0x001b> {
10675 static const char* GetVRString() { return "SQ"; }
10676 typedef VRToType<VR::SQ>::Type Type;
10677 enum : long long { VRType = VR::SQ };
10678 enum { VMType = VM::VM1 };
10679 static const char* GetVMString() { return "1"; }
10680 };
10681 template <> struct TagToType<0x0022,0x001c> {
10682 static const char* GetVRString() { return "SQ"; }
10683 typedef VRToType<VR::SQ>::Type Type;
10684 enum : long long { VRType = VR::SQ };
10685 enum { VMType = VM::VM1 };
10686 static const char* GetVMString() { return "1"; }
10687 };
10688 template <> struct TagToType<0x0022,0x001d> {
10689 static const char* GetVRString() { return "SQ"; }
10690 typedef VRToType<VR::SQ>::Type Type;
10691 enum : long long { VRType = VR::SQ };
10692 enum { VMType = VM::VM1 };
10693 static const char* GetVMString() { return "1"; }
10694 };
10695 template <> struct TagToType<0x0022,0x001e> {
10696 static const char* GetVRString() { return "FL"; }
10697 typedef VRToType<VR::FL>::Type Type;
10698 enum : long long { VRType = VR::FL };
10699 enum { VMType = VM::VM1 };
10700 static const char* GetVMString() { return "1"; }
10701 };
10702 template <> struct TagToType<0x0022,0x0020> {
10703 static const char* GetVRString() { return "SQ"; }
10704 typedef VRToType<VR::SQ>::Type Type;
10705 enum : long long { VRType = VR::SQ };
10706 enum { VMType = VM::VM1 };
10707 static const char* GetVMString() { return "1"; }
10708 };
10709 template <> struct TagToType<0x0022,0x0021> {
10710 static const char* GetVRString() { return "SQ"; }
10711 typedef VRToType<VR::SQ>::Type Type;
10712 enum : long long { VRType = VR::SQ };
10713 enum { VMType = VM::VM1 };
10714 static const char* GetVMString() { return "1"; }
10715 };
10716 template <> struct TagToType<0x0022,0x0022> {
10717 static const char* GetVRString() { return "SQ"; }
10718 typedef VRToType<VR::SQ>::Type Type;
10719 enum : long long { VRType = VR::SQ };
10720 enum { VMType = VM::VM1 };
10721 static const char* GetVMString() { return "1"; }
10722 };
10723 template <> struct TagToType<0x0022,0x0028> {
10724 static const char* GetVRString() { return "CS"; }
10725 typedef VRToType<VR::CS>::Type Type;
10726 enum : long long { VRType = VR::CS };
10727 enum { VMType = VM::VM1 };
10728 static const char* GetVMString() { return "1"; }
10729 };
10730 template <> struct TagToType<0x0022,0x0030> {
10731 static const char* GetVRString() { return "FL"; }
10732 typedef VRToType<VR::FL>::Type Type;
10733 enum : long long { VRType = VR::FL };
10734 enum { VMType = VM::VM1 };
10735 static const char* GetVMString() { return "1"; }
10736 };
10737 template <> struct TagToType<0x0022,0x0031> {
10738 static const char* GetVRString() { return "SQ"; }
10739 typedef VRToType<VR::SQ>::Type Type;
10740 enum : long long { VRType = VR::SQ };
10741 enum { VMType = VM::VM1 };
10742 static const char* GetVMString() { return "1"; }
10743 };
10744 template <> struct TagToType<0x0022,0x0032> {
10745 static const char* GetVRString() { return "FL"; }
10746 typedef VRToType<VR::FL>::Type Type;
10747 enum : long long { VRType = VR::FL };
10748 enum { VMType = VM::VM2_2n };
10749 static const char* GetVMString() { return "2-2n"; }
10750 };
10751 template <> struct TagToType<0x0022,0x0035> {
10752 static const char* GetVRString() { return "FL"; }
10753 typedef VRToType<VR::FL>::Type Type;
10754 enum : long long { VRType = VR::FL };
10755 enum { VMType = VM::VM1 };
10756 static const char* GetVMString() { return "1"; }
10757 };
10758 template <> struct TagToType<0x0022,0x0036> {
10759 static const char* GetVRString() { return "FL"; }
10760 typedef VRToType<VR::FL>::Type Type;
10761 enum : long long { VRType = VR::FL };
10762 enum { VMType = VM::VM1 };
10763 static const char* GetVMString() { return "1"; }
10764 };
10765 template <> struct TagToType<0x0022,0x0037> {
10766 static const char* GetVRString() { return "FL"; }
10767 typedef VRToType<VR::FL>::Type Type;
10768 enum : long long { VRType = VR::FL };
10769 enum { VMType = VM::VM1 };
10770 static const char* GetVMString() { return "1"; }
10771 };
10772 template <> struct TagToType<0x0022,0x0038> {
10773 static const char* GetVRString() { return "FL"; }
10774 typedef VRToType<VR::FL>::Type Type;
10775 enum : long long { VRType = VR::FL };
10776 enum { VMType = VM::VM1 };
10777 static const char* GetVMString() { return "1"; }
10778 };
10779 template <> struct TagToType<0x0022,0x0039> {
10780 static const char* GetVRString() { return "CS"; }
10781 typedef VRToType<VR::CS>::Type Type;
10782 enum : long long { VRType = VR::CS };
10783 enum { VMType = VM::VM1 };
10784 static const char* GetVMString() { return "1"; }
10785 };
10786 template <> struct TagToType<0x0022,0x0041> {
10787 static const char* GetVRString() { return "FL"; }
10788 typedef VRToType<VR::FL>::Type Type;
10789 enum : long long { VRType = VR::FL };
10790 enum { VMType = VM::VM1 };
10791 static const char* GetVMString() { return "1"; }
10792 };
10793 template <> struct TagToType<0x0022,0x0042> {
10794 static const char* GetVRString() { return "SQ"; }
10795 typedef VRToType<VR::SQ>::Type Type;
10796 enum : long long { VRType = VR::SQ };
10797 enum { VMType = VM::VM1 };
10798 static const char* GetVMString() { return "1"; }
10799 };
10800 template <> struct TagToType<0x0022,0x0048> {
10801 static const char* GetVRString() { return "FL"; }
10802 typedef VRToType<VR::FL>::Type Type;
10803 enum : long long { VRType = VR::FL };
10804 enum { VMType = VM::VM1 };
10805 static const char* GetVMString() { return "1"; }
10806 };
10807 template <> struct TagToType<0x0022,0x0049> {
10808 static const char* GetVRString() { return "FL"; }
10809 typedef VRToType<VR::FL>::Type Type;
10810 enum : long long { VRType = VR::FL };
10811 enum { VMType = VM::VM1 };
10812 static const char* GetVMString() { return "1"; }
10813 };
10814 template <> struct TagToType<0x0022,0x004e> {
10815 static const char* GetVRString() { return "DS"; }
10816 typedef VRToType<VR::DS>::Type Type;
10817 enum : long long { VRType = VR::DS };
10818 enum { VMType = VM::VM1 };
10819 static const char* GetVMString() { return "1"; }
10820 };
10821 template <> struct TagToType<0x0022,0x0055> {
10822 static const char* GetVRString() { return "FL"; }
10823 typedef VRToType<VR::FL>::Type Type;
10824 enum : long long { VRType = VR::FL };
10825 enum { VMType = VM::VM1 };
10826 static const char* GetVMString() { return "1"; }
10827 };
10828 template <> struct TagToType<0x0022,0x0056> {
10829 static const char* GetVRString() { return "FL"; }
10830 typedef VRToType<VR::FL>::Type Type;
10831 enum : long long { VRType = VR::FL };
10832 enum { VMType = VM::VM1 };
10833 static const char* GetVMString() { return "1"; }
10834 };
10835 template <> struct TagToType<0x0022,0x0057> {
10836 static const char* GetVRString() { return "FL"; }
10837 typedef VRToType<VR::FL>::Type Type;
10838 enum : long long { VRType = VR::FL };
10839 enum { VMType = VM::VM1 };
10840 static const char* GetVMString() { return "1"; }
10841 };
10842 template <> struct TagToType<0x0022,0x0058> {
10843 static const char* GetVRString() { return "SQ"; }
10844 typedef VRToType<VR::SQ>::Type Type;
10845 enum : long long { VRType = VR::SQ };
10846 enum { VMType = VM::VM1 };
10847 static const char* GetVMString() { return "1"; }
10848 };
10849 template <> struct TagToType<0x0022,0x1007> {
10850 static const char* GetVRString() { return "SQ"; }
10851 typedef VRToType<VR::SQ>::Type Type;
10852 enum : long long { VRType = VR::SQ };
10853 enum { VMType = VM::VM1 };
10854 static const char* GetVMString() { return "1"; }
10855 };
10856 template <> struct TagToType<0x0022,0x1008> {
10857 static const char* GetVRString() { return "SQ"; }
10858 typedef VRToType<VR::SQ>::Type Type;
10859 enum : long long { VRType = VR::SQ };
10860 enum { VMType = VM::VM1 };
10861 static const char* GetVMString() { return "1"; }
10862 };
10863 template <> struct TagToType<0x0022,0x1009> {
10864 static const char* GetVRString() { return "CS"; }
10865 typedef VRToType<VR::CS>::Type Type;
10866 enum : long long { VRType = VR::CS };
10867 enum { VMType = VM::VM1 };
10868 static const char* GetVMString() { return "1"; }
10869 };
10870 template <> struct TagToType<0x0022,0x1010> {
10871 static const char* GetVRString() { return "CS"; }
10872 typedef VRToType<VR::CS>::Type Type;
10873 enum : long long { VRType = VR::CS };
10874 enum { VMType = VM::VM1 };
10875 static const char* GetVMString() { return "1"; }
10876 };
10877 template <> struct TagToType<0x0022,0x1012> {
10878 static const char* GetVRString() { return "SQ"; }
10879 typedef VRToType<VR::SQ>::Type Type;
10880 enum : long long { VRType = VR::SQ };
10881 enum { VMType = VM::VM1 };
10882 static const char* GetVMString() { return "1"; }
10883 };
10884 template <> struct TagToType<0x0022,0x1019> {
10885 static const char* GetVRString() { return "FL"; }
10886 typedef VRToType<VR::FL>::Type Type;
10887 enum : long long { VRType = VR::FL };
10888 enum { VMType = VM::VM1 };
10889 static const char* GetVMString() { return "1"; }
10890 };
10891 template <> struct TagToType<0x0022,0x1024> {
10892 static const char* GetVRString() { return "SQ"; }
10893 typedef VRToType<VR::SQ>::Type Type;
10894 enum : long long { VRType = VR::SQ };
10895 enum { VMType = VM::VM1 };
10896 static const char* GetVMString() { return "1"; }
10897 };
10898 template <> struct TagToType<0x0022,0x1025> {
10899 static const char* GetVRString() { return "SQ"; }
10900 typedef VRToType<VR::SQ>::Type Type;
10901 enum : long long { VRType = VR::SQ };
10902 enum { VMType = VM::VM1 };
10903 static const char* GetVMString() { return "1"; }
10904 };
10905 template <> struct TagToType<0x0022,0x1028> {
10906 static const char* GetVRString() { return "SQ"; }
10907 typedef VRToType<VR::SQ>::Type Type;
10908 enum : long long { VRType = VR::SQ };
10909 enum { VMType = VM::VM1 };
10910 static const char* GetVMString() { return "1"; }
10911 };
10912 template <> struct TagToType<0x0022,0x1029> {
10913 static const char* GetVRString() { return "LO"; }
10914 typedef VRToType<VR::LO>::Type Type;
10915 enum : long long { VRType = VR::LO };
10916 enum { VMType = VM::VM1 };
10917 static const char* GetVMString() { return "1"; }
10918 };
10919 template <> struct TagToType<0x0022,0x1033> {
10920 static const char* GetVRString() { return "FL"; }
10921 typedef VRToType<VR::FL>::Type Type;
10922 enum : long long { VRType = VR::FL };
10923 enum { VMType = VM::VM1 };
10924 static const char* GetVMString() { return "1"; }
10925 };
10926 template <> struct TagToType<0x0022,0x1035> {
10927 static const char* GetVRString() { return "SQ"; }
10928 typedef VRToType<VR::SQ>::Type Type;
10929 enum : long long { VRType = VR::SQ };
10930 enum { VMType = VM::VM1 };
10931 static const char* GetVMString() { return "1"; }
10932 };
10933 template <> struct TagToType<0x0022,0x1037> {
10934 static const char* GetVRString() { return "FL"; }
10935 typedef VRToType<VR::FL>::Type Type;
10936 enum : long long { VRType = VR::FL };
10937 enum { VMType = VM::VM1 };
10938 static const char* GetVMString() { return "1"; }
10939 };
10940 template <> struct TagToType<0x0022,0x1039> {
10941 static const char* GetVRString() { return "CS"; }
10942 typedef VRToType<VR::CS>::Type Type;
10943 enum : long long { VRType = VR::CS };
10944 enum { VMType = VM::VM1 };
10945 static const char* GetVMString() { return "1"; }
10946 };
10947 template <> struct TagToType<0x0022,0x1040> {
10948 static const char* GetVRString() { return "SQ"; }
10949 typedef VRToType<VR::SQ>::Type Type;
10950 enum : long long { VRType = VR::SQ };
10951 enum { VMType = VM::VM1 };
10952 static const char* GetVMString() { return "1"; }
10953 };
10954 template <> struct TagToType<0x0022,0x1044> {
10955 static const char* GetVRString() { return "SQ"; }
10956 typedef VRToType<VR::SQ>::Type Type;
10957 enum : long long { VRType = VR::SQ };
10958 enum { VMType = VM::VM1 };
10959 static const char* GetVMString() { return "1"; }
10960 };
10961 template <> struct TagToType<0x0022,0x1050> {
10962 static const char* GetVRString() { return "SQ"; }
10963 typedef VRToType<VR::SQ>::Type Type;
10964 enum : long long { VRType = VR::SQ };
10965 enum { VMType = VM::VM1 };
10966 static const char* GetVMString() { return "1"; }
10967 };
10968 template <> struct TagToType<0x0022,0x1053> {
10969 static const char* GetVRString() { return "FL"; }
10970 typedef VRToType<VR::FL>::Type Type;
10971 enum : long long { VRType = VR::FL };
10972 enum { VMType = VM::VM1 };
10973 static const char* GetVMString() { return "1"; }
10974 };
10975 template <> struct TagToType<0x0022,0x1054> {
10976 static const char* GetVRString() { return "FL"; }
10977 typedef VRToType<VR::FL>::Type Type;
10978 enum : long long { VRType = VR::FL };
10979 enum { VMType = VM::VM1 };
10980 static const char* GetVMString() { return "1"; }
10981 };
10982 template <> struct TagToType<0x0022,0x1059> {
10983 static const char* GetVRString() { return "FL"; }
10984 typedef VRToType<VR::FL>::Type Type;
10985 enum : long long { VRType = VR::FL };
10986 enum { VMType = VM::VM1 };
10987 static const char* GetVMString() { return "1"; }
10988 };
10989 template <> struct TagToType<0x0022,0x1065> {
10990 static const char* GetVRString() { return "LO"; }
10991 typedef VRToType<VR::LO>::Type Type;
10992 enum : long long { VRType = VR::LO };
10993 enum { VMType = VM::VM1 };
10994 static const char* GetVMString() { return "1"; }
10995 };
10996 template <> struct TagToType<0x0022,0x1066> {
10997 static const char* GetVRString() { return "LO"; }
10998 typedef VRToType<VR::LO>::Type Type;
10999 enum : long long { VRType = VR::LO };
11000 enum { VMType = VM::VM1 };
11001 static const char* GetVMString() { return "1"; }
11002 };
11003 template <> struct TagToType<0x0022,0x1090> {
11004 static const char* GetVRString() { return "SQ"; }
11005 typedef VRToType<VR::SQ>::Type Type;
11006 enum : long long { VRType = VR::SQ };
11007 enum { VMType = VM::VM1 };
11008 static const char* GetVMString() { return "1"; }
11009 };
11010 template <> struct TagToType<0x0022,0x1092> {
11011 static const char* GetVRString() { return "SQ"; }
11012 typedef VRToType<VR::SQ>::Type Type;
11013 enum : long long { VRType = VR::SQ };
11014 enum { VMType = VM::VM1 };
11015 static const char* GetVMString() { return "1"; }
11016 };
11017 template <> struct TagToType<0x0022,0x1093> {
11018 static const char* GetVRString() { return "LO"; }
11019 typedef VRToType<VR::LO>::Type Type;
11020 enum : long long { VRType = VR::LO };
11021 enum { VMType = VM::VM1 };
11022 static const char* GetVMString() { return "1"; }
11023 };
11024 template <> struct TagToType<0x0022,0x1094> {
11025 static const char* GetVRString() { return "LO"; }
11026 typedef VRToType<VR::LO>::Type Type;
11027 enum : long long { VRType = VR::LO };
11028 enum { VMType = VM::VM1 };
11029 static const char* GetVMString() { return "1"; }
11030 };
11031 template <> struct TagToType<0x0022,0x1095> {
11032 static const char* GetVRString() { return "LO"; }
11033 typedef VRToType<VR::LO>::Type Type;
11034 enum : long long { VRType = VR::LO };
11035 enum { VMType = VM::VM1 };
11036 static const char* GetVMString() { return "1"; }
11037 };
11038 template <> struct TagToType<0x0022,0x1096> {
11039 static const char* GetVRString() { return "SQ"; }
11040 typedef VRToType<VR::SQ>::Type Type;
11041 enum : long long { VRType = VR::SQ };
11042 enum { VMType = VM::VM1 };
11043 static const char* GetVMString() { return "1"; }
11044 };
11045 template <> struct TagToType<0x0022,0x1097> {
11046 static const char* GetVRString() { return "LO"; }
11047 typedef VRToType<VR::LO>::Type Type;
11048 enum : long long { VRType = VR::LO };
11049 enum { VMType = VM::VM1 };
11050 static const char* GetVMString() { return "1"; }
11051 };
11052 template <> struct TagToType<0x0022,0x1100> {
11053 static const char* GetVRString() { return "SQ"; }
11054 typedef VRToType<VR::SQ>::Type Type;
11055 enum : long long { VRType = VR::SQ };
11056 enum { VMType = VM::VM1 };
11057 static const char* GetVMString() { return "1"; }
11058 };
11059 template <> struct TagToType<0x0022,0x1101> {
11060 static const char* GetVRString() { return "SQ"; }
11061 typedef VRToType<VR::SQ>::Type Type;
11062 enum : long long { VRType = VR::SQ };
11063 enum { VMType = VM::VM1 };
11064 static const char* GetVMString() { return "1"; }
11065 };
11066 template <> struct TagToType<0x0022,0x1103> {
11067 static const char* GetVRString() { return "SQ"; }
11068 typedef VRToType<VR::SQ>::Type Type;
11069 enum : long long { VRType = VR::SQ };
11070 enum { VMType = VM::VM1 };
11071 static const char* GetVMString() { return "1"; }
11072 };
11073 template <> struct TagToType<0x0022,0x1121> {
11074 static const char* GetVRString() { return "FL"; }
11075 typedef VRToType<VR::FL>::Type Type;
11076 enum : long long { VRType = VR::FL };
11077 enum { VMType = VM::VM1 };
11078 static const char* GetVMString() { return "1"; }
11079 };
11080 template <> struct TagToType<0x0022,0x1122> {
11081 static const char* GetVRString() { return "FL"; }
11082 typedef VRToType<VR::FL>::Type Type;
11083 enum : long long { VRType = VR::FL };
11084 enum { VMType = VM::VM1 };
11085 static const char* GetVMString() { return "1"; }
11086 };
11087 template <> struct TagToType<0x0022,0x1125> {
11088 static const char* GetVRString() { return "SQ"; }
11089 typedef VRToType<VR::SQ>::Type Type;
11090 enum : long long { VRType = VR::SQ };
11091 enum { VMType = VM::VM1 };
11092 static const char* GetVMString() { return "1"; }
11093 };
11094 template <> struct TagToType<0x0022,0x1127> {
11095 static const char* GetVRString() { return "SQ"; }
11096 typedef VRToType<VR::SQ>::Type Type;
11097 enum : long long { VRType = VR::SQ };
11098 enum { VMType = VM::VM1 };
11099 static const char* GetVMString() { return "1"; }
11100 };
11101 template <> struct TagToType<0x0022,0x1128> {
11102 static const char* GetVRString() { return "SQ"; }
11103 typedef VRToType<VR::SQ>::Type Type;
11104 enum : long long { VRType = VR::SQ };
11105 enum { VMType = VM::VM1 };
11106 static const char* GetVMString() { return "1"; }
11107 };
11108 template <> struct TagToType<0x0022,0x1130> {
11109 static const char* GetVRString() { return "FL"; }
11110 typedef VRToType<VR::FL>::Type Type;
11111 enum : long long { VRType = VR::FL };
11112 enum { VMType = VM::VM1 };
11113 static const char* GetVMString() { return "1"; }
11114 };
11115 template <> struct TagToType<0x0022,0x1131> {
11116 static const char* GetVRString() { return "FL"; }
11117 typedef VRToType<VR::FL>::Type Type;
11118 enum : long long { VRType = VR::FL };
11119 enum { VMType = VM::VM1 };
11120 static const char* GetVMString() { return "1"; }
11121 };
11122 template <> struct TagToType<0x0022,0x1132> {
11123 static const char* GetVRString() { return "SQ"; }
11124 typedef VRToType<VR::SQ>::Type Type;
11125 enum : long long { VRType = VR::SQ };
11126 enum { VMType = VM::VM1 };
11127 static const char* GetVMString() { return "1"; }
11128 };
11129 template <> struct TagToType<0x0022,0x1133> {
11130 static const char* GetVRString() { return "SQ"; }
11131 typedef VRToType<VR::SQ>::Type Type;
11132 enum : long long { VRType = VR::SQ };
11133 enum { VMType = VM::VM1 };
11134 static const char* GetVMString() { return "1"; }
11135 };
11136 template <> struct TagToType<0x0022,0x1134> {
11137 static const char* GetVRString() { return "SQ"; }
11138 typedef VRToType<VR::SQ>::Type Type;
11139 enum : long long { VRType = VR::SQ };
11140 enum { VMType = VM::VM1 };
11141 static const char* GetVMString() { return "1"; }
11142 };
11143 template <> struct TagToType<0x0022,0x1135> {
11144 static const char* GetVRString() { return "SQ"; }
11145 typedef VRToType<VR::SQ>::Type Type;
11146 enum : long long { VRType = VR::SQ };
11147 enum { VMType = VM::VM1 };
11148 static const char* GetVMString() { return "1"; }
11149 };
11150 template <> struct TagToType<0x0022,0x1140> {
11151 static const char* GetVRString() { return "CS"; }
11152 typedef VRToType<VR::CS>::Type Type;
11153 enum : long long { VRType = VR::CS };
11154 enum { VMType = VM::VM1 };
11155 static const char* GetVMString() { return "1"; }
11156 };
11157 template <> struct TagToType<0x0022,0x1150> {
11158 static const char* GetVRString() { return "SQ"; }
11159 typedef VRToType<VR::SQ>::Type Type;
11160 enum : long long { VRType = VR::SQ };
11161 enum { VMType = VM::VM1 };
11162 static const char* GetVMString() { return "1"; }
11163 };
11164 template <> struct TagToType<0x0022,0x1153> {
11165 static const char* GetVRString() { return "SQ"; }
11166 typedef VRToType<VR::SQ>::Type Type;
11167 enum : long long { VRType = VR::SQ };
11168 enum { VMType = VM::VM1 };
11169 static const char* GetVMString() { return "1"; }
11170 };
11171 template <> struct TagToType<0x0022,0x1155> {
11172 static const char* GetVRString() { return "FL"; }
11173 typedef VRToType<VR::FL>::Type Type;
11174 enum : long long { VRType = VR::FL };
11175 enum { VMType = VM::VM1 };
11176 static const char* GetVMString() { return "1"; }
11177 };
11178 template <> struct TagToType<0x0022,0x1159> {
11179 static const char* GetVRString() { return "LO"; }
11180 typedef VRToType<VR::LO>::Type Type;
11181 enum : long long { VRType = VR::LO };
11182 enum { VMType = VM::VM1 };
11183 static const char* GetVMString() { return "1"; }
11184 };
11185 template <> struct TagToType<0x0022,0x1210> {
11186 static const char* GetVRString() { return "SQ"; }
11187 typedef VRToType<VR::SQ>::Type Type;
11188 enum : long long { VRType = VR::SQ };
11189 enum { VMType = VM::VM1 };
11190 static const char* GetVMString() { return "1"; }
11191 };
11192 template <> struct TagToType<0x0022,0x1211> {
11193 static const char* GetVRString() { return "SQ"; }
11194 typedef VRToType<VR::SQ>::Type Type;
11195 enum : long long { VRType = VR::SQ };
11196 enum { VMType = VM::VM1 };
11197 static const char* GetVMString() { return "1"; }
11198 };
11199 template <> struct TagToType<0x0022,0x1212> {
11200 static const char* GetVRString() { return "SQ"; }
11201 typedef VRToType<VR::SQ>::Type Type;
11202 enum : long long { VRType = VR::SQ };
11203 enum { VMType = VM::VM1 };
11204 static const char* GetVMString() { return "1"; }
11205 };
11206 template <> struct TagToType<0x0022,0x1220> {
11207 static const char* GetVRString() { return "SQ"; }
11208 typedef VRToType<VR::SQ>::Type Type;
11209 enum : long long { VRType = VR::SQ };
11210 enum { VMType = VM::VM1 };
11211 static const char* GetVMString() { return "1"; }
11212 };
11213 template <> struct TagToType<0x0022,0x1225> {
11214 static const char* GetVRString() { return "SQ"; }
11215 typedef VRToType<VR::SQ>::Type Type;
11216 enum : long long { VRType = VR::SQ };
11217 enum { VMType = VM::VM1 };
11218 static const char* GetVMString() { return "1"; }
11219 };
11220 template <> struct TagToType<0x0022,0x1230> {
11221 static const char* GetVRString() { return "SQ"; }
11222 typedef VRToType<VR::SQ>::Type Type;
11223 enum : long long { VRType = VR::SQ };
11224 enum { VMType = VM::VM1 };
11225 static const char* GetVMString() { return "1"; }
11226 };
11227 template <> struct TagToType<0x0022,0x1250> {
11228 static const char* GetVRString() { return "SQ"; }
11229 typedef VRToType<VR::SQ>::Type Type;
11230 enum : long long { VRType = VR::SQ };
11231 enum { VMType = VM::VM1 };
11232 static const char* GetVMString() { return "1"; }
11233 };
11234 template <> struct TagToType<0x0022,0x1255> {
11235 static const char* GetVRString() { return "SQ"; }
11236 typedef VRToType<VR::SQ>::Type Type;
11237 enum : long long { VRType = VR::SQ };
11238 enum { VMType = VM::VM1 };
11239 static const char* GetVMString() { return "1"; }
11240 };
11241 template <> struct TagToType<0x0022,0x1257> {
11242 static const char* GetVRString() { return "SQ"; }
11243 typedef VRToType<VR::SQ>::Type Type;
11244 enum : long long { VRType = VR::SQ };
11245 enum { VMType = VM::VM1 };
11246 static const char* GetVMString() { return "1"; }
11247 };
11248 template <> struct TagToType<0x0022,0x1260> {
11249 static const char* GetVRString() { return "SQ"; }
11250 typedef VRToType<VR::SQ>::Type Type;
11251 enum : long long { VRType = VR::SQ };
11252 enum { VMType = VM::VM1 };
11253 static const char* GetVMString() { return "1"; }
11254 };
11255 template <> struct TagToType<0x0022,0x1262> {
11256 static const char* GetVRString() { return "SQ"; }
11257 typedef VRToType<VR::SQ>::Type Type;
11258 enum : long long { VRType = VR::SQ };
11259 enum { VMType = VM::VM1 };
11260 static const char* GetVMString() { return "1"; }
11261 };
11262 template <> struct TagToType<0x0022,0x1265> {
11263 static const char* GetVRString() { return "SQ"; }
11264 typedef VRToType<VR::SQ>::Type Type;
11265 enum : long long { VRType = VR::SQ };
11266 enum { VMType = VM::VM1 };
11267 static const char* GetVMString() { return "1"; }
11268 };
11269 template <> struct TagToType<0x0022,0x1273> {
11270 static const char* GetVRString() { return "LO"; }
11271 typedef VRToType<VR::LO>::Type Type;
11272 enum : long long { VRType = VR::LO };
11273 enum { VMType = VM::VM1 };
11274 static const char* GetVMString() { return "1"; }
11275 };
11276 template <> struct TagToType<0x0022,0x1300> {
11277 static const char* GetVRString() { return "SQ"; }
11278 typedef VRToType<VR::SQ>::Type Type;
11279 enum : long long { VRType = VR::SQ };
11280 enum { VMType = VM::VM1 };
11281 static const char* GetVMString() { return "1"; }
11282 };
11283 template <> struct TagToType<0x0022,0x1310> {
11284 static const char* GetVRString() { return "SQ"; }
11285 typedef VRToType<VR::SQ>::Type Type;
11286 enum : long long { VRType = VR::SQ };
11287 enum { VMType = VM::VM1 };
11288 static const char* GetVMString() { return "1"; }
11289 };
11290 template <> struct TagToType<0x0022,0x1330> {
11291 static const char* GetVRString() { return "SQ"; }
11292 typedef VRToType<VR::SQ>::Type Type;
11293 enum : long long { VRType = VR::SQ };
11294 enum { VMType = VM::VM1 };
11295 static const char* GetVMString() { return "1"; }
11296 };
11297 template <> struct TagToType<0x0022,0x1415> {
11298 static const char* GetVRString() { return "CS"; }
11299 typedef VRToType<VR::CS>::Type Type;
11300 enum : long long { VRType = VR::CS };
11301 enum { VMType = VM::VM1 };
11302 static const char* GetVMString() { return "1"; }
11303 };
11304 template <> struct TagToType<0x0022,0x1420> {
11305 static const char* GetVRString() { return "SQ"; }
11306 typedef VRToType<VR::SQ>::Type Type;
11307 enum : long long { VRType = VR::SQ };
11308 enum { VMType = VM::VM1 };
11309 static const char* GetVMString() { return "1"; }
11310 };
11311 template <> struct TagToType<0x0022,0x1423> {
11312 static const char* GetVRString() { return "SQ"; }
11313 typedef VRToType<VR::SQ>::Type Type;
11314 enum : long long { VRType = VR::SQ };
11315 enum { VMType = VM::VM1 };
11316 static const char* GetVMString() { return "1"; }
11317 };
11318 template <> struct TagToType<0x0022,0x1436> {
11319 static const char* GetVRString() { return "SQ"; }
11320 typedef VRToType<VR::SQ>::Type Type;
11321 enum : long long { VRType = VR::SQ };
11322 enum { VMType = VM::VM1 };
11323 static const char* GetVMString() { return "1"; }
11324 };
11325 template <> struct TagToType<0x0022,0x1443> {
11326 static const char* GetVRString() { return "SQ"; }
11327 typedef VRToType<VR::SQ>::Type Type;
11328 enum : long long { VRType = VR::SQ };
11329 enum { VMType = VM::VM1 };
11330 static const char* GetVMString() { return "1"; }
11331 };
11332 template <> struct TagToType<0x0022,0x1445> {
11333 static const char* GetVRString() { return "SQ"; }
11334 typedef VRToType<VR::SQ>::Type Type;
11335 enum : long long { VRType = VR::SQ };
11336 enum { VMType = VM::VM1 };
11337 static const char* GetVMString() { return "1"; }
11338 };
11339 template <> struct TagToType<0x0022,0x1450> {
11340 static const char* GetVRString() { return "SQ"; }
11341 typedef VRToType<VR::SQ>::Type Type;
11342 enum : long long { VRType = VR::SQ };
11343 enum { VMType = VM::VM1 };
11344 static const char* GetVMString() { return "1"; }
11345 };
11346 template <> struct TagToType<0x0022,0x1454> {
11347 static const char* GetVRString() { return "LO"; }
11348 typedef VRToType<VR::LO>::Type Type;
11349 enum : long long { VRType = VR::LO };
11350 enum { VMType = VM::VM1 };
11351 static const char* GetVMString() { return "1"; }
11352 };
11353 template <> struct TagToType<0x0022,0x1458> {
11354 static const char* GetVRString() { return "SQ"; }
11355 typedef VRToType<VR::SQ>::Type Type;
11356 enum : long long { VRType = VR::SQ };
11357 enum { VMType = VM::VM1 };
11358 static const char* GetVMString() { return "1"; }
11359 };
11360 template <> struct TagToType<0x0022,0x1460> {
11361 static const char* GetVRString() { return "FL"; }
11362 typedef VRToType<VR::FL>::Type Type;
11363 enum : long long { VRType = VR::FL };
11364 enum { VMType = VM::VM1 };
11365 static const char* GetVMString() { return "1"; }
11366 };
11367 template <> struct TagToType<0x0022,0x1463> {
11368 static const char* GetVRString() { return "FL"; }
11369 typedef VRToType<VR::FL>::Type Type;
11370 enum : long long { VRType = VR::FL };
11371 enum { VMType = VM::VM2 };
11372 static const char* GetVMString() { return "2"; }
11373 };
11374 template <> struct TagToType<0x0022,0x1465> {
11375 static const char* GetVRString() { return "SQ"; }
11376 typedef VRToType<VR::SQ>::Type Type;
11377 enum : long long { VRType = VR::SQ };
11378 enum { VMType = VM::VM1 };
11379 static const char* GetVMString() { return "1"; }
11380 };
11381 template <> struct TagToType<0x0022,0x1466> {
11382 static const char* GetVRString() { return "CS"; }
11383 typedef VRToType<VR::CS>::Type Type;
11384 enum : long long { VRType = VR::CS };
11385 enum { VMType = VM::VM1 };
11386 static const char* GetVMString() { return "1"; }
11387 };
11388 template <> struct TagToType<0x0022,0x1467> {
11389 static const char* GetVRString() { return "FL"; }
11390 typedef VRToType<VR::FL>::Type Type;
11391 enum : long long { VRType = VR::FL };
11392 enum { VMType = VM::VM2 };
11393 static const char* GetVMString() { return "2"; }
11394 };
11395 template <> struct TagToType<0x0022,0x1468> {
11396 static const char* GetVRString() { return "FL"; }
11397 typedef VRToType<VR::FL>::Type Type;
11398 enum : long long { VRType = VR::FL };
11399 enum { VMType = VM::VM2 };
11400 static const char* GetVMString() { return "2"; }
11401 };
11402 template <> struct TagToType<0x0022,0x1470> {
11403 static const char* GetVRString() { return "SQ"; }
11404 typedef VRToType<VR::SQ>::Type Type;
11405 enum : long long { VRType = VR::SQ };
11406 enum { VMType = VM::VM1 };
11407 static const char* GetVMString() { return "1"; }
11408 };
11409 template <> struct TagToType<0x0022,0x1472> {
11410 static const char* GetVRString() { return "SQ"; }
11411 typedef VRToType<VR::SQ>::Type Type;
11412 enum : long long { VRType = VR::SQ };
11413 enum { VMType = VM::VM1 };
11414 static const char* GetVMString() { return "1"; }
11415 };
11416 template <> struct TagToType<0x0022,0x1512> {
11417 static const char* GetVRString() { return "SQ"; }
11418 typedef VRToType<VR::SQ>::Type Type;
11419 enum : long long { VRType = VR::SQ };
11420 enum { VMType = VM::VM1 };
11421 static const char* GetVMString() { return "1"; }
11422 };
11423 template <> struct TagToType<0x0022,0x1513> {
11424 static const char* GetVRString() { return "SQ"; }
11425 typedef VRToType<VR::SQ>::Type Type;
11426 enum : long long { VRType = VR::SQ };
11427 enum { VMType = VM::VM1 };
11428 static const char* GetVMString() { return "1"; }
11429 };
11430 template <> struct TagToType<0x0022,0x1515> {
11431 static const char* GetVRString() { return "CS"; }
11432 typedef VRToType<VR::CS>::Type Type;
11433 enum : long long { VRType = VR::CS };
11434 enum { VMType = VM::VM1 };
11435 static const char* GetVMString() { return "1"; }
11436 };
11437 template <> struct TagToType<0x0022,0x1517> {
11438 static const char* GetVRString() { return "FL"; }
11439 typedef VRToType<VR::FL>::Type Type;
11440 enum : long long { VRType = VR::FL };
11441 enum { VMType = VM::VM1 };
11442 static const char* GetVMString() { return "1"; }
11443 };
11444 template <> struct TagToType<0x0022,0x1518> {
11445 static const char* GetVRString() { return "SQ"; }
11446 typedef VRToType<VR::SQ>::Type Type;
11447 enum : long long { VRType = VR::SQ };
11448 enum { VMType = VM::VM1 };
11449 static const char* GetVMString() { return "1"; }
11450 };
11451 template <> struct TagToType<0x0022,0x1525> {
11452 static const char* GetVRString() { return "SQ"; }
11453 typedef VRToType<VR::SQ>::Type Type;
11454 enum : long long { VRType = VR::SQ };
11455 enum { VMType = VM::VM1 };
11456 static const char* GetVMString() { return "1"; }
11457 };
11458 template <> struct TagToType<0x0022,0x1526> {
11459 static const char* GetVRString() { return "SQ"; }
11460 typedef VRToType<VR::SQ>::Type Type;
11461 enum : long long { VRType = VR::SQ };
11462 enum { VMType = VM::VM1 };
11463 static const char* GetVMString() { return "1"; }
11464 };
11465 template <> struct TagToType<0x0022,0x1527> {
11466 static const char* GetVRString() { return "FL"; }
11467 typedef VRToType<VR::FL>::Type Type;
11468 enum : long long { VRType = VR::FL };
11469 enum { VMType = VM::VM1 };
11470 static const char* GetVMString() { return "1"; }
11471 };
11472 template <> struct TagToType<0x0022,0x1528> {
11473 static const char* GetVRString() { return "FL"; }
11474 typedef VRToType<VR::FL>::Type Type;
11475 enum : long long { VRType = VR::FL };
11476 enum { VMType = VM::VM1 };
11477 static const char* GetVMString() { return "1"; }
11478 };
11479 template <> struct TagToType<0x0022,0x1529> {
11480 static const char* GetVRString() { return "FL"; }
11481 typedef VRToType<VR::FL>::Type Type;
11482 enum : long long { VRType = VR::FL };
11483 enum { VMType = VM::VM1 };
11484 static const char* GetVMString() { return "1"; }
11485 };
11486 template <> struct TagToType<0x0022,0x1530> {
11487 static const char* GetVRString() { return "UL"; }
11488 typedef VRToType<VR::UL>::Type Type;
11489 enum : long long { VRType = VR::UL };
11490 enum { VMType = VM::VM1 };
11491 static const char* GetVMString() { return "1"; }
11492 };
11493 template <> struct TagToType<0x0022,0x1531> {
11494 static const char* GetVRString() { return "OF"; }
11495 typedef VRToType<VR::OF>::Type Type;
11496 enum : long long { VRType = VR::OF };
11497 enum { VMType = VM::VM1 };
11498 static const char* GetVMString() { return "1"; }
11499 };
11500 template <> struct TagToType<0x0024,0x0010> {
11501 static const char* GetVRString() { return "FL"; }
11502 typedef VRToType<VR::FL>::Type Type;
11503 enum : long long { VRType = VR::FL };
11504 enum { VMType = VM::VM1 };
11505 static const char* GetVMString() { return "1"; }
11506 };
11507 template <> struct TagToType<0x0024,0x0011> {
11508 static const char* GetVRString() { return "FL"; }
11509 typedef VRToType<VR::FL>::Type Type;
11510 enum : long long { VRType = VR::FL };
11511 enum { VMType = VM::VM1 };
11512 static const char* GetVMString() { return "1"; }
11513 };
11514 template <> struct TagToType<0x0024,0x0012> {
11515 static const char* GetVRString() { return "CS"; }
11516 typedef VRToType<VR::CS>::Type Type;
11517 enum : long long { VRType = VR::CS };
11518 enum { VMType = VM::VM1 };
11519 static const char* GetVMString() { return "1"; }
11520 };
11521 template <> struct TagToType<0x0024,0x0016> {
11522 static const char* GetVRString() { return "SQ"; }
11523 typedef VRToType<VR::SQ>::Type Type;
11524 enum : long long { VRType = VR::SQ };
11525 enum { VMType = VM::VM1 };
11526 static const char* GetVMString() { return "1"; }
11527 };
11528 template <> struct TagToType<0x0024,0x0018> {
11529 static const char* GetVRString() { return "FL"; }
11530 typedef VRToType<VR::FL>::Type Type;
11531 enum : long long { VRType = VR::FL };
11532 enum { VMType = VM::VM1 };
11533 static const char* GetVMString() { return "1"; }
11534 };
11535 template <> struct TagToType<0x0024,0x0020> {
11536 static const char* GetVRString() { return "FL"; }
11537 typedef VRToType<VR::FL>::Type Type;
11538 enum : long long { VRType = VR::FL };
11539 enum { VMType = VM::VM1 };
11540 static const char* GetVMString() { return "1"; }
11541 };
11542 template <> struct TagToType<0x0024,0x0021> {
11543 static const char* GetVRString() { return "SQ"; }
11544 typedef VRToType<VR::SQ>::Type Type;
11545 enum : long long { VRType = VR::SQ };
11546 enum { VMType = VM::VM1 };
11547 static const char* GetVMString() { return "1"; }
11548 };
11549 template <> struct TagToType<0x0024,0x0024> {
11550 static const char* GetVRString() { return "SQ"; }
11551 typedef VRToType<VR::SQ>::Type Type;
11552 enum : long long { VRType = VR::SQ };
11553 enum { VMType = VM::VM1 };
11554 static const char* GetVMString() { return "1"; }
11555 };
11556 template <> struct TagToType<0x0024,0x0025> {
11557 static const char* GetVRString() { return "FL"; }
11558 typedef VRToType<VR::FL>::Type Type;
11559 enum : long long { VRType = VR::FL };
11560 enum { VMType = VM::VM1 };
11561 static const char* GetVMString() { return "1"; }
11562 };
11563 template <> struct TagToType<0x0024,0x0028> {
11564 static const char* GetVRString() { return "FL"; }
11565 typedef VRToType<VR::FL>::Type Type;
11566 enum : long long { VRType = VR::FL };
11567 enum { VMType = VM::VM1 };
11568 static const char* GetVMString() { return "1"; }
11569 };
11570 template <> struct TagToType<0x0024,0x0032> {
11571 static const char* GetVRString() { return "SQ"; }
11572 typedef VRToType<VR::SQ>::Type Type;
11573 enum : long long { VRType = VR::SQ };
11574 enum { VMType = VM::VM1 };
11575 static const char* GetVMString() { return "1"; }
11576 };
11577 template <> struct TagToType<0x0024,0x0033> {
11578 static const char* GetVRString() { return "SQ"; }
11579 typedef VRToType<VR::SQ>::Type Type;
11580 enum : long long { VRType = VR::SQ };
11581 enum { VMType = VM::VM1 };
11582 static const char* GetVMString() { return "1"; }
11583 };
11584 template <> struct TagToType<0x0024,0x0034> {
11585 static const char* GetVRString() { return "SQ"; }
11586 typedef VRToType<VR::SQ>::Type Type;
11587 enum : long long { VRType = VR::SQ };
11588 enum { VMType = VM::VM1 };
11589 static const char* GetVMString() { return "1"; }
11590 };
11591 template <> struct TagToType<0x0024,0x0035> {
11592 static const char* GetVRString() { return "US"; }
11593 typedef VRToType<VR::US>::Type Type;
11594 enum : long long { VRType = VR::US };
11595 enum { VMType = VM::VM1 };
11596 static const char* GetVMString() { return "1"; }
11597 };
11598 template <> struct TagToType<0x0024,0x0036> {
11599 static const char* GetVRString() { return "US"; }
11600 typedef VRToType<VR::US>::Type Type;
11601 enum : long long { VRType = VR::US };
11602 enum { VMType = VM::VM1 };
11603 static const char* GetVMString() { return "1"; }
11604 };
11605 template <> struct TagToType<0x0024,0x0037> {
11606 static const char* GetVRString() { return "CS"; }
11607 typedef VRToType<VR::CS>::Type Type;
11608 enum : long long { VRType = VR::CS };
11609 enum { VMType = VM::VM1 };
11610 static const char* GetVMString() { return "1"; }
11611 };
11612 template <> struct TagToType<0x0024,0x0038> {
11613 static const char* GetVRString() { return "US"; }
11614 typedef VRToType<VR::US>::Type Type;
11615 enum : long long { VRType = VR::US };
11616 enum { VMType = VM::VM1 };
11617 static const char* GetVMString() { return "1"; }
11618 };
11619 template <> struct TagToType<0x0024,0x0039> {
11620 static const char* GetVRString() { return "CS"; }
11621 typedef VRToType<VR::CS>::Type Type;
11622 enum : long long { VRType = VR::CS };
11623 enum { VMType = VM::VM1 };
11624 static const char* GetVMString() { return "1"; }
11625 };
11626 template <> struct TagToType<0x0024,0x0040> {
11627 static const char* GetVRString() { return "CS"; }
11628 typedef VRToType<VR::CS>::Type Type;
11629 enum : long long { VRType = VR::CS };
11630 enum { VMType = VM::VM1 };
11631 static const char* GetVMString() { return "1"; }
11632 };
11633 template <> struct TagToType<0x0024,0x0042> {
11634 static const char* GetVRString() { return "US"; }
11635 typedef VRToType<VR::US>::Type Type;
11636 enum : long long { VRType = VR::US };
11637 enum { VMType = VM::VM1 };
11638 static const char* GetVMString() { return "1"; }
11639 };
11640 template <> struct TagToType<0x0024,0x0044> {
11641 static const char* GetVRString() { return "LT"; }
11642 typedef VRToType<VR::LT>::Type Type;
11643 enum : long long { VRType = VR::LT };
11644 enum { VMType = VM::VM1 };
11645 static const char* GetVMString() { return "1"; }
11646 };
11647 template <> struct TagToType<0x0024,0x0045> {
11648 static const char* GetVRString() { return "CS"; }
11649 typedef VRToType<VR::CS>::Type Type;
11650 enum : long long { VRType = VR::CS };
11651 enum { VMType = VM::VM1 };
11652 static const char* GetVMString() { return "1"; }
11653 };
11654 template <> struct TagToType<0x0024,0x0046> {
11655 static const char* GetVRString() { return "FL"; }
11656 typedef VRToType<VR::FL>::Type Type;
11657 enum : long long { VRType = VR::FL };
11658 enum { VMType = VM::VM1 };
11659 static const char* GetVMString() { return "1"; }
11660 };
11661 template <> struct TagToType<0x0024,0x0048> {
11662 static const char* GetVRString() { return "US"; }
11663 typedef VRToType<VR::US>::Type Type;
11664 enum : long long { VRType = VR::US };
11665 enum { VMType = VM::VM1 };
11666 static const char* GetVMString() { return "1"; }
11667 };
11668 template <> struct TagToType<0x0024,0x0050> {
11669 static const char* GetVRString() { return "US"; }
11670 typedef VRToType<VR::US>::Type Type;
11671 enum : long long { VRType = VR::US };
11672 enum { VMType = VM::VM1 };
11673 static const char* GetVMString() { return "1"; }
11674 };
11675 template <> struct TagToType<0x0024,0x0051> {
11676 static const char* GetVRString() { return "CS"; }
11677 typedef VRToType<VR::CS>::Type Type;
11678 enum : long long { VRType = VR::CS };
11679 enum { VMType = VM::VM1 };
11680 static const char* GetVMString() { return "1"; }
11681 };
11682 template <> struct TagToType<0x0024,0x0052> {
11683 static const char* GetVRString() { return "CS"; }
11684 typedef VRToType<VR::CS>::Type Type;
11685 enum : long long { VRType = VR::CS };
11686 enum { VMType = VM::VM1 };
11687 static const char* GetVMString() { return "1"; }
11688 };
11689 template <> struct TagToType<0x0024,0x0053> {
11690 static const char* GetVRString() { return "CS"; }
11691 typedef VRToType<VR::CS>::Type Type;
11692 enum : long long { VRType = VR::CS };
11693 enum { VMType = VM::VM1 };
11694 static const char* GetVMString() { return "1"; }
11695 };
11696 template <> struct TagToType<0x0024,0x0054> {
11697 static const char* GetVRString() { return "FL"; }
11698 typedef VRToType<VR::FL>::Type Type;
11699 enum : long long { VRType = VR::FL };
11700 enum { VMType = VM::VM1 };
11701 static const char* GetVMString() { return "1"; }
11702 };
11703 template <> struct TagToType<0x0024,0x0055> {
11704 static const char* GetVRString() { return "CS"; }
11705 typedef VRToType<VR::CS>::Type Type;
11706 enum : long long { VRType = VR::CS };
11707 enum { VMType = VM::VM1 };
11708 static const char* GetVMString() { return "1"; }
11709 };
11710 template <> struct TagToType<0x0024,0x0056> {
11711 static const char* GetVRString() { return "US"; }
11712 typedef VRToType<VR::US>::Type Type;
11713 enum : long long { VRType = VR::US };
11714 enum { VMType = VM::VM1 };
11715 static const char* GetVMString() { return "1"; }
11716 };
11717 template <> struct TagToType<0x0024,0x0057> {
11718 static const char* GetVRString() { return "CS"; }
11719 typedef VRToType<VR::CS>::Type Type;
11720 enum : long long { VRType = VR::CS };
11721 enum { VMType = VM::VM1 };
11722 static const char* GetVMString() { return "1"; }
11723 };
11724 template <> struct TagToType<0x0024,0x0058> {
11725 static const char* GetVRString() { return "SQ"; }
11726 typedef VRToType<VR::SQ>::Type Type;
11727 enum : long long { VRType = VR::SQ };
11728 enum { VMType = VM::VM1 };
11729 static const char* GetVMString() { return "1"; }
11730 };
11731 template <> struct TagToType<0x0024,0x0059> {
11732 static const char* GetVRString() { return "CS"; }
11733 typedef VRToType<VR::CS>::Type Type;
11734 enum : long long { VRType = VR::CS };
11735 enum { VMType = VM::VM1 };
11736 static const char* GetVMString() { return "1"; }
11737 };
11738 template <> struct TagToType<0x0024,0x0060> {
11739 static const char* GetVRString() { return "US"; }
11740 typedef VRToType<VR::US>::Type Type;
11741 enum : long long { VRType = VR::US };
11742 enum { VMType = VM::VM1 };
11743 static const char* GetVMString() { return "1"; }
11744 };
11745 template <> struct TagToType<0x0024,0x0061> {
11746 static const char* GetVRString() { return "CS"; }
11747 typedef VRToType<VR::CS>::Type Type;
11748 enum : long long { VRType = VR::CS };
11749 enum { VMType = VM::VM1 };
11750 static const char* GetVMString() { return "1"; }
11751 };
11752 template <> struct TagToType<0x0024,0x0062> {
11753 static const char* GetVRString() { return "CS"; }
11754 typedef VRToType<VR::CS>::Type Type;
11755 enum : long long { VRType = VR::CS };
11756 enum { VMType = VM::VM1 };
11757 static const char* GetVMString() { return "1"; }
11758 };
11759 template <> struct TagToType<0x0024,0x0063> {
11760 static const char* GetVRString() { return "CS"; }
11761 typedef VRToType<VR::CS>::Type Type;
11762 enum : long long { VRType = VR::CS };
11763 enum { VMType = VM::VM1 };
11764 static const char* GetVMString() { return "1"; }
11765 };
11766 template <> struct TagToType<0x0024,0x0064> {
11767 static const char* GetVRString() { return "SQ"; }
11768 typedef VRToType<VR::SQ>::Type Type;
11769 enum : long long { VRType = VR::SQ };
11770 enum { VMType = VM::VM1 };
11771 static const char* GetVMString() { return "1"; }
11772 };
11773 template <> struct TagToType<0x0024,0x0065> {
11774 static const char* GetVRString() { return "SQ"; }
11775 typedef VRToType<VR::SQ>::Type Type;
11776 enum : long long { VRType = VR::SQ };
11777 enum { VMType = VM::VM1 };
11778 static const char* GetVMString() { return "1"; }
11779 };
11780 template <> struct TagToType<0x0024,0x0066> {
11781 static const char* GetVRString() { return "FL"; }
11782 typedef VRToType<VR::FL>::Type Type;
11783 enum : long long { VRType = VR::FL };
11784 enum { VMType = VM::VM1 };
11785 static const char* GetVMString() { return "1"; }
11786 };
11787 template <> struct TagToType<0x0024,0x0067> {
11788 static const char* GetVRString() { return "SQ"; }
11789 typedef VRToType<VR::SQ>::Type Type;
11790 enum : long long { VRType = VR::SQ };
11791 enum { VMType = VM::VM1 };
11792 static const char* GetVMString() { return "1"; }
11793 };
11794 template <> struct TagToType<0x0024,0x0068> {
11795 static const char* GetVRString() { return "FL"; }
11796 typedef VRToType<VR::FL>::Type Type;
11797 enum : long long { VRType = VR::FL };
11798 enum { VMType = VM::VM1 };
11799 static const char* GetVMString() { return "1"; }
11800 };
11801 template <> struct TagToType<0x0024,0x0069> {
11802 static const char* GetVRString() { return "LO"; }
11803 typedef VRToType<VR::LO>::Type Type;
11804 enum : long long { VRType = VR::LO };
11805 enum { VMType = VM::VM1 };
11806 static const char* GetVMString() { return "1"; }
11807 };
11808 template <> struct TagToType<0x0024,0x0070> {
11809 static const char* GetVRString() { return "FL"; }
11810 typedef VRToType<VR::FL>::Type Type;
11811 enum : long long { VRType = VR::FL };
11812 enum { VMType = VM::VM1 };
11813 static const char* GetVMString() { return "1"; }
11814 };
11815 template <> struct TagToType<0x0024,0x0071> {
11816 static const char* GetVRString() { return "FL"; }
11817 typedef VRToType<VR::FL>::Type Type;
11818 enum : long long { VRType = VR::FL };
11819 enum { VMType = VM::VM1 };
11820 static const char* GetVMString() { return "1"; }
11821 };
11822 template <> struct TagToType<0x0024,0x0072> {
11823 static const char* GetVRString() { return "CS"; }
11824 typedef VRToType<VR::CS>::Type Type;
11825 enum : long long { VRType = VR::CS };
11826 enum { VMType = VM::VM1 };
11827 static const char* GetVMString() { return "1"; }
11828 };
11829 template <> struct TagToType<0x0024,0x0073> {
11830 static const char* GetVRString() { return "FL"; }
11831 typedef VRToType<VR::FL>::Type Type;
11832 enum : long long { VRType = VR::FL };
11833 enum { VMType = VM::VM1 };
11834 static const char* GetVMString() { return "1"; }
11835 };
11836 template <> struct TagToType<0x0024,0x0074> {
11837 static const char* GetVRString() { return "CS"; }
11838 typedef VRToType<VR::CS>::Type Type;
11839 enum : long long { VRType = VR::CS };
11840 enum { VMType = VM::VM1 };
11841 static const char* GetVMString() { return "1"; }
11842 };
11843 template <> struct TagToType<0x0024,0x0075> {
11844 static const char* GetVRString() { return "FL"; }
11845 typedef VRToType<VR::FL>::Type Type;
11846 enum : long long { VRType = VR::FL };
11847 enum { VMType = VM::VM1 };
11848 static const char* GetVMString() { return "1"; }
11849 };
11850 template <> struct TagToType<0x0024,0x0076> {
11851 static const char* GetVRString() { return "CS"; }
11852 typedef VRToType<VR::CS>::Type Type;
11853 enum : long long { VRType = VR::CS };
11854 enum { VMType = VM::VM1 };
11855 static const char* GetVMString() { return "1"; }
11856 };
11857 template <> struct TagToType<0x0024,0x0077> {
11858 static const char* GetVRString() { return "FL"; }
11859 typedef VRToType<VR::FL>::Type Type;
11860 enum : long long { VRType = VR::FL };
11861 enum { VMType = VM::VM1 };
11862 static const char* GetVMString() { return "1"; }
11863 };
11864 template <> struct TagToType<0x0024,0x0078> {
11865 static const char* GetVRString() { return "CS"; }
11866 typedef VRToType<VR::CS>::Type Type;
11867 enum : long long { VRType = VR::CS };
11868 enum { VMType = VM::VM1 };
11869 static const char* GetVMString() { return "1"; }
11870 };
11871 template <> struct TagToType<0x0024,0x0079> {
11872 static const char* GetVRString() { return "FL"; }
11873 typedef VRToType<VR::FL>::Type Type;
11874 enum : long long { VRType = VR::FL };
11875 enum { VMType = VM::VM1 };
11876 static const char* GetVMString() { return "1"; }
11877 };
11878 template <> struct TagToType<0x0024,0x0080> {
11879 static const char* GetVRString() { return "CS"; }
11880 typedef VRToType<VR::CS>::Type Type;
11881 enum : long long { VRType = VR::CS };
11882 enum { VMType = VM::VM1 };
11883 static const char* GetVMString() { return "1"; }
11884 };
11885 template <> struct TagToType<0x0024,0x0081> {
11886 static const char* GetVRString() { return "FL"; }
11887 typedef VRToType<VR::FL>::Type Type;
11888 enum : long long { VRType = VR::FL };
11889 enum { VMType = VM::VM1 };
11890 static const char* GetVMString() { return "1"; }
11891 };
11892 template <> struct TagToType<0x0024,0x0083> {
11893 static const char* GetVRString() { return "SQ"; }
11894 typedef VRToType<VR::SQ>::Type Type;
11895 enum : long long { VRType = VR::SQ };
11896 enum { VMType = VM::VM1 };
11897 static const char* GetVMString() { return "1"; }
11898 };
11899 template <> struct TagToType<0x0024,0x0085> {
11900 static const char* GetVRString() { return "SQ"; }
11901 typedef VRToType<VR::SQ>::Type Type;
11902 enum : long long { VRType = VR::SQ };
11903 enum { VMType = VM::VM1 };
11904 static const char* GetVMString() { return "1"; }
11905 };
11906 template <> struct TagToType<0x0024,0x0086> {
11907 static const char* GetVRString() { return "CS"; }
11908 typedef VRToType<VR::CS>::Type Type;
11909 enum : long long { VRType = VR::CS };
11910 enum { VMType = VM::VM1 };
11911 static const char* GetVMString() { return "1"; }
11912 };
11913 template <> struct TagToType<0x0024,0x0087> {
11914 static const char* GetVRString() { return "FL"; }
11915 typedef VRToType<VR::FL>::Type Type;
11916 enum : long long { VRType = VR::FL };
11917 enum { VMType = VM::VM1 };
11918 static const char* GetVMString() { return "1"; }
11919 };
11920 template <> struct TagToType<0x0024,0x0088> {
11921 static const char* GetVRString() { return "FL"; }
11922 typedef VRToType<VR::FL>::Type Type;
11923 enum : long long { VRType = VR::FL };
11924 enum { VMType = VM::VM1 };
11925 static const char* GetVMString() { return "1"; }
11926 };
11927 template <> struct TagToType<0x0024,0x0089> {
11928 static const char* GetVRString() { return "SQ"; }
11929 typedef VRToType<VR::SQ>::Type Type;
11930 enum : long long { VRType = VR::SQ };
11931 enum { VMType = VM::VM1 };
11932 static const char* GetVMString() { return "1"; }
11933 };
11934 template <> struct TagToType<0x0024,0x0090> {
11935 static const char* GetVRString() { return "FL"; }
11936 typedef VRToType<VR::FL>::Type Type;
11937 enum : long long { VRType = VR::FL };
11938 enum { VMType = VM::VM1 };
11939 static const char* GetVMString() { return "1"; }
11940 };
11941 template <> struct TagToType<0x0024,0x0091> {
11942 static const char* GetVRString() { return "FL"; }
11943 typedef VRToType<VR::FL>::Type Type;
11944 enum : long long { VRType = VR::FL };
11945 enum { VMType = VM::VM1 };
11946 static const char* GetVMString() { return "1"; }
11947 };
11948 template <> struct TagToType<0x0024,0x0092> {
11949 static const char* GetVRString() { return "FL"; }
11950 typedef VRToType<VR::FL>::Type Type;
11951 enum : long long { VRType = VR::FL };
11952 enum { VMType = VM::VM1 };
11953 static const char* GetVMString() { return "1"; }
11954 };
11955 template <> struct TagToType<0x0024,0x0093> {
11956 static const char* GetVRString() { return "CS"; }
11957 typedef VRToType<VR::CS>::Type Type;
11958 enum : long long { VRType = VR::CS };
11959 enum { VMType = VM::VM1 };
11960 static const char* GetVMString() { return "1"; }
11961 };
11962 template <> struct TagToType<0x0024,0x0094> {
11963 static const char* GetVRString() { return "FL"; }
11964 typedef VRToType<VR::FL>::Type Type;
11965 enum : long long { VRType = VR::FL };
11966 enum { VMType = VM::VM1 };
11967 static const char* GetVMString() { return "1"; }
11968 };
11969 template <> struct TagToType<0x0024,0x0095> {
11970 static const char* GetVRString() { return "CS"; }
11971 typedef VRToType<VR::CS>::Type Type;
11972 enum : long long { VRType = VR::CS };
11973 enum { VMType = VM::VM1 };
11974 static const char* GetVMString() { return "1"; }
11975 };
11976 template <> struct TagToType<0x0024,0x0096> {
11977 static const char* GetVRString() { return "FL"; }
11978 typedef VRToType<VR::FL>::Type Type;
11979 enum : long long { VRType = VR::FL };
11980 enum { VMType = VM::VM1 };
11981 static const char* GetVMString() { return "1"; }
11982 };
11983 template <> struct TagToType<0x0024,0x0097> {
11984 static const char* GetVRString() { return "SQ"; }
11985 typedef VRToType<VR::SQ>::Type Type;
11986 enum : long long { VRType = VR::SQ };
11987 enum { VMType = VM::VM1 };
11988 static const char* GetVMString() { return "1"; }
11989 };
11990 template <> struct TagToType<0x0024,0x0098> {
11991 static const char* GetVRString() { return "FL"; }
11992 typedef VRToType<VR::FL>::Type Type;
11993 enum : long long { VRType = VR::FL };
11994 enum { VMType = VM::VM1 };
11995 static const char* GetVMString() { return "1"; }
11996 };
11997 template <> struct TagToType<0x0024,0x0100> {
11998 static const char* GetVRString() { return "FL"; }
11999 typedef VRToType<VR::FL>::Type Type;
12000 enum : long long { VRType = VR::FL };
12001 enum { VMType = VM::VM1 };
12002 static const char* GetVMString() { return "1"; }
12003 };
12004 template <> struct TagToType<0x0024,0x0102> {
12005 static const char* GetVRString() { return "CS"; }
12006 typedef VRToType<VR::CS>::Type Type;
12007 enum : long long { VRType = VR::CS };
12008 enum { VMType = VM::VM1 };
12009 static const char* GetVMString() { return "1"; }
12010 };
12011 template <> struct TagToType<0x0024,0x0103> {
12012 static const char* GetVRString() { return "FL"; }
12013 typedef VRToType<VR::FL>::Type Type;
12014 enum : long long { VRType = VR::FL };
12015 enum { VMType = VM::VM1 };
12016 static const char* GetVMString() { return "1"; }
12017 };
12018 template <> struct TagToType<0x0024,0x0104> {
12019 static const char* GetVRString() { return "FL"; }
12020 typedef VRToType<VR::FL>::Type Type;
12021 enum : long long { VRType = VR::FL };
12022 enum { VMType = VM::VM1 };
12023 static const char* GetVMString() { return "1"; }
12024 };
12025 template <> struct TagToType<0x0024,0x0105> {
12026 static const char* GetVRString() { return "FL"; }
12027 typedef VRToType<VR::FL>::Type Type;
12028 enum : long long { VRType = VR::FL };
12029 enum { VMType = VM::VM1 };
12030 static const char* GetVMString() { return "1"; }
12031 };
12032 template <> struct TagToType<0x0024,0x0106> {
12033 static const char* GetVRString() { return "CS"; }
12034 typedef VRToType<VR::CS>::Type Type;
12035 enum : long long { VRType = VR::CS };
12036 enum { VMType = VM::VM1 };
12037 static const char* GetVMString() { return "1"; }
12038 };
12039 template <> struct TagToType<0x0024,0x0107> {
12040 static const char* GetVRString() { return "FL"; }
12041 typedef VRToType<VR::FL>::Type Type;
12042 enum : long long { VRType = VR::FL };
12043 enum { VMType = VM::VM1 };
12044 static const char* GetVMString() { return "1"; }
12045 };
12046 template <> struct TagToType<0x0024,0x0108> {
12047 static const char* GetVRString() { return "FL"; }
12048 typedef VRToType<VR::FL>::Type Type;
12049 enum : long long { VRType = VR::FL };
12050 enum { VMType = VM::VM1 };
12051 static const char* GetVMString() { return "1"; }
12052 };
12053 template <> struct TagToType<0x0024,0x0110> {
12054 static const char* GetVRString() { return "SQ"; }
12055 typedef VRToType<VR::SQ>::Type Type;
12056 enum : long long { VRType = VR::SQ };
12057 enum { VMType = VM::VM1 };
12058 static const char* GetVMString() { return "1"; }
12059 };
12060 template <> struct TagToType<0x0024,0x0112> {
12061 static const char* GetVRString() { return "SQ"; }
12062 typedef VRToType<VR::SQ>::Type Type;
12063 enum : long long { VRType = VR::SQ };
12064 enum { VMType = VM::VM1 };
12065 static const char* GetVMString() { return "1"; }
12066 };
12067 template <> struct TagToType<0x0024,0x0113> {
12068 static const char* GetVRString() { return "CS"; }
12069 typedef VRToType<VR::CS>::Type Type;
12070 enum : long long { VRType = VR::CS };
12071 enum { VMType = VM::VM1 };
12072 static const char* GetVMString() { return "1"; }
12073 };
12074 template <> struct TagToType<0x0024,0x0114> {
12075 static const char* GetVRString() { return "SQ"; }
12076 typedef VRToType<VR::SQ>::Type Type;
12077 enum : long long { VRType = VR::SQ };
12078 enum { VMType = VM::VM1 };
12079 static const char* GetVMString() { return "1"; }
12080 };
12081 template <> struct TagToType<0x0024,0x0115> {
12082 static const char* GetVRString() { return "SQ"; }
12083 typedef VRToType<VR::SQ>::Type Type;
12084 enum : long long { VRType = VR::SQ };
12085 enum { VMType = VM::VM1 };
12086 static const char* GetVMString() { return "1"; }
12087 };
12088 template <> struct TagToType<0x0024,0x0117> {
12089 static const char* GetVRString() { return "CS"; }
12090 typedef VRToType<VR::CS>::Type Type;
12091 enum : long long { VRType = VR::CS };
12092 enum { VMType = VM::VM1 };
12093 static const char* GetVMString() { return "1"; }
12094 };
12095 template <> struct TagToType<0x0024,0x0118> {
12096 static const char* GetVRString() { return "FL"; }
12097 typedef VRToType<VR::FL>::Type Type;
12098 enum : long long { VRType = VR::FL };
12099 enum { VMType = VM::VM1 };
12100 static const char* GetVMString() { return "1"; }
12101 };
12102 template <> struct TagToType<0x0024,0x0120> {
12103 static const char* GetVRString() { return "CS"; }
12104 typedef VRToType<VR::CS>::Type Type;
12105 enum : long long { VRType = VR::CS };
12106 enum { VMType = VM::VM1 };
12107 static const char* GetVMString() { return "1"; }
12108 };
12109 template <> struct TagToType<0x0024,0x0122> {
12110 static const char* GetVRString() { return "SQ"; }
12111 typedef VRToType<VR::SQ>::Type Type;
12112 enum : long long { VRType = VR::SQ };
12113 enum { VMType = VM::VM1 };
12114 static const char* GetVMString() { return "1"; }
12115 };
12116 template <> struct TagToType<0x0024,0x0124> {
12117 static const char* GetVRString() { return "CS"; }
12118 typedef VRToType<VR::CS>::Type Type;
12119 enum : long long { VRType = VR::CS };
12120 enum { VMType = VM::VM1 };
12121 static const char* GetVMString() { return "1"; }
12122 };
12123 template <> struct TagToType<0x0024,0x0126> {
12124 static const char* GetVRString() { return "FL"; }
12125 typedef VRToType<VR::FL>::Type Type;
12126 enum : long long { VRType = VR::FL };
12127 enum { VMType = VM::VM1 };
12128 static const char* GetVMString() { return "1"; }
12129 };
12130 template <> struct TagToType<0x0024,0x0202> {
12131 static const char* GetVRString() { return "LO"; }
12132 typedef VRToType<VR::LO>::Type Type;
12133 enum : long long { VRType = VR::LO };
12134 enum { VMType = VM::VM1 };
12135 static const char* GetVMString() { return "1"; }
12136 };
12137 template <> struct TagToType<0x0024,0x0306> {
12138 static const char* GetVRString() { return "LO"; }
12139 typedef VRToType<VR::LO>::Type Type;
12140 enum : long long { VRType = VR::LO };
12141 enum { VMType = VM::VM1 };
12142 static const char* GetVMString() { return "1"; }
12143 };
12144 template <> struct TagToType<0x0024,0x0307> {
12145 static const char* GetVRString() { return "LO"; }
12146 typedef VRToType<VR::LO>::Type Type;
12147 enum : long long { VRType = VR::LO };
12148 enum { VMType = VM::VM1 };
12149 static const char* GetVMString() { return "1"; }
12150 };
12151 template <> struct TagToType<0x0024,0x0308> {
12152 static const char* GetVRString() { return "LO"; }
12153 typedef VRToType<VR::LO>::Type Type;
12154 enum : long long { VRType = VR::LO };
12155 enum { VMType = VM::VM1 };
12156 static const char* GetVMString() { return "1"; }
12157 };
12158 template <> struct TagToType<0x0024,0x0309> {
12159 static const char* GetVRString() { return "LO"; }
12160 typedef VRToType<VR::LO>::Type Type;
12161 enum : long long { VRType = VR::LO };
12162 enum { VMType = VM::VM1 };
12163 static const char* GetVMString() { return "1"; }
12164 };
12165 template <> struct TagToType<0x0024,0x0317> {
12166 static const char* GetVRString() { return "SQ"; }
12167 typedef VRToType<VR::SQ>::Type Type;
12168 enum : long long { VRType = VR::SQ };
12169 enum { VMType = VM::VM1 };
12170 static const char* GetVMString() { return "1"; }
12171 };
12172 template <> struct TagToType<0x0024,0x0320> {
12173 static const char* GetVRString() { return "SQ"; }
12174 typedef VRToType<VR::SQ>::Type Type;
12175 enum : long long { VRType = VR::SQ };
12176 enum { VMType = VM::VM1 };
12177 static const char* GetVMString() { return "1"; }
12178 };
12179 template <> struct TagToType<0x0024,0x0325> {
12180 static const char* GetVRString() { return "SQ"; }
12181 typedef VRToType<VR::SQ>::Type Type;
12182 enum : long long { VRType = VR::SQ };
12183 enum { VMType = VM::VM1 };
12184 static const char* GetVMString() { return "1"; }
12185 };
12186 template <> struct TagToType<0x0024,0x0338> {
12187 static const char* GetVRString() { return "CS"; }
12188 typedef VRToType<VR::CS>::Type Type;
12189 enum : long long { VRType = VR::CS };
12190 enum { VMType = VM::VM1 };
12191 static const char* GetVMString() { return "1"; }
12192 };
12193 template <> struct TagToType<0x0024,0x0341> {
12194 static const char* GetVRString() { return "FL"; }
12195 typedef VRToType<VR::FL>::Type Type;
12196 enum : long long { VRType = VR::FL };
12197 enum { VMType = VM::VM1 };
12198 static const char* GetVMString() { return "1"; }
12199 };
12200 template <> struct TagToType<0x0024,0x0344> {
12201 static const char* GetVRString() { return "SQ"; }
12202 typedef VRToType<VR::SQ>::Type Type;
12203 enum : long long { VRType = VR::SQ };
12204 enum { VMType = VM::VM1 };
12205 static const char* GetVMString() { return "1"; }
12206 };
12207 template <> struct TagToType<0x0028,0x0002> {
12208 static const char* GetVRString() { return "US"; }
12209 typedef VRToType<VR::US>::Type Type;
12210 enum : long long { VRType = VR::US };
12211 enum { VMType = VM::VM1 };
12212 static const char* GetVMString() { return "1"; }
12213 };
12214 template <> struct TagToType<0x0028,0x0003> {
12215 static const char* GetVRString() { return "US"; }
12216 typedef VRToType<VR::US>::Type Type;
12217 enum : long long { VRType = VR::US };
12218 enum { VMType = VM::VM1 };
12219 static const char* GetVMString() { return "1"; }
12220 };
12221 template <> struct TagToType<0x0028,0x0004> {
12222 static const char* GetVRString() { return "CS"; }
12223 typedef VRToType<VR::CS>::Type Type;
12224 enum : long long { VRType = VR::CS };
12225 enum { VMType = VM::VM1 };
12226 static const char* GetVMString() { return "1"; }
12227 };
12228 template <> struct TagToType<0x0028,0x0005> {
12229 static const char* GetVRString() { return "US"; }
12230 typedef VRToType<VR::US>::Type Type;
12231 enum : long long { VRType = VR::US };
12232 enum { VMType = VM::VM1 };
12233 static const char* GetVMString() { return "1"; }
12234 };
12235 template <> struct TagToType<0x0028,0x0006> {
12236 static const char* GetVRString() { return "US"; }
12237 typedef VRToType<VR::US>::Type Type;
12238 enum : long long { VRType = VR::US };
12239 enum { VMType = VM::VM1 };
12240 static const char* GetVMString() { return "1"; }
12241 };
12242 template <> struct TagToType<0x0028,0x0008> {
12243 static const char* GetVRString() { return "IS"; }
12244 typedef VRToType<VR::IS>::Type Type;
12245 enum : long long { VRType = VR::IS };
12246 enum { VMType = VM::VM1 };
12247 static const char* GetVMString() { return "1"; }
12248 };
12249 template <> struct TagToType<0x0028,0x0009> {
12250 static const char* GetVRString() { return "AT"; }
12251 typedef VRToType<VR::AT>::Type Type;
12252 enum : long long { VRType = VR::AT };
12253 enum { VMType = VM::VM1_n };
12254 static const char* GetVMString() { return "1-n"; }
12255 };
12256 template <> struct TagToType<0x0028,0x000a> {
12257 static const char* GetVRString() { return "AT"; }
12258 typedef VRToType<VR::AT>::Type Type;
12259 enum : long long { VRType = VR::AT };
12260 enum { VMType = VM::VM1_n };
12261 static const char* GetVMString() { return "1-n"; }
12262 };
12263 template <> struct TagToType<0x0028,0x0010> {
12264 static const char* GetVRString() { return "US"; }
12265 typedef VRToType<VR::US>::Type Type;
12266 enum : long long { VRType = VR::US };
12267 enum { VMType = VM::VM1 };
12268 static const char* GetVMString() { return "1"; }
12269 };
12270 template <> struct TagToType<0x0028,0x0011> {
12271 static const char* GetVRString() { return "US"; }
12272 typedef VRToType<VR::US>::Type Type;
12273 enum : long long { VRType = VR::US };
12274 enum { VMType = VM::VM1 };
12275 static const char* GetVMString() { return "1"; }
12276 };
12277 template <> struct TagToType<0x0028,0x0012> {
12278 static const char* GetVRString() { return "US"; }
12279 typedef VRToType<VR::US>::Type Type;
12280 enum : long long { VRType = VR::US };
12281 enum { VMType = VM::VM1 };
12282 static const char* GetVMString() { return "1"; }
12283 };
12284 template <> struct TagToType<0x0028,0x0014> {
12285 static const char* GetVRString() { return "US"; }
12286 typedef VRToType<VR::US>::Type Type;
12287 enum : long long { VRType = VR::US };
12288 enum { VMType = VM::VM1 };
12289 static const char* GetVMString() { return "1"; }
12290 };
12291 template <> struct TagToType<0x0028,0x0030> {
12292 static const char* GetVRString() { return "DS"; }
12293 typedef VRToType<VR::DS>::Type Type;
12294 enum : long long { VRType = VR::DS };
12295 enum { VMType = VM::VM2 };
12296 static const char* GetVMString() { return "2"; }
12297 };
12298 template <> struct TagToType<0x0028,0x0031> {
12299 static const char* GetVRString() { return "DS"; }
12300 typedef VRToType<VR::DS>::Type Type;
12301 enum : long long { VRType = VR::DS };
12302 enum { VMType = VM::VM2 };
12303 static const char* GetVMString() { return "2"; }
12304 };
12305 template <> struct TagToType<0x0028,0x0032> {
12306 static const char* GetVRString() { return "DS"; }
12307 typedef VRToType<VR::DS>::Type Type;
12308 enum : long long { VRType = VR::DS };
12309 enum { VMType = VM::VM2 };
12310 static const char* GetVMString() { return "2"; }
12311 };
12312 template <> struct TagToType<0x0028,0x0034> {
12313 static const char* GetVRString() { return "IS"; }
12314 typedef VRToType<VR::IS>::Type Type;
12315 enum : long long { VRType = VR::IS };
12316 enum { VMType = VM::VM2 };
12317 static const char* GetVMString() { return "2"; }
12318 };
12319 template <> struct TagToType<0x0028,0x0040> {
12320 static const char* GetVRString() { return "CS"; }
12321 typedef VRToType<VR::CS>::Type Type;
12322 enum : long long { VRType = VR::CS };
12323 enum { VMType = VM::VM1 };
12324 static const char* GetVMString() { return "1"; }
12325 };
12326 template <> struct TagToType<0x0028,0x0050> {
12327 static const char* GetVRString() { return "LO"; }
12328 typedef VRToType<VR::LO>::Type Type;
12329 enum : long long { VRType = VR::LO };
12330 enum { VMType = VM::VM1_n };
12331 static const char* GetVMString() { return "1-n"; }
12332 };
12333 template <> struct TagToType<0x0028,0x0051> {
12334 static const char* GetVRString() { return "CS"; }
12335 typedef VRToType<VR::CS>::Type Type;
12336 enum : long long { VRType = VR::CS };
12337 enum { VMType = VM::VM1_n };
12338 static const char* GetVMString() { return "1-n"; }
12339 };
12340 template <> struct TagToType<0x0028,0x005f> {
12341 static const char* GetVRString() { return "LO"; }
12342 typedef VRToType<VR::LO>::Type Type;
12343 enum : long long { VRType = VR::LO };
12344 enum { VMType = VM::VM1 };
12345 static const char* GetVMString() { return "1"; }
12346 };
12347 template <> struct TagToType<0x0028,0x0060> {
12348 static const char* GetVRString() { return "CS"; }
12349 typedef VRToType<VR::CS>::Type Type;
12350 enum : long long { VRType = VR::CS };
12351 enum { VMType = VM::VM1 };
12352 static const char* GetVMString() { return "1"; }
12353 };
12354 template <> struct TagToType<0x0028,0x0061> {
12355 static const char* GetVRString() { return "SH"; }
12356 typedef VRToType<VR::SH>::Type Type;
12357 enum : long long { VRType = VR::SH };
12358 enum { VMType = VM::VM1 };
12359 static const char* GetVMString() { return "1"; }
12360 };
12361 template <> struct TagToType<0x0028,0x0062> {
12362 static const char* GetVRString() { return "LO"; }
12363 typedef VRToType<VR::LO>::Type Type;
12364 enum : long long { VRType = VR::LO };
12365 enum { VMType = VM::VM1 };
12366 static const char* GetVMString() { return "1"; }
12367 };
12368 template <> struct TagToType<0x0028,0x0063> {
12369 static const char* GetVRString() { return "SH"; }
12370 typedef VRToType<VR::SH>::Type Type;
12371 enum : long long { VRType = VR::SH };
12372 enum { VMType = VM::VM1 };
12373 static const char* GetVMString() { return "1"; }
12374 };
12375 template <> struct TagToType<0x0028,0x0065> {
12376 static const char* GetVRString() { return "CS"; }
12377 typedef VRToType<VR::CS>::Type Type;
12378 enum : long long { VRType = VR::CS };
12379 enum { VMType = VM::VM1_n };
12380 static const char* GetVMString() { return "1-n"; }
12381 };
12382 template <> struct TagToType<0x0028,0x0066> {
12383 static const char* GetVRString() { return "AT"; }
12384 typedef VRToType<VR::AT>::Type Type;
12385 enum : long long { VRType = VR::AT };
12386 enum { VMType = VM::VM1_n };
12387 static const char* GetVMString() { return "1-n"; }
12388 };
12389 template <> struct TagToType<0x0028,0x0068> {
12390 static const char* GetVRString() { return "US"; }
12391 typedef VRToType<VR::US>::Type Type;
12392 enum : long long { VRType = VR::US };
12393 enum { VMType = VM::VM1 };
12394 static const char* GetVMString() { return "1"; }
12395 };
12396 template <> struct TagToType<0x0028,0x0069> {
12397 static const char* GetVRString() { return "US"; }
12398 typedef VRToType<VR::US>::Type Type;
12399 enum : long long { VRType = VR::US };
12400 enum { VMType = VM::VM1 };
12401 static const char* GetVMString() { return "1"; }
12402 };
12403 template <> struct TagToType<0x0028,0x0070> {
12404 static const char* GetVRString() { return "US"; }
12405 typedef VRToType<VR::US>::Type Type;
12406 enum : long long { VRType = VR::US };
12407 enum { VMType = VM::VM1_n };
12408 static const char* GetVMString() { return "1-n"; }
12409 };
12410 template <> struct TagToType<0x0028,0x0080> {
12411 static const char* GetVRString() { return "US"; }
12412 typedef VRToType<VR::US>::Type Type;
12413 enum : long long { VRType = VR::US };
12414 enum { VMType = VM::VM1 };
12415 static const char* GetVMString() { return "1"; }
12416 };
12417 template <> struct TagToType<0x0028,0x0081> {
12418 static const char* GetVRString() { return "US"; }
12419 typedef VRToType<VR::US>::Type Type;
12420 enum : long long { VRType = VR::US };
12421 enum { VMType = VM::VM1 };
12422 static const char* GetVMString() { return "1"; }
12423 };
12424 template <> struct TagToType<0x0028,0x0082> {
12425 static const char* GetVRString() { return "US"; }
12426 typedef VRToType<VR::US>::Type Type;
12427 enum : long long { VRType = VR::US };
12428 enum { VMType = VM::VM1_n };
12429 static const char* GetVMString() { return "1-n"; }
12430 };
12431 template <> struct TagToType<0x0028,0x0090> {
12432 static const char* GetVRString() { return "CS"; }
12433 typedef VRToType<VR::CS>::Type Type;
12434 enum : long long { VRType = VR::CS };
12435 enum { VMType = VM::VM1 };
12436 static const char* GetVMString() { return "1"; }
12437 };
12438 template <> struct TagToType<0x0028,0x0091> {
12439 static const char* GetVRString() { return "US"; }
12440 typedef VRToType<VR::US>::Type Type;
12441 enum : long long { VRType = VR::US };
12442 enum { VMType = VM::VM1 };
12443 static const char* GetVMString() { return "1"; }
12444 };
12445 template <> struct TagToType<0x0028,0x0092> {
12446 static const char* GetVRString() { return "US"; }
12447 typedef VRToType<VR::US>::Type Type;
12448 enum : long long { VRType = VR::US };
12449 enum { VMType = VM::VM1 };
12450 static const char* GetVMString() { return "1"; }
12451 };
12452 template <> struct TagToType<0x0028,0x0093> {
12453 static const char* GetVRString() { return "US"; }
12454 typedef VRToType<VR::US>::Type Type;
12455 enum : long long { VRType = VR::US };
12456 enum { VMType = VM::VM1 };
12457 static const char* GetVMString() { return "1"; }
12458 };
12459 template <> struct TagToType<0x0028,0x0094> {
12460 static const char* GetVRString() { return "US"; }
12461 typedef VRToType<VR::US>::Type Type;
12462 enum : long long { VRType = VR::US };
12463 enum { VMType = VM::VM1 };
12464 static const char* GetVMString() { return "1"; }
12465 };
12466 template <> struct TagToType<0x0028,0x0100> {
12467 static const char* GetVRString() { return "US"; }
12468 typedef VRToType<VR::US>::Type Type;
12469 enum : long long { VRType = VR::US };
12470 enum { VMType = VM::VM1 };
12471 static const char* GetVMString() { return "1"; }
12472 };
12473 template <> struct TagToType<0x0028,0x0101> {
12474 static const char* GetVRString() { return "US"; }
12475 typedef VRToType<VR::US>::Type Type;
12476 enum : long long { VRType = VR::US };
12477 enum { VMType = VM::VM1 };
12478 static const char* GetVMString() { return "1"; }
12479 };
12480 template <> struct TagToType<0x0028,0x0102> {
12481 static const char* GetVRString() { return "US"; }
12482 typedef VRToType<VR::US>::Type Type;
12483 enum : long long { VRType = VR::US };
12484 enum { VMType = VM::VM1 };
12485 static const char* GetVMString() { return "1"; }
12486 };
12487 template <> struct TagToType<0x0028,0x0103> {
12488 static const char* GetVRString() { return "US"; }
12489 typedef VRToType<VR::US>::Type Type;
12490 enum : long long { VRType = VR::US };
12491 enum { VMType = VM::VM1 };
12492 static const char* GetVMString() { return "1"; }
12493 };
12494 template <> struct TagToType<0x0028,0x0122> {
12495 static const char* GetVRString() { return "FL"; }
12496 typedef VRToType<VR::FL>::Type Type;
12497 enum : long long { VRType = VR::FL };
12498 enum { VMType = VM::VM1 };
12499 static const char* GetVMString() { return "1"; }
12500 };
12501 template <> struct TagToType<0x0028,0x0123> {
12502 static const char* GetVRString() { return "FD"; }
12503 typedef VRToType<VR::FD>::Type Type;
12504 enum : long long { VRType = VR::FD };
12505 enum { VMType = VM::VM1 };
12506 static const char* GetVMString() { return "1"; }
12507 };
12508 template <> struct TagToType<0x0028,0x0124> {
12509 static const char* GetVRString() { return "FL"; }
12510 typedef VRToType<VR::FL>::Type Type;
12511 enum : long long { VRType = VR::FL };
12512 enum { VMType = VM::VM1 };
12513 static const char* GetVMString() { return "1"; }
12514 };
12515 template <> struct TagToType<0x0028,0x0125> {
12516 static const char* GetVRString() { return "FD"; }
12517 typedef VRToType<VR::FD>::Type Type;
12518 enum : long long { VRType = VR::FD };
12519 enum { VMType = VM::VM1 };
12520 static const char* GetVMString() { return "1"; }
12521 };
12522 template <> struct TagToType<0x0028,0x0200> {
12523 static const char* GetVRString() { return "US"; }
12524 typedef VRToType<VR::US>::Type Type;
12525 enum : long long { VRType = VR::US };
12526 enum { VMType = VM::VM1 };
12527 static const char* GetVMString() { return "1"; }
12528 };
12529 template <> struct TagToType<0x0028,0x0300> {
12530 static const char* GetVRString() { return "CS"; }
12531 typedef VRToType<VR::CS>::Type Type;
12532 enum : long long { VRType = VR::CS };
12533 enum { VMType = VM::VM1 };
12534 static const char* GetVMString() { return "1"; }
12535 };
12536 template <> struct TagToType<0x0028,0x0301> {
12537 static const char* GetVRString() { return "CS"; }
12538 typedef VRToType<VR::CS>::Type Type;
12539 enum : long long { VRType = VR::CS };
12540 enum { VMType = VM::VM1 };
12541 static const char* GetVMString() { return "1"; }
12542 };
12543 template <> struct TagToType<0x0028,0x0302> {
12544 static const char* GetVRString() { return "CS"; }
12545 typedef VRToType<VR::CS>::Type Type;
12546 enum : long long { VRType = VR::CS };
12547 enum { VMType = VM::VM1 };
12548 static const char* GetVMString() { return "1"; }
12549 };
12550 template <> struct TagToType<0x0028,0x0303> {
12551 static const char* GetVRString() { return "CS"; }
12552 typedef VRToType<VR::CS>::Type Type;
12553 enum : long long { VRType = VR::CS };
12554 enum { VMType = VM::VM1 };
12555 static const char* GetVMString() { return "1"; }
12556 };
12557 template <> struct TagToType<0x0028,0x0304> {
12558 static const char* GetVRString() { return "UI"; }
12559 typedef VRToType<VR::UI>::Type Type;
12560 enum : long long { VRType = VR::UI };
12561 enum { VMType = VM::VM1 };
12562 static const char* GetVMString() { return "1"; }
12563 };
12564 template <> struct TagToType<0x0028,0x0400> {
12565 static const char* GetVRString() { return "LO"; }
12566 typedef VRToType<VR::LO>::Type Type;
12567 enum : long long { VRType = VR::LO };
12568 enum { VMType = VM::VM1 };
12569 static const char* GetVMString() { return "1"; }
12570 };
12571 template <> struct TagToType<0x0028,0x0401> {
12572 static const char* GetVRString() { return "LO"; }
12573 typedef VRToType<VR::LO>::Type Type;
12574 enum : long long { VRType = VR::LO };
12575 enum { VMType = VM::VM1 };
12576 static const char* GetVMString() { return "1"; }
12577 };
12578 template <> struct TagToType<0x0028,0x0402> {
12579 static const char* GetVRString() { return "US"; }
12580 typedef VRToType<VR::US>::Type Type;
12581 enum : long long { VRType = VR::US };
12582 enum { VMType = VM::VM1 };
12583 static const char* GetVMString() { return "1"; }
12584 };
12585 template <> struct TagToType<0x0028,0x0403> {
12586 static const char* GetVRString() { return "LO"; }
12587 typedef VRToType<VR::LO>::Type Type;
12588 enum : long long { VRType = VR::LO };
12589 enum { VMType = VM::VM1_n };
12590 static const char* GetVMString() { return "1-n"; }
12591 };
12592 template <> struct TagToType<0x0028,0x0404> {
12593 static const char* GetVRString() { return "AT"; }
12594 typedef VRToType<VR::AT>::Type Type;
12595 enum : long long { VRType = VR::AT };
12596 enum { VMType = VM::VM1_n };
12597 static const char* GetVMString() { return "1-n"; }
12598 };
12599 template <> struct TagToType<0x0028,0x0700> {
12600 static const char* GetVRString() { return "LO"; }
12601 typedef VRToType<VR::LO>::Type Type;
12602 enum : long long { VRType = VR::LO };
12603 enum { VMType = VM::VM1 };
12604 static const char* GetVMString() { return "1"; }
12605 };
12606 template <> struct TagToType<0x0028,0x0701> {
12607 static const char* GetVRString() { return "CS"; }
12608 typedef VRToType<VR::CS>::Type Type;
12609 enum : long long { VRType = VR::CS };
12610 enum { VMType = VM::VM1_n };
12611 static const char* GetVMString() { return "1-n"; }
12612 };
12613 template <> struct TagToType<0x0028,0x0702> {
12614 static const char* GetVRString() { return "AT"; }
12615 typedef VRToType<VR::AT>::Type Type;
12616 enum : long long { VRType = VR::AT };
12617 enum { VMType = VM::VM1_n };
12618 static const char* GetVMString() { return "1-n"; }
12619 };
12620 template <> struct TagToType<0x0028,0x0710> {
12621 static const char* GetVRString() { return "US"; }
12622 typedef VRToType<VR::US>::Type Type;
12623 enum : long long { VRType = VR::US };
12624 enum { VMType = VM::VM1 };
12625 static const char* GetVMString() { return "1"; }
12626 };
12627 template <> struct TagToType<0x0028,0x0720> {
12628 static const char* GetVRString() { return "US"; }
12629 typedef VRToType<VR::US>::Type Type;
12630 enum : long long { VRType = VR::US };
12631 enum { VMType = VM::VM1 };
12632 static const char* GetVMString() { return "1"; }
12633 };
12634 template <> struct TagToType<0x0028,0x0721> {
12635 static const char* GetVRString() { return "AT"; }
12636 typedef VRToType<VR::AT>::Type Type;
12637 enum : long long { VRType = VR::AT };
12638 enum { VMType = VM::VM1_n };
12639 static const char* GetVMString() { return "1-n"; }
12640 };
12641 template <> struct TagToType<0x0028,0x0722> {
12642 static const char* GetVRString() { return "US"; }
12643 typedef VRToType<VR::US>::Type Type;
12644 enum : long long { VRType = VR::US };
12645 enum { VMType = VM::VM1 };
12646 static const char* GetVMString() { return "1"; }
12647 };
12648 template <> struct TagToType<0x0028,0x0730> {
12649 static const char* GetVRString() { return "US"; }
12650 typedef VRToType<VR::US>::Type Type;
12651 enum : long long { VRType = VR::US };
12652 enum { VMType = VM::VM1 };
12653 static const char* GetVMString() { return "1"; }
12654 };
12655 template <> struct TagToType<0x0028,0x0740> {
12656 static const char* GetVRString() { return "US"; }
12657 typedef VRToType<VR::US>::Type Type;
12658 enum : long long { VRType = VR::US };
12659 enum { VMType = VM::VM1 };
12660 static const char* GetVMString() { return "1"; }
12661 };
12662 template <> struct TagToType<0x0028,0x0a02> {
12663 static const char* GetVRString() { return "CS"; }
12664 typedef VRToType<VR::CS>::Type Type;
12665 enum : long long { VRType = VR::CS };
12666 enum { VMType = VM::VM1 };
12667 static const char* GetVMString() { return "1"; }
12668 };
12669 template <> struct TagToType<0x0028,0x0a04> {
12670 static const char* GetVRString() { return "LO"; }
12671 typedef VRToType<VR::LO>::Type Type;
12672 enum : long long { VRType = VR::LO };
12673 enum { VMType = VM::VM1 };
12674 static const char* GetVMString() { return "1"; }
12675 };
12676 template <> struct TagToType<0x0028,0x1040> {
12677 static const char* GetVRString() { return "CS"; }
12678 typedef VRToType<VR::CS>::Type Type;
12679 enum : long long { VRType = VR::CS };
12680 enum { VMType = VM::VM1 };
12681 static const char* GetVMString() { return "1"; }
12682 };
12683 template <> struct TagToType<0x0028,0x1041> {
12684 static const char* GetVRString() { return "SS"; }
12685 typedef VRToType<VR::SS>::Type Type;
12686 enum : long long { VRType = VR::SS };
12687 enum { VMType = VM::VM1 };
12688 static const char* GetVMString() { return "1"; }
12689 };
12690 template <> struct TagToType<0x0028,0x1050> {
12691 static const char* GetVRString() { return "DS"; }
12692 typedef VRToType<VR::DS>::Type Type;
12693 enum : long long { VRType = VR::DS };
12694 enum { VMType = VM::VM1_n };
12695 static const char* GetVMString() { return "1-n"; }
12696 };
12697 template <> struct TagToType<0x0028,0x1051> {
12698 static const char* GetVRString() { return "DS"; }
12699 typedef VRToType<VR::DS>::Type Type;
12700 enum : long long { VRType = VR::DS };
12701 enum { VMType = VM::VM1_n };
12702 static const char* GetVMString() { return "1-n"; }
12703 };
12704 template <> struct TagToType<0x0028,0x1052> {
12705 static const char* GetVRString() { return "DS"; }
12706 typedef VRToType<VR::DS>::Type Type;
12707 enum : long long { VRType = VR::DS };
12708 enum { VMType = VM::VM1 };
12709 static const char* GetVMString() { return "1"; }
12710 };
12711 template <> struct TagToType<0x0028,0x1053> {
12712 static const char* GetVRString() { return "DS"; }
12713 typedef VRToType<VR::DS>::Type Type;
12714 enum : long long { VRType = VR::DS };
12715 enum { VMType = VM::VM1 };
12716 static const char* GetVMString() { return "1"; }
12717 };
12718 template <> struct TagToType<0x0028,0x1054> {
12719 static const char* GetVRString() { return "LO"; }
12720 typedef VRToType<VR::LO>::Type Type;
12721 enum : long long { VRType = VR::LO };
12722 enum { VMType = VM::VM1 };
12723 static const char* GetVMString() { return "1"; }
12724 };
12725 template <> struct TagToType<0x0028,0x1055> {
12726 static const char* GetVRString() { return "LO"; }
12727 typedef VRToType<VR::LO>::Type Type;
12728 enum : long long { VRType = VR::LO };
12729 enum { VMType = VM::VM1_n };
12730 static const char* GetVMString() { return "1-n"; }
12731 };
12732 template <> struct TagToType<0x0028,0x1056> {
12733 static const char* GetVRString() { return "CS"; }
12734 typedef VRToType<VR::CS>::Type Type;
12735 enum : long long { VRType = VR::CS };
12736 enum { VMType = VM::VM1 };
12737 static const char* GetVMString() { return "1"; }
12738 };
12739 template <> struct TagToType<0x0028,0x1080> {
12740 static const char* GetVRString() { return "CS"; }
12741 typedef VRToType<VR::CS>::Type Type;
12742 enum : long long { VRType = VR::CS };
12743 enum { VMType = VM::VM1 };
12744 static const char* GetVMString() { return "1"; }
12745 };
12746 template <> struct TagToType<0x0028,0x1090> {
12747 static const char* GetVRString() { return "CS"; }
12748 typedef VRToType<VR::CS>::Type Type;
12749 enum : long long { VRType = VR::CS };
12750 enum { VMType = VM::VM1 };
12751 static const char* GetVMString() { return "1"; }
12752 };
12753 template <> struct TagToType<0x0028,0x1104> {
12754 static const char* GetVRString() { return "US"; }
12755 typedef VRToType<VR::US>::Type Type;
12756 enum : long long { VRType = VR::US };
12757 enum { VMType = VM::VM3 };
12758 static const char* GetVMString() { return "3"; }
12759 };
12760 template <> struct TagToType<0x0028,0x1199> {
12761 static const char* GetVRString() { return "UI"; }
12762 typedef VRToType<VR::UI>::Type Type;
12763 enum : long long { VRType = VR::UI };
12764 enum { VMType = VM::VM1 };
12765 static const char* GetVMString() { return "1"; }
12766 };
12767 template <> struct TagToType<0x0028,0x1201> {
12768 static const char* GetVRString() { return "OW"; }
12769 typedef VRToType<VR::OW>::Type Type;
12770 enum : long long { VRType = VR::OW };
12771 enum { VMType = VM::VM1 };
12772 static const char* GetVMString() { return "1"; }
12773 };
12774 template <> struct TagToType<0x0028,0x1202> {
12775 static const char* GetVRString() { return "OW"; }
12776 typedef VRToType<VR::OW>::Type Type;
12777 enum : long long { VRType = VR::OW };
12778 enum { VMType = VM::VM1 };
12779 static const char* GetVMString() { return "1"; }
12780 };
12781 template <> struct TagToType<0x0028,0x1203> {
12782 static const char* GetVRString() { return "OW"; }
12783 typedef VRToType<VR::OW>::Type Type;
12784 enum : long long { VRType = VR::OW };
12785 enum { VMType = VM::VM1 };
12786 static const char* GetVMString() { return "1"; }
12787 };
12788 template <> struct TagToType<0x0028,0x1204> {
12789 static const char* GetVRString() { return "OW"; }
12790 typedef VRToType<VR::OW>::Type Type;
12791 enum : long long { VRType = VR::OW };
12792 enum { VMType = VM::VM1 };
12793 static const char* GetVMString() { return "1"; }
12794 };
12795 template <> struct TagToType<0x0028,0x1211> {
12796 static const char* GetVRString() { return "OW"; }
12797 typedef VRToType<VR::OW>::Type Type;
12798 enum : long long { VRType = VR::OW };
12799 enum { VMType = VM::VM1 };
12800 static const char* GetVMString() { return "1"; }
12801 };
12802 template <> struct TagToType<0x0028,0x1212> {
12803 static const char* GetVRString() { return "OW"; }
12804 typedef VRToType<VR::OW>::Type Type;
12805 enum : long long { VRType = VR::OW };
12806 enum { VMType = VM::VM1 };
12807 static const char* GetVMString() { return "1"; }
12808 };
12809 template <> struct TagToType<0x0028,0x1213> {
12810 static const char* GetVRString() { return "OW"; }
12811 typedef VRToType<VR::OW>::Type Type;
12812 enum : long long { VRType = VR::OW };
12813 enum { VMType = VM::VM1 };
12814 static const char* GetVMString() { return "1"; }
12815 };
12816 template <> struct TagToType<0x0028,0x1214> {
12817 static const char* GetVRString() { return "UI"; }
12818 typedef VRToType<VR::UI>::Type Type;
12819 enum : long long { VRType = VR::UI };
12820 enum { VMType = VM::VM1 };
12821 static const char* GetVMString() { return "1"; }
12822 };
12823 template <> struct TagToType<0x0028,0x1221> {
12824 static const char* GetVRString() { return "OW"; }
12825 typedef VRToType<VR::OW>::Type Type;
12826 enum : long long { VRType = VR::OW };
12827 enum { VMType = VM::VM1 };
12828 static const char* GetVMString() { return "1"; }
12829 };
12830 template <> struct TagToType<0x0028,0x1222> {
12831 static const char* GetVRString() { return "OW"; }
12832 typedef VRToType<VR::OW>::Type Type;
12833 enum : long long { VRType = VR::OW };
12834 enum { VMType = VM::VM1 };
12835 static const char* GetVMString() { return "1"; }
12836 };
12837 template <> struct TagToType<0x0028,0x1223> {
12838 static const char* GetVRString() { return "OW"; }
12839 typedef VRToType<VR::OW>::Type Type;
12840 enum : long long { VRType = VR::OW };
12841 enum { VMType = VM::VM1 };
12842 static const char* GetVMString() { return "1"; }
12843 };
12844 template <> struct TagToType<0x0028,0x1224> {
12845 static const char* GetVRString() { return "OW"; }
12846 typedef VRToType<VR::OW>::Type Type;
12847 enum : long long { VRType = VR::OW };
12848 enum { VMType = VM::VM1 };
12849 static const char* GetVMString() { return "1"; }
12850 };
12851 template <> struct TagToType<0x0028,0x1230> {
12852 static const char* GetVRString() { return "SQ"; }
12853 typedef VRToType<VR::SQ>::Type Type;
12854 enum : long long { VRType = VR::SQ };
12855 enum { VMType = VM::VM1 };
12856 static const char* GetVMString() { return "1"; }
12857 };
12858 template <> struct TagToType<0x0028,0x1231> {
12859 static const char* GetVRString() { return "FD"; }
12860 typedef VRToType<VR::FD>::Type Type;
12861 enum : long long { VRType = VR::FD };
12862 enum { VMType = VM::VM1 };
12863 static const char* GetVMString() { return "1"; }
12864 };
12865 template <> struct TagToType<0x0028,0x1232> {
12866 static const char* GetVRString() { return "FD"; }
12867 typedef VRToType<VR::FD>::Type Type;
12868 enum : long long { VRType = VR::FD };
12869 enum { VMType = VM::VM1 };
12870 static const char* GetVMString() { return "1"; }
12871 };
12872 template <> struct TagToType<0x0028,0x1300> {
12873 static const char* GetVRString() { return "CS"; }
12874 typedef VRToType<VR::CS>::Type Type;
12875 enum : long long { VRType = VR::CS };
12876 enum { VMType = VM::VM1 };
12877 static const char* GetVMString() { return "1"; }
12878 };
12879 template <> struct TagToType<0x0028,0x1350> {
12880 static const char* GetVRString() { return "CS"; }
12881 typedef VRToType<VR::CS>::Type Type;
12882 enum : long long { VRType = VR::CS };
12883 enum { VMType = VM::VM1 };
12884 static const char* GetVMString() { return "1"; }
12885 };
12886 template <> struct TagToType<0x0028,0x1351> {
12887 static const char* GetVRString() { return "ST"; }
12888 typedef VRToType<VR::ST>::Type Type;
12889 enum : long long { VRType = VR::ST };
12890 enum { VMType = VM::VM1 };
12891 static const char* GetVMString() { return "1"; }
12892 };
12893 template <> struct TagToType<0x0028,0x1352> {
12894 static const char* GetVRString() { return "SQ"; }
12895 typedef VRToType<VR::SQ>::Type Type;
12896 enum : long long { VRType = VR::SQ };
12897 enum { VMType = VM::VM1 };
12898 static const char* GetVMString() { return "1"; }
12899 };
12900 template <> struct TagToType<0x0028,0x135a> {
12901 static const char* GetVRString() { return "CS"; }
12902 typedef VRToType<VR::CS>::Type Type;
12903 enum : long long { VRType = VR::CS };
12904 enum { VMType = VM::VM1 };
12905 static const char* GetVMString() { return "1"; }
12906 };
12907 template <> struct TagToType<0x0028,0x1401> {
12908 static const char* GetVRString() { return "SQ"; }
12909 typedef VRToType<VR::SQ>::Type Type;
12910 enum : long long { VRType = VR::SQ };
12911 enum { VMType = VM::VM1 };
12912 static const char* GetVMString() { return "1"; }
12913 };
12914 template <> struct TagToType<0x0028,0x1402> {
12915 static const char* GetVRString() { return "CS"; }
12916 typedef VRToType<VR::CS>::Type Type;
12917 enum : long long { VRType = VR::CS };
12918 enum { VMType = VM::VM1 };
12919 static const char* GetVMString() { return "1"; }
12920 };
12921 template <> struct TagToType<0x0028,0x1403> {
12922 static const char* GetVRString() { return "US"; }
12923 typedef VRToType<VR::US>::Type Type;
12924 enum : long long { VRType = VR::US };
12925 enum { VMType = VM::VM1 };
12926 static const char* GetVMString() { return "1"; }
12927 };
12928 template <> struct TagToType<0x0028,0x1404> {
12929 static const char* GetVRString() { return "SQ"; }
12930 typedef VRToType<VR::SQ>::Type Type;
12931 enum : long long { VRType = VR::SQ };
12932 enum { VMType = VM::VM1 };
12933 static const char* GetVMString() { return "1"; }
12934 };
12935 template <> struct TagToType<0x0028,0x1405> {
12936 static const char* GetVRString() { return "CS"; }
12937 typedef VRToType<VR::CS>::Type Type;
12938 enum : long long { VRType = VR::CS };
12939 enum { VMType = VM::VM1 };
12940 static const char* GetVMString() { return "1"; }
12941 };
12942 template <> struct TagToType<0x0028,0x1406> {
12943 static const char* GetVRString() { return "FD"; }
12944 typedef VRToType<VR::FD>::Type Type;
12945 enum : long long { VRType = VR::FD };
12946 enum { VMType = VM::VM1 };
12947 static const char* GetVMString() { return "1"; }
12948 };
12949 template <> struct TagToType<0x0028,0x1407> {
12950 static const char* GetVRString() { return "US"; }
12951 typedef VRToType<VR::US>::Type Type;
12952 enum : long long { VRType = VR::US };
12953 enum { VMType = VM::VM3 };
12954 static const char* GetVMString() { return "3"; }
12955 };
12956 template <> struct TagToType<0x0028,0x1408> {
12957 static const char* GetVRString() { return "OW"; }
12958 typedef VRToType<VR::OW>::Type Type;
12959 enum : long long { VRType = VR::OW };
12960 enum { VMType = VM::VM1 };
12961 static const char* GetVMString() { return "1"; }
12962 };
12963 template <> struct TagToType<0x0028,0x140b> {
12964 static const char* GetVRString() { return "SQ"; }
12965 typedef VRToType<VR::SQ>::Type Type;
12966 enum : long long { VRType = VR::SQ };
12967 enum { VMType = VM::VM1 };
12968 static const char* GetVMString() { return "1"; }
12969 };
12970 template <> struct TagToType<0x0028,0x140c> {
12971 static const char* GetVRString() { return "SQ"; }
12972 typedef VRToType<VR::SQ>::Type Type;
12973 enum : long long { VRType = VR::SQ };
12974 enum { VMType = VM::VM1 };
12975 static const char* GetVMString() { return "1"; }
12976 };
12977 template <> struct TagToType<0x0028,0x140d> {
12978 static const char* GetVRString() { return "CS"; }
12979 typedef VRToType<VR::CS>::Type Type;
12980 enum : long long { VRType = VR::CS };
12981 enum { VMType = VM::VM1 };
12982 static const char* GetVMString() { return "1"; }
12983 };
12984 template <> struct TagToType<0x0028,0x140e> {
12985 static const char* GetVRString() { return "CS"; }
12986 typedef VRToType<VR::CS>::Type Type;
12987 enum : long long { VRType = VR::CS };
12988 enum { VMType = VM::VM1 };
12989 static const char* GetVMString() { return "1"; }
12990 };
12991 template <> struct TagToType<0x0028,0x140f> {
12992 static const char* GetVRString() { return "CS"; }
12993 typedef VRToType<VR::CS>::Type Type;
12994 enum : long long { VRType = VR::CS };
12995 enum { VMType = VM::VM1 };
12996 static const char* GetVMString() { return "1"; }
12997 };
12998 template <> struct TagToType<0x0028,0x1410> {
12999 static const char* GetVRString() { return "CS"; }
13000 typedef VRToType<VR::CS>::Type Type;
13001 enum : long long { VRType = VR::CS };
13002 enum { VMType = VM::VM1 };
13003 static const char* GetVMString() { return "1"; }
13004 };
13005 template <> struct TagToType<0x0028,0x2000> {
13006 static const char* GetVRString() { return "OB"; }
13007 typedef VRToType<VR::OB>::Type Type;
13008 enum : long long { VRType = VR::OB };
13009 enum { VMType = VM::VM1 };
13010 static const char* GetVMString() { return "1"; }
13011 };
13012 template <> struct TagToType<0x0028,0x2002> {
13013 static const char* GetVRString() { return "CS"; }
13014 typedef VRToType<VR::CS>::Type Type;
13015 enum : long long { VRType = VR::CS };
13016 enum { VMType = VM::VM1 };
13017 static const char* GetVMString() { return "1"; }
13018 };
13019 template <> struct TagToType<0x0028,0x2110> {
13020 static const char* GetVRString() { return "CS"; }
13021 typedef VRToType<VR::CS>::Type Type;
13022 enum : long long { VRType = VR::CS };
13023 enum { VMType = VM::VM1 };
13024 static const char* GetVMString() { return "1"; }
13025 };
13026 template <> struct TagToType<0x0028,0x2112> {
13027 static const char* GetVRString() { return "DS"; }
13028 typedef VRToType<VR::DS>::Type Type;
13029 enum : long long { VRType = VR::DS };
13030 enum { VMType = VM::VM1_n };
13031 static const char* GetVMString() { return "1-n"; }
13032 };
13033 template <> struct TagToType<0x0028,0x2114> {
13034 static const char* GetVRString() { return "CS"; }
13035 typedef VRToType<VR::CS>::Type Type;
13036 enum : long long { VRType = VR::CS };
13037 enum { VMType = VM::VM1_n };
13038 static const char* GetVMString() { return "1-n"; }
13039 };
13040 template <> struct TagToType<0x0028,0x3000> {
13041 static const char* GetVRString() { return "SQ"; }
13042 typedef VRToType<VR::SQ>::Type Type;
13043 enum : long long { VRType = VR::SQ };
13044 enum { VMType = VM::VM1 };
13045 static const char* GetVMString() { return "1"; }
13046 };
13047 template <> struct TagToType<0x0028,0x3003> {
13048 static const char* GetVRString() { return "LO"; }
13049 typedef VRToType<VR::LO>::Type Type;
13050 enum : long long { VRType = VR::LO };
13051 enum { VMType = VM::VM1 };
13052 static const char* GetVMString() { return "1"; }
13053 };
13054 template <> struct TagToType<0x0028,0x3004> {
13055 static const char* GetVRString() { return "LO"; }
13056 typedef VRToType<VR::LO>::Type Type;
13057 enum : long long { VRType = VR::LO };
13058 enum { VMType = VM::VM1 };
13059 static const char* GetVMString() { return "1"; }
13060 };
13061 template <> struct TagToType<0x0028,0x3010> {
13062 static const char* GetVRString() { return "SQ"; }
13063 typedef VRToType<VR::SQ>::Type Type;
13064 enum : long long { VRType = VR::SQ };
13065 enum { VMType = VM::VM1 };
13066 static const char* GetVMString() { return "1"; }
13067 };
13068 template <> struct TagToType<0x0028,0x3110> {
13069 static const char* GetVRString() { return "SQ"; }
13070 typedef VRToType<VR::SQ>::Type Type;
13071 enum : long long { VRType = VR::SQ };
13072 enum { VMType = VM::VM1 };
13073 static const char* GetVMString() { return "1"; }
13074 };
13075 template <> struct TagToType<0x0028,0x4000> {
13076 static const char* GetVRString() { return "LT"; }
13077 typedef VRToType<VR::LT>::Type Type;
13078 enum : long long { VRType = VR::LT };
13079 enum { VMType = VM::VM1 };
13080 static const char* GetVMString() { return "1"; }
13081 };
13082 template <> struct TagToType<0x0028,0x5000> {
13083 static const char* GetVRString() { return "SQ"; }
13084 typedef VRToType<VR::SQ>::Type Type;
13085 enum : long long { VRType = VR::SQ };
13086 enum { VMType = VM::VM1 };
13087 static const char* GetVMString() { return "1"; }
13088 };
13089 template <> struct TagToType<0x0028,0x6010> {
13090 static const char* GetVRString() { return "US"; }
13091 typedef VRToType<VR::US>::Type Type;
13092 enum : long long { VRType = VR::US };
13093 enum { VMType = VM::VM1 };
13094 static const char* GetVMString() { return "1"; }
13095 };
13096 template <> struct TagToType<0x0028,0x6020> {
13097 static const char* GetVRString() { return "US"; }
13098 typedef VRToType<VR::US>::Type Type;
13099 enum : long long { VRType = VR::US };
13100 enum { VMType = VM::VM1_n };
13101 static const char* GetVMString() { return "1-n"; }
13102 };
13103 template <> struct TagToType<0x0028,0x6022> {
13104 static const char* GetVRString() { return "LO"; }
13105 typedef VRToType<VR::LO>::Type Type;
13106 enum : long long { VRType = VR::LO };
13107 enum { VMType = VM::VM1_n };
13108 static const char* GetVMString() { return "1-n"; }
13109 };
13110 template <> struct TagToType<0x0028,0x6023> {
13111 static const char* GetVRString() { return "CS"; }
13112 typedef VRToType<VR::CS>::Type Type;
13113 enum : long long { VRType = VR::CS };
13114 enum { VMType = VM::VM1_n };
13115 static const char* GetVMString() { return "1-n"; }
13116 };
13117 template <> struct TagToType<0x0028,0x6030> {
13118 static const char* GetVRString() { return "US"; }
13119 typedef VRToType<VR::US>::Type Type;
13120 enum : long long { VRType = VR::US };
13121 enum { VMType = VM::VM1_n };
13122 static const char* GetVMString() { return "1-n"; }
13123 };
13124 template <> struct TagToType<0x0028,0x6040> {
13125 static const char* GetVRString() { return "US"; }
13126 typedef VRToType<VR::US>::Type Type;
13127 enum : long long { VRType = VR::US };
13128 enum { VMType = VM::VM1_n };
13129 static const char* GetVMString() { return "1-n"; }
13130 };
13131 template <> struct TagToType<0x0028,0x6100> {
13132 static const char* GetVRString() { return "SQ"; }
13133 typedef VRToType<VR::SQ>::Type Type;
13134 enum : long long { VRType = VR::SQ };
13135 enum { VMType = VM::VM1 };
13136 static const char* GetVMString() { return "1"; }
13137 };
13138 template <> struct TagToType<0x0028,0x6101> {
13139 static const char* GetVRString() { return "CS"; }
13140 typedef VRToType<VR::CS>::Type Type;
13141 enum : long long { VRType = VR::CS };
13142 enum { VMType = VM::VM1 };
13143 static const char* GetVMString() { return "1"; }
13144 };
13145 template <> struct TagToType<0x0028,0x6102> {
13146 static const char* GetVRString() { return "US"; }
13147 typedef VRToType<VR::US>::Type Type;
13148 enum : long long { VRType = VR::US };
13149 enum { VMType = VM::VM2_2n };
13150 static const char* GetVMString() { return "2-2n"; }
13151 };
13152 template <> struct TagToType<0x0028,0x6110> {
13153 static const char* GetVRString() { return "US"; }
13154 typedef VRToType<VR::US>::Type Type;
13155 enum : long long { VRType = VR::US };
13156 enum { VMType = VM::VM1_n };
13157 static const char* GetVMString() { return "1-n"; }
13158 };
13159 template <> struct TagToType<0x0028,0x6112> {
13160 static const char* GetVRString() { return "US"; }
13161 typedef VRToType<VR::US>::Type Type;
13162 enum : long long { VRType = VR::US };
13163 enum { VMType = VM::VM1 };
13164 static const char* GetVMString() { return "1"; }
13165 };
13166 template <> struct TagToType<0x0028,0x6114> {
13167 static const char* GetVRString() { return "FL"; }
13168 typedef VRToType<VR::FL>::Type Type;
13169 enum : long long { VRType = VR::FL };
13170 enum { VMType = VM::VM2 };
13171 static const char* GetVMString() { return "2"; }
13172 };
13173 template <> struct TagToType<0x0028,0x6120> {
13174 static const char* GetVRString() { return "SS"; }
13175 typedef VRToType<VR::SS>::Type Type;
13176 enum : long long { VRType = VR::SS };
13177 enum { VMType = VM::VM1 };
13178 static const char* GetVMString() { return "1"; }
13179 };
13180 template <> struct TagToType<0x0028,0x6190> {
13181 static const char* GetVRString() { return "ST"; }
13182 typedef VRToType<VR::ST>::Type Type;
13183 enum : long long { VRType = VR::ST };
13184 enum { VMType = VM::VM1 };
13185 static const char* GetVMString() { return "1"; }
13186 };
13187 template <> struct TagToType<0x0028,0x7000> {
13188 static const char* GetVRString() { return "SQ"; }
13189 typedef VRToType<VR::SQ>::Type Type;
13190 enum : long long { VRType = VR::SQ };
13191 enum { VMType = VM::VM1 };
13192 static const char* GetVMString() { return "1"; }
13193 };
13194 template <> struct TagToType<0x0028,0x7001> {
13195 static const char* GetVRString() { return "US"; }
13196 typedef VRToType<VR::US>::Type Type;
13197 enum : long long { VRType = VR::US };
13198 enum { VMType = VM::VM1 };
13199 static const char* GetVMString() { return "1"; }
13200 };
13201 template <> struct TagToType<0x0028,0x7002> {
13202 static const char* GetVRString() { return "US"; }
13203 typedef VRToType<VR::US>::Type Type;
13204 enum : long long { VRType = VR::US };
13205 enum { VMType = VM::VM1 };
13206 static const char* GetVMString() { return "1"; }
13207 };
13208 template <> struct TagToType<0x0028,0x7003> {
13209 static const char* GetVRString() { return "US"; }
13210 typedef VRToType<VR::US>::Type Type;
13211 enum : long long { VRType = VR::US };
13212 enum { VMType = VM::VM1 };
13213 static const char* GetVMString() { return "1"; }
13214 };
13215 template <> struct TagToType<0x0028,0x7004> {
13216 static const char* GetVRString() { return "SH"; }
13217 typedef VRToType<VR::SH>::Type Type;
13218 enum : long long { VRType = VR::SH };
13219 enum { VMType = VM::VM1 };
13220 static const char* GetVMString() { return "1"; }
13221 };
13222 template <> struct TagToType<0x0028,0x7005> {
13223 static const char* GetVRString() { return "LO"; }
13224 typedef VRToType<VR::LO>::Type Type;
13225 enum : long long { VRType = VR::LO };
13226 enum { VMType = VM::VM1 };
13227 static const char* GetVMString() { return "1"; }
13228 };
13229 template <> struct TagToType<0x0028,0x7006> {
13230 static const char* GetVRString() { return "CS"; }
13231 typedef VRToType<VR::CS>::Type Type;
13232 enum : long long { VRType = VR::CS };
13233 enum { VMType = VM::VM1 };
13234 static const char* GetVMString() { return "1"; }
13235 };
13236 template <> struct TagToType<0x0028,0x7007> {
13237 static const char* GetVRString() { return "LO"; }
13238 typedef VRToType<VR::LO>::Type Type;
13239 enum : long long { VRType = VR::LO };
13240 enum { VMType = VM::VM1 };
13241 static const char* GetVMString() { return "1"; }
13242 };
13243 template <> struct TagToType<0x0028,0x7008> {
13244 static const char* GetVRString() { return "SQ"; }
13245 typedef VRToType<VR::SQ>::Type Type;
13246 enum : long long { VRType = VR::SQ };
13247 enum { VMType = VM::VM1 };
13248 static const char* GetVMString() { return "1"; }
13249 };
13250 template <> struct TagToType<0x0028,0x7009> {
13251 static const char* GetVRString() { return "US"; }
13252 typedef VRToType<VR::US>::Type Type;
13253 enum : long long { VRType = VR::US };
13254 enum { VMType = VM::VM1 };
13255 static const char* GetVMString() { return "1"; }
13256 };
13257 template <> struct TagToType<0x0028,0x700a> {
13258 static const char* GetVRString() { return "SQ"; }
13259 typedef VRToType<VR::SQ>::Type Type;
13260 enum : long long { VRType = VR::SQ };
13261 enum { VMType = VM::VM1 };
13262 static const char* GetVMString() { return "1"; }
13263 };
13264 template <> struct TagToType<0x0028,0x700b> {
13265 static const char* GetVRString() { return "US"; }
13266 typedef VRToType<VR::US>::Type Type;
13267 enum : long long { VRType = VR::US };
13268 enum { VMType = VM::VM1 };
13269 static const char* GetVMString() { return "1"; }
13270 };
13271 template <> struct TagToType<0x0028,0x700c> {
13272 static const char* GetVRString() { return "SH"; }
13273 typedef VRToType<VR::SH>::Type Type;
13274 enum : long long { VRType = VR::SH };
13275 enum { VMType = VM::VM1 };
13276 static const char* GetVMString() { return "1"; }
13277 };
13278 template <> struct TagToType<0x0028,0x700d> {
13279 static const char* GetVRString() { return "LO"; }
13280 typedef VRToType<VR::LO>::Type Type;
13281 enum : long long { VRType = VR::LO };
13282 enum { VMType = VM::VM1 };
13283 static const char* GetVMString() { return "1"; }
13284 };
13285 template <> struct TagToType<0x0028,0x700e> {
13286 static const char* GetVRString() { return "US"; }
13287 typedef VRToType<VR::US>::Type Type;
13288 enum : long long { VRType = VR::US };
13289 enum { VMType = VM::VM1 };
13290 static const char* GetVMString() { return "1"; }
13291 };
13292 template <> struct TagToType<0x0028,0x700f> {
13293 static const char* GetVRString() { return "SQ"; }
13294 typedef VRToType<VR::SQ>::Type Type;
13295 enum : long long { VRType = VR::SQ };
13296 enum { VMType = VM::VM1 };
13297 static const char* GetVMString() { return "1"; }
13298 };
13299 template <> struct TagToType<0x0028,0x7010> {
13300 static const char* GetVRString() { return "SQ"; }
13301 typedef VRToType<VR::SQ>::Type Type;
13302 enum : long long { VRType = VR::SQ };
13303 enum { VMType = VM::VM1 };
13304 static const char* GetVMString() { return "1"; }
13305 };
13306 template <> struct TagToType<0x0028,0x7011> {
13307 static const char* GetVRString() { return "SQ"; }
13308 typedef VRToType<VR::SQ>::Type Type;
13309 enum : long long { VRType = VR::SQ };
13310 enum { VMType = VM::VM1 };
13311 static const char* GetVMString() { return "1"; }
13312 };
13313 template <> struct TagToType<0x0028,0x7012> {
13314 static const char* GetVRString() { return "SQ"; }
13315 typedef VRToType<VR::SQ>::Type Type;
13316 enum : long long { VRType = VR::SQ };
13317 enum { VMType = VM::VM1 };
13318 static const char* GetVMString() { return "1"; }
13319 };
13320 template <> struct TagToType<0x0028,0x7013> {
13321 static const char* GetVRString() { return "CS"; }
13322 typedef VRToType<VR::CS>::Type Type;
13323 enum : long long { VRType = VR::CS };
13324 enum { VMType = VM::VM1_n };
13325 static const char* GetVMString() { return "1-n"; }
13326 };
13327 template <> struct TagToType<0x0028,0x7014> {
13328 static const char* GetVRString() { return "CS"; }
13329 typedef VRToType<VR::CS>::Type Type;
13330 enum : long long { VRType = VR::CS };
13331 enum { VMType = VM::VM1 };
13332 static const char* GetVMString() { return "1"; }
13333 };
13334 template <> struct TagToType<0x0028,0x7015> {
13335 static const char* GetVRString() { return "SQ"; }
13336 typedef VRToType<VR::SQ>::Type Type;
13337 enum : long long { VRType = VR::SQ };
13338 enum { VMType = VM::VM1 };
13339 static const char* GetVMString() { return "1"; }
13340 };
13341 template <> struct TagToType<0x0028,0x7016> {
13342 static const char* GetVRString() { return "SQ"; }
13343 typedef VRToType<VR::SQ>::Type Type;
13344 enum : long long { VRType = VR::SQ };
13345 enum { VMType = VM::VM1 };
13346 static const char* GetVMString() { return "1"; }
13347 };
13348 template <> struct TagToType<0x0028,0x7017> {
13349 static const char* GetVRString() { return "US"; }
13350 typedef VRToType<VR::US>::Type Type;
13351 enum : long long { VRType = VR::US };
13352 enum { VMType = VM::VM1 };
13353 static const char* GetVMString() { return "1"; }
13354 };
13355 template <> struct TagToType<0x0028,0x7018> {
13356 static const char* GetVRString() { return "FL"; }
13357 typedef VRToType<VR::FL>::Type Type;
13358 enum : long long { VRType = VR::FL };
13359 enum { VMType = VM::VM2 };
13360 static const char* GetVMString() { return "2"; }
13361 };
13362 template <> struct TagToType<0x0028,0x7019> {
13363 static const char* GetVRString() { return "CS"; }
13364 typedef VRToType<VR::CS>::Type Type;
13365 enum : long long { VRType = VR::CS };
13366 enum { VMType = VM::VM1 };
13367 static const char* GetVMString() { return "1"; }
13368 };
13369 template <> struct TagToType<0x0028,0x701a> {
13370 static const char* GetVRString() { return "FL"; }
13371 typedef VRToType<VR::FL>::Type Type;
13372 enum : long long { VRType = VR::FL };
13373 enum { VMType = VM::VM1 };
13374 static const char* GetVMString() { return "1"; }
13375 };
13376 template <> struct TagToType<0x0028,0x701b> {
13377 static const char* GetVRString() { return "US"; }
13378 typedef VRToType<VR::US>::Type Type;
13379 enum : long long { VRType = VR::US };
13380 enum { VMType = VM::VM1 };
13381 static const char* GetVMString() { return "1"; }
13382 };
13383 template <> struct TagToType<0x0028,0x701c> {
13384 static const char* GetVRString() { return "SQ"; }
13385 typedef VRToType<VR::SQ>::Type Type;
13386 enum : long long { VRType = VR::SQ };
13387 enum { VMType = VM::VM1 };
13388 static const char* GetVMString() { return "1"; }
13389 };
13390 template <> struct TagToType<0x0028,0x701d> {
13391 static const char* GetVRString() { return "FL"; }
13392 typedef VRToType<VR::FL>::Type Type;
13393 enum : long long { VRType = VR::FL };
13394 enum { VMType = VM::VM1 };
13395 static const char* GetVMString() { return "1"; }
13396 };
13397 template <> struct TagToType<0x0028,0x701e> {
13398 static const char* GetVRString() { return "FL"; }
13399 typedef VRToType<VR::FL>::Type Type;
13400 enum : long long { VRType = VR::FL };
13401 enum { VMType = VM::VM1 };
13402 static const char* GetVMString() { return "1"; }
13403 };
13404 template <> struct TagToType<0x0028,0x701f> {
13405 static const char* GetVRString() { return "FL"; }
13406 typedef VRToType<VR::FL>::Type Type;
13407 enum : long long { VRType = VR::FL };
13408 enum { VMType = VM::VM1 };
13409 static const char* GetVMString() { return "1"; }
13410 };
13411 template <> struct TagToType<0x0028,0x7020> {
13412 static const char* GetVRString() { return "LO"; }
13413 typedef VRToType<VR::LO>::Type Type;
13414 enum : long long { VRType = VR::LO };
13415 enum { VMType = VM::VM1 };
13416 static const char* GetVMString() { return "1"; }
13417 };
13418 template <> struct TagToType<0x0028,0x7021> {
13419 static const char* GetVRString() { return "CS"; }
13420 typedef VRToType<VR::CS>::Type Type;
13421 enum : long long { VRType = VR::CS };
13422 enum { VMType = VM::VM1 };
13423 static const char* GetVMString() { return "1"; }
13424 };
13425 template <> struct TagToType<0x0028,0x7022> {
13426 static const char* GetVRString() { return "SQ"; }
13427 typedef VRToType<VR::SQ>::Type Type;
13428 enum : long long { VRType = VR::SQ };
13429 enum { VMType = VM::VM1 };
13430 static const char* GetVMString() { return "1"; }
13431 };
13432 template <> struct TagToType<0x0028,0x7023> {
13433 static const char* GetVRString() { return "SQ"; }
13434 typedef VRToType<VR::SQ>::Type Type;
13435 enum : long long { VRType = VR::SQ };
13436 enum { VMType = VM::VM1 };
13437 static const char* GetVMString() { return "1"; }
13438 };
13439 template <> struct TagToType<0x0028,0x7024> {
13440 static const char* GetVRString() { return "SQ"; }
13441 typedef VRToType<VR::SQ>::Type Type;
13442 enum : long long { VRType = VR::SQ };
13443 enum { VMType = VM::VM1 };
13444 static const char* GetVMString() { return "1"; }
13445 };
13446 template <> struct TagToType<0x0028,0x7025> {
13447 static const char* GetVRString() { return "CS"; }
13448 typedef VRToType<VR::CS>::Type Type;
13449 enum : long long { VRType = VR::CS };
13450 enum { VMType = VM::VM1 };
13451 static const char* GetVMString() { return "1"; }
13452 };
13453 template <> struct TagToType<0x0028,0x7026> {
13454 static const char* GetVRString() { return "CS"; }
13455 typedef VRToType<VR::CS>::Type Type;
13456 enum : long long { VRType = VR::CS };
13457 enum { VMType = VM::VM1_n };
13458 static const char* GetVMString() { return "1-n"; }
13459 };
13460 template <> struct TagToType<0x0028,0x7027> {
13461 static const char* GetVRString() { return "SQ"; }
13462 typedef VRToType<VR::SQ>::Type Type;
13463 enum : long long { VRType = VR::SQ };
13464 enum { VMType = VM::VM1 };
13465 static const char* GetVMString() { return "1"; }
13466 };
13467 template <> struct TagToType<0x0028,0x7028> {
13468 static const char* GetVRString() { return "SQ"; }
13469 typedef VRToType<VR::SQ>::Type Type;
13470 enum : long long { VRType = VR::SQ };
13471 enum { VMType = VM::VM1 };
13472 static const char* GetVMString() { return "1"; }
13473 };
13474 template <> struct TagToType<0x0028,0x7029> {
13475 static const char* GetVRString() { return "CS"; }
13476 typedef VRToType<VR::CS>::Type Type;
13477 enum : long long { VRType = VR::CS };
13478 enum { VMType = VM::VM1 };
13479 static const char* GetVMString() { return "1"; }
13480 };
13481 template <> struct TagToType<0x0028,0x702a> {
13482 static const char* GetVRString() { return "LO"; }
13483 typedef VRToType<VR::LO>::Type Type;
13484 enum : long long { VRType = VR::LO };
13485 enum { VMType = VM::VM1 };
13486 static const char* GetVMString() { return "1"; }
13487 };
13488 template <> struct TagToType<0x0028,0x702b> {
13489 static const char* GetVRString() { return "CS"; }
13490 typedef VRToType<VR::CS>::Type Type;
13491 enum : long long { VRType = VR::CS };
13492 enum { VMType = VM::VM1 };
13493 static const char* GetVMString() { return "1"; }
13494 };
13495 template <> struct TagToType<0x0028,0x702c> {
13496 static const char* GetVRString() { return "SQ"; }
13497 typedef VRToType<VR::SQ>::Type Type;
13498 enum : long long { VRType = VR::SQ };
13499 enum { VMType = VM::VM1 };
13500 static const char* GetVMString() { return "1"; }
13501 };
13502 template <> struct TagToType<0x0028,0x702d> {
13503 static const char* GetVRString() { return "SQ"; }
13504 typedef VRToType<VR::SQ>::Type Type;
13505 enum : long long { VRType = VR::SQ };
13506 enum { VMType = VM::VM1 };
13507 static const char* GetVMString() { return "1"; }
13508 };
13509 template <> struct TagToType<0x0028,0x702e> {
13510 static const char* GetVRString() { return "SQ"; }
13511 typedef VRToType<VR::SQ>::Type Type;
13512 enum : long long { VRType = VR::SQ };
13513 enum { VMType = VM::VM1 };
13514 static const char* GetVMString() { return "1"; }
13515 };
13516 template <> struct TagToType<0x0028,0x7fe0> {
13517 static const char* GetVRString() { return "UR"; }
13518 typedef VRToType<VR::UR>::Type Type;
13519 enum : long long { VRType = VR::UR };
13520 enum { VMType = VM::VM1 };
13521 static const char* GetVMString() { return "1"; }
13522 };
13523 template <> struct TagToType<0x0028,0x9001> {
13524 static const char* GetVRString() { return "UL"; }
13525 typedef VRToType<VR::UL>::Type Type;
13526 enum : long long { VRType = VR::UL };
13527 enum { VMType = VM::VM1 };
13528 static const char* GetVMString() { return "1"; }
13529 };
13530 template <> struct TagToType<0x0028,0x9002> {
13531 static const char* GetVRString() { return "UL"; }
13532 typedef VRToType<VR::UL>::Type Type;
13533 enum : long long { VRType = VR::UL };
13534 enum { VMType = VM::VM1 };
13535 static const char* GetVMString() { return "1"; }
13536 };
13537 template <> struct TagToType<0x0028,0x9003> {
13538 static const char* GetVRString() { return "CS"; }
13539 typedef VRToType<VR::CS>::Type Type;
13540 enum : long long { VRType = VR::CS };
13541 enum { VMType = VM::VM1 };
13542 static const char* GetVMString() { return "1"; }
13543 };
13544 template <> struct TagToType<0x0028,0x9099> {
13545 static const char* GetVRString() { return "US"; }
13546 typedef VRToType<VR::US>::Type Type;
13547 enum : long long { VRType = VR::US };
13548 enum { VMType = VM::VM1 };
13549 static const char* GetVMString() { return "1"; }
13550 };
13551 template <> struct TagToType<0x0028,0x9108> {
13552 static const char* GetVRString() { return "CS"; }
13553 typedef VRToType<VR::CS>::Type Type;
13554 enum : long long { VRType = VR::CS };
13555 enum { VMType = VM::VM1 };
13556 static const char* GetVMString() { return "1"; }
13557 };
13558 template <> struct TagToType<0x0028,0x9110> {
13559 static const char* GetVRString() { return "SQ"; }
13560 typedef VRToType<VR::SQ>::Type Type;
13561 enum : long long { VRType = VR::SQ };
13562 enum { VMType = VM::VM1 };
13563 static const char* GetVMString() { return "1"; }
13564 };
13565 template <> struct TagToType<0x0028,0x9132> {
13566 static const char* GetVRString() { return "SQ"; }
13567 typedef VRToType<VR::SQ>::Type Type;
13568 enum : long long { VRType = VR::SQ };
13569 enum { VMType = VM::VM1 };
13570 static const char* GetVMString() { return "1"; }
13571 };
13572 template <> struct TagToType<0x0028,0x9145> {
13573 static const char* GetVRString() { return "SQ"; }
13574 typedef VRToType<VR::SQ>::Type Type;
13575 enum : long long { VRType = VR::SQ };
13576 enum { VMType = VM::VM1 };
13577 static const char* GetVMString() { return "1"; }
13578 };
13579 template <> struct TagToType<0x0028,0x9235> {
13580 static const char* GetVRString() { return "CS"; }
13581 typedef VRToType<VR::CS>::Type Type;
13582 enum : long long { VRType = VR::CS };
13583 enum { VMType = VM::VM1 };
13584 static const char* GetVMString() { return "1"; }
13585 };
13586 template <> struct TagToType<0x0028,0x9411> {
13587 static const char* GetVRString() { return "FL"; }
13588 typedef VRToType<VR::FL>::Type Type;
13589 enum : long long { VRType = VR::FL };
13590 enum { VMType = VM::VM1 };
13591 static const char* GetVMString() { return "1"; }
13592 };
13593 template <> struct TagToType<0x0028,0x9415> {
13594 static const char* GetVRString() { return "SQ"; }
13595 typedef VRToType<VR::SQ>::Type Type;
13596 enum : long long { VRType = VR::SQ };
13597 enum { VMType = VM::VM1 };
13598 static const char* GetVMString() { return "1"; }
13599 };
13600 template <> struct TagToType<0x0028,0x9416> {
13601 static const char* GetVRString() { return "US"; }
13602 typedef VRToType<VR::US>::Type Type;
13603 enum : long long { VRType = VR::US };
13604 enum { VMType = VM::VM1 };
13605 static const char* GetVMString() { return "1"; }
13606 };
13607 template <> struct TagToType<0x0028,0x9422> {
13608 static const char* GetVRString() { return "SQ"; }
13609 typedef VRToType<VR::SQ>::Type Type;
13610 enum : long long { VRType = VR::SQ };
13611 enum { VMType = VM::VM1 };
13612 static const char* GetVMString() { return "1"; }
13613 };
13614 template <> struct TagToType<0x0028,0x9443> {
13615 static const char* GetVRString() { return "SQ"; }
13616 typedef VRToType<VR::SQ>::Type Type;
13617 enum : long long { VRType = VR::SQ };
13618 enum { VMType = VM::VM1 };
13619 static const char* GetVMString() { return "1"; }
13620 };
13621 template <> struct TagToType<0x0028,0x9444> {
13622 static const char* GetVRString() { return "CS"; }
13623 typedef VRToType<VR::CS>::Type Type;
13624 enum : long long { VRType = VR::CS };
13625 enum { VMType = VM::VM1 };
13626 static const char* GetVMString() { return "1"; }
13627 };
13628 template <> struct TagToType<0x0028,0x9445> {
13629 static const char* GetVRString() { return "FL"; }
13630 typedef VRToType<VR::FL>::Type Type;
13631 enum : long long { VRType = VR::FL };
13632 enum { VMType = VM::VM1 };
13633 static const char* GetVMString() { return "1"; }
13634 };
13635 template <> struct TagToType<0x0028,0x9446> {
13636 static const char* GetVRString() { return "CS"; }
13637 typedef VRToType<VR::CS>::Type Type;
13638 enum : long long { VRType = VR::CS };
13639 enum { VMType = VM::VM1_n };
13640 static const char* GetVMString() { return "1-n"; }
13641 };
13642 template <> struct TagToType<0x0028,0x9454> {
13643 static const char* GetVRString() { return "CS"; }
13644 typedef VRToType<VR::CS>::Type Type;
13645 enum : long long { VRType = VR::CS };
13646 enum { VMType = VM::VM1 };
13647 static const char* GetVMString() { return "1"; }
13648 };
13649 template <> struct TagToType<0x0028,0x9474> {
13650 static const char* GetVRString() { return "CS"; }
13651 typedef VRToType<VR::CS>::Type Type;
13652 enum : long long { VRType = VR::CS };
13653 enum { VMType = VM::VM1 };
13654 static const char* GetVMString() { return "1"; }
13655 };
13656 template <> struct TagToType<0x0028,0x9478> {
13657 static const char* GetVRString() { return "FL"; }
13658 typedef VRToType<VR::FL>::Type Type;
13659 enum : long long { VRType = VR::FL };
13660 enum { VMType = VM::VM1 };
13661 static const char* GetVMString() { return "1"; }
13662 };
13663 template <> struct TagToType<0x0028,0x9501> {
13664 static const char* GetVRString() { return "SQ"; }
13665 typedef VRToType<VR::SQ>::Type Type;
13666 enum : long long { VRType = VR::SQ };
13667 enum { VMType = VM::VM1 };
13668 static const char* GetVMString() { return "1"; }
13669 };
13670 template <> struct TagToType<0x0028,0x9502> {
13671 static const char* GetVRString() { return "SQ"; }
13672 typedef VRToType<VR::SQ>::Type Type;
13673 enum : long long { VRType = VR::SQ };
13674 enum { VMType = VM::VM1 };
13675 static const char* GetVMString() { return "1"; }
13676 };
13677 template <> struct TagToType<0x0028,0x9503> {
13678 static const char* GetVRString() { return "SS"; }
13679 typedef VRToType<VR::SS>::Type Type;
13680 enum : long long { VRType = VR::SS };
13681 enum { VMType = VM::VM2_2n };
13682 static const char* GetVMString() { return "2-2n"; }
13683 };
13684 template <> struct TagToType<0x0028,0x9505> {
13685 static const char* GetVRString() { return "SQ"; }
13686 typedef VRToType<VR::SQ>::Type Type;
13687 enum : long long { VRType = VR::SQ };
13688 enum { VMType = VM::VM1 };
13689 static const char* GetVMString() { return "1"; }
13690 };
13691 template <> struct TagToType<0x0028,0x9506> {
13692 static const char* GetVRString() { return "US"; }
13693 typedef VRToType<VR::US>::Type Type;
13694 enum : long long { VRType = VR::US };
13695 enum { VMType = VM::VM2_2n };
13696 static const char* GetVMString() { return "2-2n"; }
13697 };
13698 template <> struct TagToType<0x0028,0x9507> {
13699 static const char* GetVRString() { return "US"; }
13700 typedef VRToType<VR::US>::Type Type;
13701 enum : long long { VRType = VR::US };
13702 enum { VMType = VM::VM2_2n };
13703 static const char* GetVMString() { return "2-2n"; }
13704 };
13705 template <> struct TagToType<0x0028,0x9520> {
13706 static const char* GetVRString() { return "DS"; }
13707 typedef VRToType<VR::DS>::Type Type;
13708 enum : long long { VRType = VR::DS };
13709 enum { VMType = VM::VM16 };
13710 static const char* GetVMString() { return "16"; }
13711 };
13712 template <> struct TagToType<0x0028,0x9537> {
13713 static const char* GetVRString() { return "CS"; }
13714 typedef VRToType<VR::CS>::Type Type;
13715 enum : long long { VRType = VR::CS };
13716 enum { VMType = VM::VM1 };
13717 static const char* GetVMString() { return "1"; }
13718 };
13719 template <> struct TagToType<0x0032,0x000a> {
13720 static const char* GetVRString() { return "CS"; }
13721 typedef VRToType<VR::CS>::Type Type;
13722 enum : long long { VRType = VR::CS };
13723 enum { VMType = VM::VM1 };
13724 static const char* GetVMString() { return "1"; }
13725 };
13726 template <> struct TagToType<0x0032,0x000c> {
13727 static const char* GetVRString() { return "CS"; }
13728 typedef VRToType<VR::CS>::Type Type;
13729 enum : long long { VRType = VR::CS };
13730 enum { VMType = VM::VM1 };
13731 static const char* GetVMString() { return "1"; }
13732 };
13733 template <> struct TagToType<0x0032,0x0012> {
13734 static const char* GetVRString() { return "LO"; }
13735 typedef VRToType<VR::LO>::Type Type;
13736 enum : long long { VRType = VR::LO };
13737 enum { VMType = VM::VM1 };
13738 static const char* GetVMString() { return "1"; }
13739 };
13740 template <> struct TagToType<0x0032,0x0032> {
13741 static const char* GetVRString() { return "DA"; }
13742 typedef VRToType<VR::DA>::Type Type;
13743 enum : long long { VRType = VR::DA };
13744 enum { VMType = VM::VM1 };
13745 static const char* GetVMString() { return "1"; }
13746 };
13747 template <> struct TagToType<0x0032,0x0033> {
13748 static const char* GetVRString() { return "TM"; }
13749 typedef VRToType<VR::TM>::Type Type;
13750 enum : long long { VRType = VR::TM };
13751 enum { VMType = VM::VM1 };
13752 static const char* GetVMString() { return "1"; }
13753 };
13754 template <> struct TagToType<0x0032,0x0034> {
13755 static const char* GetVRString() { return "DA"; }
13756 typedef VRToType<VR::DA>::Type Type;
13757 enum : long long { VRType = VR::DA };
13758 enum { VMType = VM::VM1 };
13759 static const char* GetVMString() { return "1"; }
13760 };
13761 template <> struct TagToType<0x0032,0x0035> {
13762 static const char* GetVRString() { return "TM"; }
13763 typedef VRToType<VR::TM>::Type Type;
13764 enum : long long { VRType = VR::TM };
13765 enum { VMType = VM::VM1 };
13766 static const char* GetVMString() { return "1"; }
13767 };
13768 template <> struct TagToType<0x0032,0x1000> {
13769 static const char* GetVRString() { return "DA"; }
13770 typedef VRToType<VR::DA>::Type Type;
13771 enum : long long { VRType = VR::DA };
13772 enum { VMType = VM::VM1 };
13773 static const char* GetVMString() { return "1"; }
13774 };
13775 template <> struct TagToType<0x0032,0x1001> {
13776 static const char* GetVRString() { return "TM"; }
13777 typedef VRToType<VR::TM>::Type Type;
13778 enum : long long { VRType = VR::TM };
13779 enum { VMType = VM::VM1 };
13780 static const char* GetVMString() { return "1"; }
13781 };
13782 template <> struct TagToType<0x0032,0x1010> {
13783 static const char* GetVRString() { return "DA"; }
13784 typedef VRToType<VR::DA>::Type Type;
13785 enum : long long { VRType = VR::DA };
13786 enum { VMType = VM::VM1 };
13787 static const char* GetVMString() { return "1"; }
13788 };
13789 template <> struct TagToType<0x0032,0x1011> {
13790 static const char* GetVRString() { return "TM"; }
13791 typedef VRToType<VR::TM>::Type Type;
13792 enum : long long { VRType = VR::TM };
13793 enum { VMType = VM::VM1 };
13794 static const char* GetVMString() { return "1"; }
13795 };
13796 template <> struct TagToType<0x0032,0x1020> {
13797 static const char* GetVRString() { return "LO"; }
13798 typedef VRToType<VR::LO>::Type Type;
13799 enum : long long { VRType = VR::LO };
13800 enum { VMType = VM::VM1 };
13801 static const char* GetVMString() { return "1"; }
13802 };
13803 template <> struct TagToType<0x0032,0x1021> {
13804 static const char* GetVRString() { return "AE"; }
13805 typedef VRToType<VR::AE>::Type Type;
13806 enum : long long { VRType = VR::AE };
13807 enum { VMType = VM::VM1_n };
13808 static const char* GetVMString() { return "1-n"; }
13809 };
13810 template <> struct TagToType<0x0032,0x1030> {
13811 static const char* GetVRString() { return "LO"; }
13812 typedef VRToType<VR::LO>::Type Type;
13813 enum : long long { VRType = VR::LO };
13814 enum { VMType = VM::VM1 };
13815 static const char* GetVMString() { return "1"; }
13816 };
13817 template <> struct TagToType<0x0032,0x1031> {
13818 static const char* GetVRString() { return "SQ"; }
13819 typedef VRToType<VR::SQ>::Type Type;
13820 enum : long long { VRType = VR::SQ };
13821 enum { VMType = VM::VM1 };
13822 static const char* GetVMString() { return "1"; }
13823 };
13824 template <> struct TagToType<0x0032,0x1032> {
13825 static const char* GetVRString() { return "PN"; }
13826 typedef VRToType<VR::PN>::Type Type;
13827 enum : long long { VRType = VR::PN };
13828 enum { VMType = VM::VM1 };
13829 static const char* GetVMString() { return "1"; }
13830 };
13831 template <> struct TagToType<0x0032,0x1033> {
13832 static const char* GetVRString() { return "LO"; }
13833 typedef VRToType<VR::LO>::Type Type;
13834 enum : long long { VRType = VR::LO };
13835 enum { VMType = VM::VM1 };
13836 static const char* GetVMString() { return "1"; }
13837 };
13838 template <> struct TagToType<0x0032,0x1034> {
13839 static const char* GetVRString() { return "SQ"; }
13840 typedef VRToType<VR::SQ>::Type Type;
13841 enum : long long { VRType = VR::SQ };
13842 enum { VMType = VM::VM1 };
13843 static const char* GetVMString() { return "1"; }
13844 };
13845 template <> struct TagToType<0x0032,0x1040> {
13846 static const char* GetVRString() { return "DA"; }
13847 typedef VRToType<VR::DA>::Type Type;
13848 enum : long long { VRType = VR::DA };
13849 enum { VMType = VM::VM1 };
13850 static const char* GetVMString() { return "1"; }
13851 };
13852 template <> struct TagToType<0x0032,0x1041> {
13853 static const char* GetVRString() { return "TM"; }
13854 typedef VRToType<VR::TM>::Type Type;
13855 enum : long long { VRType = VR::TM };
13856 enum { VMType = VM::VM1 };
13857 static const char* GetVMString() { return "1"; }
13858 };
13859 template <> struct TagToType<0x0032,0x1050> {
13860 static const char* GetVRString() { return "DA"; }
13861 typedef VRToType<VR::DA>::Type Type;
13862 enum : long long { VRType = VR::DA };
13863 enum { VMType = VM::VM1 };
13864 static const char* GetVMString() { return "1"; }
13865 };
13866 template <> struct TagToType<0x0032,0x1051> {
13867 static const char* GetVRString() { return "TM"; }
13868 typedef VRToType<VR::TM>::Type Type;
13869 enum : long long { VRType = VR::TM };
13870 enum { VMType = VM::VM1 };
13871 static const char* GetVMString() { return "1"; }
13872 };
13873 template <> struct TagToType<0x0032,0x1055> {
13874 static const char* GetVRString() { return "CS"; }
13875 typedef VRToType<VR::CS>::Type Type;
13876 enum : long long { VRType = VR::CS };
13877 enum { VMType = VM::VM1 };
13878 static const char* GetVMString() { return "1"; }
13879 };
13880 template <> struct TagToType<0x0032,0x1060> {
13881 static const char* GetVRString() { return "LO"; }
13882 typedef VRToType<VR::LO>::Type Type;
13883 enum : long long { VRType = VR::LO };
13884 enum { VMType = VM::VM1 };
13885 static const char* GetVMString() { return "1"; }
13886 };
13887 template <> struct TagToType<0x0032,0x1064> {
13888 static const char* GetVRString() { return "SQ"; }
13889 typedef VRToType<VR::SQ>::Type Type;
13890 enum : long long { VRType = VR::SQ };
13891 enum { VMType = VM::VM1 };
13892 static const char* GetVMString() { return "1"; }
13893 };
13894 template <> struct TagToType<0x0032,0x1070> {
13895 static const char* GetVRString() { return "LO"; }
13896 typedef VRToType<VR::LO>::Type Type;
13897 enum : long long { VRType = VR::LO };
13898 enum { VMType = VM::VM1 };
13899 static const char* GetVMString() { return "1"; }
13900 };
13901 template <> struct TagToType<0x0032,0x4000> {
13902 static const char* GetVRString() { return "LT"; }
13903 typedef VRToType<VR::LT>::Type Type;
13904 enum : long long { VRType = VR::LT };
13905 enum { VMType = VM::VM1 };
13906 static const char* GetVMString() { return "1"; }
13907 };
13908 template <> struct TagToType<0x0038,0x0004> {
13909 static const char* GetVRString() { return "SQ"; }
13910 typedef VRToType<VR::SQ>::Type Type;
13911 enum : long long { VRType = VR::SQ };
13912 enum { VMType = VM::VM1 };
13913 static const char* GetVMString() { return "1"; }
13914 };
13915 template <> struct TagToType<0x0038,0x0008> {
13916 static const char* GetVRString() { return "CS"; }
13917 typedef VRToType<VR::CS>::Type Type;
13918 enum : long long { VRType = VR::CS };
13919 enum { VMType = VM::VM1 };
13920 static const char* GetVMString() { return "1"; }
13921 };
13922 template <> struct TagToType<0x0038,0x0010> {
13923 static const char* GetVRString() { return "LO"; }
13924 typedef VRToType<VR::LO>::Type Type;
13925 enum : long long { VRType = VR::LO };
13926 enum { VMType = VM::VM1 };
13927 static const char* GetVMString() { return "1"; }
13928 };
13929 template <> struct TagToType<0x0038,0x0011> {
13930 static const char* GetVRString() { return "LO"; }
13931 typedef VRToType<VR::LO>::Type Type;
13932 enum : long long { VRType = VR::LO };
13933 enum { VMType = VM::VM1 };
13934 static const char* GetVMString() { return "1"; }
13935 };
13936 template <> struct TagToType<0x0038,0x0014> {
13937 static const char* GetVRString() { return "SQ"; }
13938 typedef VRToType<VR::SQ>::Type Type;
13939 enum : long long { VRType = VR::SQ };
13940 enum { VMType = VM::VM1 };
13941 static const char* GetVMString() { return "1"; }
13942 };
13943 template <> struct TagToType<0x0038,0x0016> {
13944 static const char* GetVRString() { return "LO"; }
13945 typedef VRToType<VR::LO>::Type Type;
13946 enum : long long { VRType = VR::LO };
13947 enum { VMType = VM::VM1 };
13948 static const char* GetVMString() { return "1"; }
13949 };
13950 template <> struct TagToType<0x0038,0x001a> {
13951 static const char* GetVRString() { return "DA"; }
13952 typedef VRToType<VR::DA>::Type Type;
13953 enum : long long { VRType = VR::DA };
13954 enum { VMType = VM::VM1 };
13955 static const char* GetVMString() { return "1"; }
13956 };
13957 template <> struct TagToType<0x0038,0x001b> {
13958 static const char* GetVRString() { return "TM"; }
13959 typedef VRToType<VR::TM>::Type Type;
13960 enum : long long { VRType = VR::TM };
13961 enum { VMType = VM::VM1 };
13962 static const char* GetVMString() { return "1"; }
13963 };
13964 template <> struct TagToType<0x0038,0x001c> {
13965 static const char* GetVRString() { return "DA"; }
13966 typedef VRToType<VR::DA>::Type Type;
13967 enum : long long { VRType = VR::DA };
13968 enum { VMType = VM::VM1 };
13969 static const char* GetVMString() { return "1"; }
13970 };
13971 template <> struct TagToType<0x0038,0x001d> {
13972 static const char* GetVRString() { return "TM"; }
13973 typedef VRToType<VR::TM>::Type Type;
13974 enum : long long { VRType = VR::TM };
13975 enum { VMType = VM::VM1 };
13976 static const char* GetVMString() { return "1"; }
13977 };
13978 template <> struct TagToType<0x0038,0x001e> {
13979 static const char* GetVRString() { return "LO"; }
13980 typedef VRToType<VR::LO>::Type Type;
13981 enum : long long { VRType = VR::LO };
13982 enum { VMType = VM::VM1 };
13983 static const char* GetVMString() { return "1"; }
13984 };
13985 template <> struct TagToType<0x0038,0x0020> {
13986 static const char* GetVRString() { return "DA"; }
13987 typedef VRToType<VR::DA>::Type Type;
13988 enum : long long { VRType = VR::DA };
13989 enum { VMType = VM::VM1 };
13990 static const char* GetVMString() { return "1"; }
13991 };
13992 template <> struct TagToType<0x0038,0x0021> {
13993 static const char* GetVRString() { return "TM"; }
13994 typedef VRToType<VR::TM>::Type Type;
13995 enum : long long { VRType = VR::TM };
13996 enum { VMType = VM::VM1 };
13997 static const char* GetVMString() { return "1"; }
13998 };
13999 template <> struct TagToType<0x0038,0x0030> {
14000 static const char* GetVRString() { return "DA"; }
14001 typedef VRToType<VR::DA>::Type Type;
14002 enum : long long { VRType = VR::DA };
14003 enum { VMType = VM::VM1 };
14004 static const char* GetVMString() { return "1"; }
14005 };
14006 template <> struct TagToType<0x0038,0x0032> {
14007 static const char* GetVRString() { return "TM"; }
14008 typedef VRToType<VR::TM>::Type Type;
14009 enum : long long { VRType = VR::TM };
14010 enum { VMType = VM::VM1 };
14011 static const char* GetVMString() { return "1"; }
14012 };
14013 template <> struct TagToType<0x0038,0x0040> {
14014 static const char* GetVRString() { return "LO"; }
14015 typedef VRToType<VR::LO>::Type Type;
14016 enum : long long { VRType = VR::LO };
14017 enum { VMType = VM::VM1 };
14018 static const char* GetVMString() { return "1"; }
14019 };
14020 template <> struct TagToType<0x0038,0x0044> {
14021 static const char* GetVRString() { return "SQ"; }
14022 typedef VRToType<VR::SQ>::Type Type;
14023 enum : long long { VRType = VR::SQ };
14024 enum { VMType = VM::VM1 };
14025 static const char* GetVMString() { return "1"; }
14026 };
14027 template <> struct TagToType<0x0038,0x0050> {
14028 static const char* GetVRString() { return "LO"; }
14029 typedef VRToType<VR::LO>::Type Type;
14030 enum : long long { VRType = VR::LO };
14031 enum { VMType = VM::VM1 };
14032 static const char* GetVMString() { return "1"; }
14033 };
14034 template <> struct TagToType<0x0038,0x0060> {
14035 static const char* GetVRString() { return "LO"; }
14036 typedef VRToType<VR::LO>::Type Type;
14037 enum : long long { VRType = VR::LO };
14038 enum { VMType = VM::VM1 };
14039 static const char* GetVMString() { return "1"; }
14040 };
14041 template <> struct TagToType<0x0038,0x0061> {
14042 static const char* GetVRString() { return "LO"; }
14043 typedef VRToType<VR::LO>::Type Type;
14044 enum : long long { VRType = VR::LO };
14045 enum { VMType = VM::VM1 };
14046 static const char* GetVMString() { return "1"; }
14047 };
14048 template <> struct TagToType<0x0038,0x0062> {
14049 static const char* GetVRString() { return "LO"; }
14050 typedef VRToType<VR::LO>::Type Type;
14051 enum : long long { VRType = VR::LO };
14052 enum { VMType = VM::VM1 };
14053 static const char* GetVMString() { return "1"; }
14054 };
14055 template <> struct TagToType<0x0038,0x0064> {
14056 static const char* GetVRString() { return "SQ"; }
14057 typedef VRToType<VR::SQ>::Type Type;
14058 enum : long long { VRType = VR::SQ };
14059 enum { VMType = VM::VM1 };
14060 static const char* GetVMString() { return "1"; }
14061 };
14062 template <> struct TagToType<0x0038,0x0100> {
14063 static const char* GetVRString() { return "SQ"; }
14064 typedef VRToType<VR::SQ>::Type Type;
14065 enum : long long { VRType = VR::SQ };
14066 enum { VMType = VM::VM1 };
14067 static const char* GetVMString() { return "1"; }
14068 };
14069 template <> struct TagToType<0x0038,0x0101> {
14070 static const char* GetVRString() { return "SQ"; }
14071 typedef VRToType<VR::SQ>::Type Type;
14072 enum : long long { VRType = VR::SQ };
14073 enum { VMType = VM::VM1 };
14074 static const char* GetVMString() { return "1"; }
14075 };
14076 template <> struct TagToType<0x0038,0x0102> {
14077 static const char* GetVRString() { return "LO"; }
14078 typedef VRToType<VR::LO>::Type Type;
14079 enum : long long { VRType = VR::LO };
14080 enum { VMType = VM::VM1 };
14081 static const char* GetVMString() { return "1"; }
14082 };
14083 template <> struct TagToType<0x0038,0x0300> {
14084 static const char* GetVRString() { return "LO"; }
14085 typedef VRToType<VR::LO>::Type Type;
14086 enum : long long { VRType = VR::LO };
14087 enum { VMType = VM::VM1 };
14088 static const char* GetVMString() { return "1"; }
14089 };
14090 template <> struct TagToType<0x0038,0x0400> {
14091 static const char* GetVRString() { return "LO"; }
14092 typedef VRToType<VR::LO>::Type Type;
14093 enum : long long { VRType = VR::LO };
14094 enum { VMType = VM::VM1 };
14095 static const char* GetVMString() { return "1"; }
14096 };
14097 template <> struct TagToType<0x0038,0x0500> {
14098 static const char* GetVRString() { return "LO"; }
14099 typedef VRToType<VR::LO>::Type Type;
14100 enum : long long { VRType = VR::LO };
14101 enum { VMType = VM::VM1 };
14102 static const char* GetVMString() { return "1"; }
14103 };
14104 template <> struct TagToType<0x0038,0x0502> {
14105 static const char* GetVRString() { return "SQ"; }
14106 typedef VRToType<VR::SQ>::Type Type;
14107 enum : long long { VRType = VR::SQ };
14108 enum { VMType = VM::VM1 };
14109 static const char* GetVMString() { return "1"; }
14110 };
14111 template <> struct TagToType<0x0038,0x4000> {
14112 static const char* GetVRString() { return "LT"; }
14113 typedef VRToType<VR::LT>::Type Type;
14114 enum : long long { VRType = VR::LT };
14115 enum { VMType = VM::VM1 };
14116 static const char* GetVMString() { return "1"; }
14117 };
14118 template <> struct TagToType<0x003a,0x0004> {
14119 static const char* GetVRString() { return "CS"; }
14120 typedef VRToType<VR::CS>::Type Type;
14121 enum : long long { VRType = VR::CS };
14122 enum { VMType = VM::VM1 };
14123 static const char* GetVMString() { return "1"; }
14124 };
14125 template <> struct TagToType<0x003a,0x0005> {
14126 static const char* GetVRString() { return "US"; }
14127 typedef VRToType<VR::US>::Type Type;
14128 enum : long long { VRType = VR::US };
14129 enum { VMType = VM::VM1 };
14130 static const char* GetVMString() { return "1"; }
14131 };
14132 template <> struct TagToType<0x003a,0x0010> {
14133 static const char* GetVRString() { return "UL"; }
14134 typedef VRToType<VR::UL>::Type Type;
14135 enum : long long { VRType = VR::UL };
14136 enum { VMType = VM::VM1 };
14137 static const char* GetVMString() { return "1"; }
14138 };
14139 template <> struct TagToType<0x003a,0x001a> {
14140 static const char* GetVRString() { return "DS"; }
14141 typedef VRToType<VR::DS>::Type Type;
14142 enum : long long { VRType = VR::DS };
14143 enum { VMType = VM::VM1 };
14144 static const char* GetVMString() { return "1"; }
14145 };
14146 template <> struct TagToType<0x003a,0x0020> {
14147 static const char* GetVRString() { return "SH"; }
14148 typedef VRToType<VR::SH>::Type Type;
14149 enum : long long { VRType = VR::SH };
14150 enum { VMType = VM::VM1 };
14151 static const char* GetVMString() { return "1"; }
14152 };
14153 template <> struct TagToType<0x003a,0x0200> {
14154 static const char* GetVRString() { return "SQ"; }
14155 typedef VRToType<VR::SQ>::Type Type;
14156 enum : long long { VRType = VR::SQ };
14157 enum { VMType = VM::VM1 };
14158 static const char* GetVMString() { return "1"; }
14159 };
14160 template <> struct TagToType<0x003a,0x0202> {
14161 static const char* GetVRString() { return "IS"; }
14162 typedef VRToType<VR::IS>::Type Type;
14163 enum : long long { VRType = VR::IS };
14164 enum { VMType = VM::VM1 };
14165 static const char* GetVMString() { return "1"; }
14166 };
14167 template <> struct TagToType<0x003a,0x0203> {
14168 static const char* GetVRString() { return "SH"; }
14169 typedef VRToType<VR::SH>::Type Type;
14170 enum : long long { VRType = VR::SH };
14171 enum { VMType = VM::VM1 };
14172 static const char* GetVMString() { return "1"; }
14173 };
14174 template <> struct TagToType<0x003a,0x0205> {
14175 static const char* GetVRString() { return "CS"; }
14176 typedef VRToType<VR::CS>::Type Type;
14177 enum : long long { VRType = VR::CS };
14178 enum { VMType = VM::VM1_n };
14179 static const char* GetVMString() { return "1-n"; }
14180 };
14181 template <> struct TagToType<0x003a,0x0208> {
14182 static const char* GetVRString() { return "SQ"; }
14183 typedef VRToType<VR::SQ>::Type Type;
14184 enum : long long { VRType = VR::SQ };
14185 enum { VMType = VM::VM1 };
14186 static const char* GetVMString() { return "1"; }
14187 };
14188 template <> struct TagToType<0x003a,0x0209> {
14189 static const char* GetVRString() { return "SQ"; }
14190 typedef VRToType<VR::SQ>::Type Type;
14191 enum : long long { VRType = VR::SQ };
14192 enum { VMType = VM::VM1 };
14193 static const char* GetVMString() { return "1"; }
14194 };
14195 template <> struct TagToType<0x003a,0x020a> {
14196 static const char* GetVRString() { return "SQ"; }
14197 typedef VRToType<VR::SQ>::Type Type;
14198 enum : long long { VRType = VR::SQ };
14199 enum { VMType = VM::VM1 };
14200 static const char* GetVMString() { return "1"; }
14201 };
14202 template <> struct TagToType<0x003a,0x020c> {
14203 static const char* GetVRString() { return "LO"; }
14204 typedef VRToType<VR::LO>::Type Type;
14205 enum : long long { VRType = VR::LO };
14206 enum { VMType = VM::VM1 };
14207 static const char* GetVMString() { return "1"; }
14208 };
14209 template <> struct TagToType<0x003a,0x0210> {
14210 static const char* GetVRString() { return "DS"; }
14211 typedef VRToType<VR::DS>::Type Type;
14212 enum : long long { VRType = VR::DS };
14213 enum { VMType = VM::VM1 };
14214 static const char* GetVMString() { return "1"; }
14215 };
14216 template <> struct TagToType<0x003a,0x0211> {
14217 static const char* GetVRString() { return "SQ"; }
14218 typedef VRToType<VR::SQ>::Type Type;
14219 enum : long long { VRType = VR::SQ };
14220 enum { VMType = VM::VM1 };
14221 static const char* GetVMString() { return "1"; }
14222 };
14223 template <> struct TagToType<0x003a,0x0212> {
14224 static const char* GetVRString() { return "DS"; }
14225 typedef VRToType<VR::DS>::Type Type;
14226 enum : long long { VRType = VR::DS };
14227 enum { VMType = VM::VM1 };
14228 static const char* GetVMString() { return "1"; }
14229 };
14230 template <> struct TagToType<0x003a,0x0213> {
14231 static const char* GetVRString() { return "DS"; }
14232 typedef VRToType<VR::DS>::Type Type;
14233 enum : long long { VRType = VR::DS };
14234 enum { VMType = VM::VM1 };
14235 static const char* GetVMString() { return "1"; }
14236 };
14237 template <> struct TagToType<0x003a,0x0214> {
14238 static const char* GetVRString() { return "DS"; }
14239 typedef VRToType<VR::DS>::Type Type;
14240 enum : long long { VRType = VR::DS };
14241 enum { VMType = VM::VM1 };
14242 static const char* GetVMString() { return "1"; }
14243 };
14244 template <> struct TagToType<0x003a,0x0215> {
14245 static const char* GetVRString() { return "DS"; }
14246 typedef VRToType<VR::DS>::Type Type;
14247 enum : long long { VRType = VR::DS };
14248 enum { VMType = VM::VM1 };
14249 static const char* GetVMString() { return "1"; }
14250 };
14251 template <> struct TagToType<0x003a,0x0218> {
14252 static const char* GetVRString() { return "DS"; }
14253 typedef VRToType<VR::DS>::Type Type;
14254 enum : long long { VRType = VR::DS };
14255 enum { VMType = VM::VM1 };
14256 static const char* GetVMString() { return "1"; }
14257 };
14258 template <> struct TagToType<0x003a,0x021a> {
14259 static const char* GetVRString() { return "US"; }
14260 typedef VRToType<VR::US>::Type Type;
14261 enum : long long { VRType = VR::US };
14262 enum { VMType = VM::VM1 };
14263 static const char* GetVMString() { return "1"; }
14264 };
14265 template <> struct TagToType<0x003a,0x0220> {
14266 static const char* GetVRString() { return "DS"; }
14267 typedef VRToType<VR::DS>::Type Type;
14268 enum : long long { VRType = VR::DS };
14269 enum { VMType = VM::VM1 };
14270 static const char* GetVMString() { return "1"; }
14271 };
14272 template <> struct TagToType<0x003a,0x0221> {
14273 static const char* GetVRString() { return "DS"; }
14274 typedef VRToType<VR::DS>::Type Type;
14275 enum : long long { VRType = VR::DS };
14276 enum { VMType = VM::VM1 };
14277 static const char* GetVMString() { return "1"; }
14278 };
14279 template <> struct TagToType<0x003a,0x0222> {
14280 static const char* GetVRString() { return "DS"; }
14281 typedef VRToType<VR::DS>::Type Type;
14282 enum : long long { VRType = VR::DS };
14283 enum { VMType = VM::VM1 };
14284 static const char* GetVMString() { return "1"; }
14285 };
14286 template <> struct TagToType<0x003a,0x0223> {
14287 static const char* GetVRString() { return "DS"; }
14288 typedef VRToType<VR::DS>::Type Type;
14289 enum : long long { VRType = VR::DS };
14290 enum { VMType = VM::VM1 };
14291 static const char* GetVMString() { return "1"; }
14292 };
14293 template <> struct TagToType<0x003a,0x0230> {
14294 static const char* GetVRString() { return "FL"; }
14295 typedef VRToType<VR::FL>::Type Type;
14296 enum : long long { VRType = VR::FL };
14297 enum { VMType = VM::VM1 };
14298 static const char* GetVMString() { return "1"; }
14299 };
14300 template <> struct TagToType<0x003a,0x0231> {
14301 static const char* GetVRString() { return "US"; }
14302 typedef VRToType<VR::US>::Type Type;
14303 enum : long long { VRType = VR::US };
14304 enum { VMType = VM::VM3 };
14305 static const char* GetVMString() { return "3"; }
14306 };
14307 template <> struct TagToType<0x003a,0x0240> {
14308 static const char* GetVRString() { return "SQ"; }
14309 typedef VRToType<VR::SQ>::Type Type;
14310 enum : long long { VRType = VR::SQ };
14311 enum { VMType = VM::VM1 };
14312 static const char* GetVMString() { return "1"; }
14313 };
14314 template <> struct TagToType<0x003a,0x0241> {
14315 static const char* GetVRString() { return "US"; }
14316 typedef VRToType<VR::US>::Type Type;
14317 enum : long long { VRType = VR::US };
14318 enum { VMType = VM::VM1 };
14319 static const char* GetVMString() { return "1"; }
14320 };
14321 template <> struct TagToType<0x003a,0x0242> {
14322 static const char* GetVRString() { return "SQ"; }
14323 typedef VRToType<VR::SQ>::Type Type;
14324 enum : long long { VRType = VR::SQ };
14325 enum { VMType = VM::VM1 };
14326 static const char* GetVMString() { return "1"; }
14327 };
14328 template <> struct TagToType<0x003a,0x0244> {
14329 static const char* GetVRString() { return "US"; }
14330 typedef VRToType<VR::US>::Type Type;
14331 enum : long long { VRType = VR::US };
14332 enum { VMType = VM::VM3 };
14333 static const char* GetVMString() { return "3"; }
14334 };
14335 template <> struct TagToType<0x003a,0x0245> {
14336 static const char* GetVRString() { return "FL"; }
14337 typedef VRToType<VR::FL>::Type Type;
14338 enum : long long { VRType = VR::FL };
14339 enum { VMType = VM::VM1 };
14340 static const char* GetVMString() { return "1"; }
14341 };
14342 template <> struct TagToType<0x003a,0x0246> {
14343 static const char* GetVRString() { return "CS"; }
14344 typedef VRToType<VR::CS>::Type Type;
14345 enum : long long { VRType = VR::CS };
14346 enum { VMType = VM::VM1 };
14347 static const char* GetVMString() { return "1"; }
14348 };
14349 template <> struct TagToType<0x003a,0x0247> {
14350 static const char* GetVRString() { return "FL"; }
14351 typedef VRToType<VR::FL>::Type Type;
14352 enum : long long { VRType = VR::FL };
14353 enum { VMType = VM::VM1 };
14354 static const char* GetVMString() { return "1"; }
14355 };
14356 template <> struct TagToType<0x003a,0x0248> {
14357 static const char* GetVRString() { return "FL"; }
14358 typedef VRToType<VR::FL>::Type Type;
14359 enum : long long { VRType = VR::FL };
14360 enum { VMType = VM::VM1 };
14361 static const char* GetVMString() { return "1"; }
14362 };
14363 template <> struct TagToType<0x003a,0x0300> {
14364 static const char* GetVRString() { return "SQ"; }
14365 typedef VRToType<VR::SQ>::Type Type;
14366 enum : long long { VRType = VR::SQ };
14367 enum { VMType = VM::VM1 };
14368 static const char* GetVMString() { return "1"; }
14369 };
14370 template <> struct TagToType<0x003a,0x0301> {
14371 static const char* GetVRString() { return "IS"; }
14372 typedef VRToType<VR::IS>::Type Type;
14373 enum : long long { VRType = VR::IS };
14374 enum { VMType = VM::VM1 };
14375 static const char* GetVMString() { return "1"; }
14376 };
14377 template <> struct TagToType<0x003a,0x0302> {
14378 static const char* GetVRString() { return "CS"; }
14379 typedef VRToType<VR::CS>::Type Type;
14380 enum : long long { VRType = VR::CS };
14381 enum { VMType = VM::VM1 };
14382 static const char* GetVMString() { return "1"; }
14383 };
14384 template <> struct TagToType<0x0040,0x0001> {
14385 static const char* GetVRString() { return "AE"; }
14386 typedef VRToType<VR::AE>::Type Type;
14387 enum : long long { VRType = VR::AE };
14388 enum { VMType = VM::VM1_n };
14389 static const char* GetVMString() { return "1-n"; }
14390 };
14391 template <> struct TagToType<0x0040,0x0002> {
14392 static const char* GetVRString() { return "DA"; }
14393 typedef VRToType<VR::DA>::Type Type;
14394 enum : long long { VRType = VR::DA };
14395 enum { VMType = VM::VM1 };
14396 static const char* GetVMString() { return "1"; }
14397 };
14398 template <> struct TagToType<0x0040,0x0003> {
14399 static const char* GetVRString() { return "TM"; }
14400 typedef VRToType<VR::TM>::Type Type;
14401 enum : long long { VRType = VR::TM };
14402 enum { VMType = VM::VM1 };
14403 static const char* GetVMString() { return "1"; }
14404 };
14405 template <> struct TagToType<0x0040,0x0004> {
14406 static const char* GetVRString() { return "DA"; }
14407 typedef VRToType<VR::DA>::Type Type;
14408 enum : long long { VRType = VR::DA };
14409 enum { VMType = VM::VM1 };
14410 static const char* GetVMString() { return "1"; }
14411 };
14412 template <> struct TagToType<0x0040,0x0005> {
14413 static const char* GetVRString() { return "TM"; }
14414 typedef VRToType<VR::TM>::Type Type;
14415 enum : long long { VRType = VR::TM };
14416 enum { VMType = VM::VM1 };
14417 static const char* GetVMString() { return "1"; }
14418 };
14419 template <> struct TagToType<0x0040,0x0006> {
14420 static const char* GetVRString() { return "PN"; }
14421 typedef VRToType<VR::PN>::Type Type;
14422 enum : long long { VRType = VR::PN };
14423 enum { VMType = VM::VM1 };
14424 static const char* GetVMString() { return "1"; }
14425 };
14426 template <> struct TagToType<0x0040,0x0007> {
14427 static const char* GetVRString() { return "LO"; }
14428 typedef VRToType<VR::LO>::Type Type;
14429 enum : long long { VRType = VR::LO };
14430 enum { VMType = VM::VM1 };
14431 static const char* GetVMString() { return "1"; }
14432 };
14433 template <> struct TagToType<0x0040,0x0008> {
14434 static const char* GetVRString() { return "SQ"; }
14435 typedef VRToType<VR::SQ>::Type Type;
14436 enum : long long { VRType = VR::SQ };
14437 enum { VMType = VM::VM1 };
14438 static const char* GetVMString() { return "1"; }
14439 };
14440 template <> struct TagToType<0x0040,0x0009> {
14441 static const char* GetVRString() { return "SH"; }
14442 typedef VRToType<VR::SH>::Type Type;
14443 enum : long long { VRType = VR::SH };
14444 enum { VMType = VM::VM1 };
14445 static const char* GetVMString() { return "1"; }
14446 };
14447 template <> struct TagToType<0x0040,0x000a> {
14448 static const char* GetVRString() { return "SQ"; }
14449 typedef VRToType<VR::SQ>::Type Type;
14450 enum : long long { VRType = VR::SQ };
14451 enum { VMType = VM::VM1 };
14452 static const char* GetVMString() { return "1"; }
14453 };
14454 template <> struct TagToType<0x0040,0x000b> {
14455 static const char* GetVRString() { return "SQ"; }
14456 typedef VRToType<VR::SQ>::Type Type;
14457 enum : long long { VRType = VR::SQ };
14458 enum { VMType = VM::VM1 };
14459 static const char* GetVMString() { return "1"; }
14460 };
14461 template <> struct TagToType<0x0040,0x0010> {
14462 static const char* GetVRString() { return "SH"; }
14463 typedef VRToType<VR::SH>::Type Type;
14464 enum : long long { VRType = VR::SH };
14465 enum { VMType = VM::VM1_n };
14466 static const char* GetVMString() { return "1-n"; }
14467 };
14468 template <> struct TagToType<0x0040,0x0011> {
14469 static const char* GetVRString() { return "SH"; }
14470 typedef VRToType<VR::SH>::Type Type;
14471 enum : long long { VRType = VR::SH };
14472 enum { VMType = VM::VM1 };
14473 static const char* GetVMString() { return "1"; }
14474 };
14475 template <> struct TagToType<0x0040,0x0012> {
14476 static const char* GetVRString() { return "LO"; }
14477 typedef VRToType<VR::LO>::Type Type;
14478 enum : long long { VRType = VR::LO };
14479 enum { VMType = VM::VM1 };
14480 static const char* GetVMString() { return "1"; }
14481 };
14482 template <> struct TagToType<0x0040,0x0020> {
14483 static const char* GetVRString() { return "CS"; }
14484 typedef VRToType<VR::CS>::Type Type;
14485 enum : long long { VRType = VR::CS };
14486 enum { VMType = VM::VM1 };
14487 static const char* GetVMString() { return "1"; }
14488 };
14489 template <> struct TagToType<0x0040,0x0026> {
14490 static const char* GetVRString() { return "SQ"; }
14491 typedef VRToType<VR::SQ>::Type Type;
14492 enum : long long { VRType = VR::SQ };
14493 enum { VMType = VM::VM1 };
14494 static const char* GetVMString() { return "1"; }
14495 };
14496 template <> struct TagToType<0x0040,0x0027> {
14497 static const char* GetVRString() { return "SQ"; }
14498 typedef VRToType<VR::SQ>::Type Type;
14499 enum : long long { VRType = VR::SQ };
14500 enum { VMType = VM::VM1 };
14501 static const char* GetVMString() { return "1"; }
14502 };
14503 template <> struct TagToType<0x0040,0x0031> {
14504 static const char* GetVRString() { return "UT"; }
14505 typedef VRToType<VR::UT>::Type Type;
14506 enum : long long { VRType = VR::UT };
14507 enum { VMType = VM::VM1 };
14508 static const char* GetVMString() { return "1"; }
14509 };
14510 template <> struct TagToType<0x0040,0x0032> {
14511 static const char* GetVRString() { return "UT"; }
14512 typedef VRToType<VR::UT>::Type Type;
14513 enum : long long { VRType = VR::UT };
14514 enum { VMType = VM::VM1 };
14515 static const char* GetVMString() { return "1"; }
14516 };
14517 template <> struct TagToType<0x0040,0x0033> {
14518 static const char* GetVRString() { return "CS"; }
14519 typedef VRToType<VR::CS>::Type Type;
14520 enum : long long { VRType = VR::CS };
14521 enum { VMType = VM::VM1 };
14522 static const char* GetVMString() { return "1"; }
14523 };
14524 template <> struct TagToType<0x0040,0x0035> {
14525 static const char* GetVRString() { return "CS"; }
14526 typedef VRToType<VR::CS>::Type Type;
14527 enum : long long { VRType = VR::CS };
14528 enum { VMType = VM::VM1 };
14529 static const char* GetVMString() { return "1"; }
14530 };
14531 template <> struct TagToType<0x0040,0x0036> {
14532 static const char* GetVRString() { return "SQ"; }
14533 typedef VRToType<VR::SQ>::Type Type;
14534 enum : long long { VRType = VR::SQ };
14535 enum { VMType = VM::VM1 };
14536 static const char* GetVMString() { return "1"; }
14537 };
14538 template <> struct TagToType<0x0040,0x0039> {
14539 static const char* GetVRString() { return "SQ"; }
14540 typedef VRToType<VR::SQ>::Type Type;
14541 enum : long long { VRType = VR::SQ };
14542 enum { VMType = VM::VM1 };
14543 static const char* GetVMString() { return "1"; }
14544 };
14545 template <> struct TagToType<0x0040,0x003a> {
14546 static const char* GetVRString() { return "SQ"; }
14547 typedef VRToType<VR::SQ>::Type Type;
14548 enum : long long { VRType = VR::SQ };
14549 enum { VMType = VM::VM1 };
14550 static const char* GetVMString() { return "1"; }
14551 };
14552 template <> struct TagToType<0x0040,0x0100> {
14553 static const char* GetVRString() { return "SQ"; }
14554 typedef VRToType<VR::SQ>::Type Type;
14555 enum : long long { VRType = VR::SQ };
14556 enum { VMType = VM::VM1 };
14557 static const char* GetVMString() { return "1"; }
14558 };
14559 template <> struct TagToType<0x0040,0x0220> {
14560 static const char* GetVRString() { return "SQ"; }
14561 typedef VRToType<VR::SQ>::Type Type;
14562 enum : long long { VRType = VR::SQ };
14563 enum { VMType = VM::VM1 };
14564 static const char* GetVMString() { return "1"; }
14565 };
14566 template <> struct TagToType<0x0040,0x0241> {
14567 static const char* GetVRString() { return "AE"; }
14568 typedef VRToType<VR::AE>::Type Type;
14569 enum : long long { VRType = VR::AE };
14570 enum { VMType = VM::VM1 };
14571 static const char* GetVMString() { return "1"; }
14572 };
14573 template <> struct TagToType<0x0040,0x0242> {
14574 static const char* GetVRString() { return "SH"; }
14575 typedef VRToType<VR::SH>::Type Type;
14576 enum : long long { VRType = VR::SH };
14577 enum { VMType = VM::VM1 };
14578 static const char* GetVMString() { return "1"; }
14579 };
14580 template <> struct TagToType<0x0040,0x0243> {
14581 static const char* GetVRString() { return "SH"; }
14582 typedef VRToType<VR::SH>::Type Type;
14583 enum : long long { VRType = VR::SH };
14584 enum { VMType = VM::VM1 };
14585 static const char* GetVMString() { return "1"; }
14586 };
14587 template <> struct TagToType<0x0040,0x0244> {
14588 static const char* GetVRString() { return "DA"; }
14589 typedef VRToType<VR::DA>::Type Type;
14590 enum : long long { VRType = VR::DA };
14591 enum { VMType = VM::VM1 };
14592 static const char* GetVMString() { return "1"; }
14593 };
14594 template <> struct TagToType<0x0040,0x0245> {
14595 static const char* GetVRString() { return "TM"; }
14596 typedef VRToType<VR::TM>::Type Type;
14597 enum : long long { VRType = VR::TM };
14598 enum { VMType = VM::VM1 };
14599 static const char* GetVMString() { return "1"; }
14600 };
14601 template <> struct TagToType<0x0040,0x0250> {
14602 static const char* GetVRString() { return "DA"; }
14603 typedef VRToType<VR::DA>::Type Type;
14604 enum : long long { VRType = VR::DA };
14605 enum { VMType = VM::VM1 };
14606 static const char* GetVMString() { return "1"; }
14607 };
14608 template <> struct TagToType<0x0040,0x0251> {
14609 static const char* GetVRString() { return "TM"; }
14610 typedef VRToType<VR::TM>::Type Type;
14611 enum : long long { VRType = VR::TM };
14612 enum { VMType = VM::VM1 };
14613 static const char* GetVMString() { return "1"; }
14614 };
14615 template <> struct TagToType<0x0040,0x0252> {
14616 static const char* GetVRString() { return "CS"; }
14617 typedef VRToType<VR::CS>::Type Type;
14618 enum : long long { VRType = VR::CS };
14619 enum { VMType = VM::VM1 };
14620 static const char* GetVMString() { return "1"; }
14621 };
14622 template <> struct TagToType<0x0040,0x0253> {
14623 static const char* GetVRString() { return "SH"; }
14624 typedef VRToType<VR::SH>::Type Type;
14625 enum : long long { VRType = VR::SH };
14626 enum { VMType = VM::VM1 };
14627 static const char* GetVMString() { return "1"; }
14628 };
14629 template <> struct TagToType<0x0040,0x0254> {
14630 static const char* GetVRString() { return "LO"; }
14631 typedef VRToType<VR::LO>::Type Type;
14632 enum : long long { VRType = VR::LO };
14633 enum { VMType = VM::VM1 };
14634 static const char* GetVMString() { return "1"; }
14635 };
14636 template <> struct TagToType<0x0040,0x0255> {
14637 static const char* GetVRString() { return "LO"; }
14638 typedef VRToType<VR::LO>::Type Type;
14639 enum : long long { VRType = VR::LO };
14640 enum { VMType = VM::VM1 };
14641 static const char* GetVMString() { return "1"; }
14642 };
14643 template <> struct TagToType<0x0040,0x0260> {
14644 static const char* GetVRString() { return "SQ"; }
14645 typedef VRToType<VR::SQ>::Type Type;
14646 enum : long long { VRType = VR::SQ };
14647 enum { VMType = VM::VM1 };
14648 static const char* GetVMString() { return "1"; }
14649 };
14650 template <> struct TagToType<0x0040,0x0261> {
14651 static const char* GetVRString() { return "CS"; }
14652 typedef VRToType<VR::CS>::Type Type;
14653 enum : long long { VRType = VR::CS };
14654 enum { VMType = VM::VM1 };
14655 static const char* GetVMString() { return "1"; }
14656 };
14657 template <> struct TagToType<0x0040,0x0270> {
14658 static const char* GetVRString() { return "SQ"; }
14659 typedef VRToType<VR::SQ>::Type Type;
14660 enum : long long { VRType = VR::SQ };
14661 enum { VMType = VM::VM1 };
14662 static const char* GetVMString() { return "1"; }
14663 };
14664 template <> struct TagToType<0x0040,0x0275> {
14665 static const char* GetVRString() { return "SQ"; }
14666 typedef VRToType<VR::SQ>::Type Type;
14667 enum : long long { VRType = VR::SQ };
14668 enum { VMType = VM::VM1 };
14669 static const char* GetVMString() { return "1"; }
14670 };
14671 template <> struct TagToType<0x0040,0x0280> {
14672 static const char* GetVRString() { return "ST"; }
14673 typedef VRToType<VR::ST>::Type Type;
14674 enum : long long { VRType = VR::ST };
14675 enum { VMType = VM::VM1 };
14676 static const char* GetVMString() { return "1"; }
14677 };
14678 template <> struct TagToType<0x0040,0x0281> {
14679 static const char* GetVRString() { return "SQ"; }
14680 typedef VRToType<VR::SQ>::Type Type;
14681 enum : long long { VRType = VR::SQ };
14682 enum { VMType = VM::VM1 };
14683 static const char* GetVMString() { return "1"; }
14684 };
14685 template <> struct TagToType<0x0040,0x0293> {
14686 static const char* GetVRString() { return "SQ"; }
14687 typedef VRToType<VR::SQ>::Type Type;
14688 enum : long long { VRType = VR::SQ };
14689 enum { VMType = VM::VM1 };
14690 static const char* GetVMString() { return "1"; }
14691 };
14692 template <> struct TagToType<0x0040,0x0294> {
14693 static const char* GetVRString() { return "DS"; }
14694 typedef VRToType<VR::DS>::Type Type;
14695 enum : long long { VRType = VR::DS };
14696 enum { VMType = VM::VM1 };
14697 static const char* GetVMString() { return "1"; }
14698 };
14699 template <> struct TagToType<0x0040,0x0295> {
14700 static const char* GetVRString() { return "SQ"; }
14701 typedef VRToType<VR::SQ>::Type Type;
14702 enum : long long { VRType = VR::SQ };
14703 enum { VMType = VM::VM1 };
14704 static const char* GetVMString() { return "1"; }
14705 };
14706 template <> struct TagToType<0x0040,0x0296> {
14707 static const char* GetVRString() { return "SQ"; }
14708 typedef VRToType<VR::SQ>::Type Type;
14709 enum : long long { VRType = VR::SQ };
14710 enum { VMType = VM::VM1 };
14711 static const char* GetVMString() { return "1"; }
14712 };
14713 template <> struct TagToType<0x0040,0x0300> {
14714 static const char* GetVRString() { return "US"; }
14715 typedef VRToType<VR::US>::Type Type;
14716 enum : long long { VRType = VR::US };
14717 enum { VMType = VM::VM1 };
14718 static const char* GetVMString() { return "1"; }
14719 };
14720 template <> struct TagToType<0x0040,0x0301> {
14721 static const char* GetVRString() { return "US"; }
14722 typedef VRToType<VR::US>::Type Type;
14723 enum : long long { VRType = VR::US };
14724 enum { VMType = VM::VM1 };
14725 static const char* GetVMString() { return "1"; }
14726 };
14727 template <> struct TagToType<0x0040,0x0302> {
14728 static const char* GetVRString() { return "US"; }
14729 typedef VRToType<VR::US>::Type Type;
14730 enum : long long { VRType = VR::US };
14731 enum { VMType = VM::VM1 };
14732 static const char* GetVMString() { return "1"; }
14733 };
14734 template <> struct TagToType<0x0040,0x0303> {
14735 static const char* GetVRString() { return "US"; }
14736 typedef VRToType<VR::US>::Type Type;
14737 enum : long long { VRType = VR::US };
14738 enum { VMType = VM::VM1_2 };
14739 static const char* GetVMString() { return "1-2"; }
14740 };
14741 template <> struct TagToType<0x0040,0x0306> {
14742 static const char* GetVRString() { return "DS"; }
14743 typedef VRToType<VR::DS>::Type Type;
14744 enum : long long { VRType = VR::DS };
14745 enum { VMType = VM::VM1 };
14746 static const char* GetVMString() { return "1"; }
14747 };
14748 template <> struct TagToType<0x0040,0x0307> {
14749 static const char* GetVRString() { return "DS"; }
14750 typedef VRToType<VR::DS>::Type Type;
14751 enum : long long { VRType = VR::DS };
14752 enum { VMType = VM::VM1 };
14753 static const char* GetVMString() { return "1"; }
14754 };
14755 template <> struct TagToType<0x0040,0x030e> {
14756 static const char* GetVRString() { return "SQ"; }
14757 typedef VRToType<VR::SQ>::Type Type;
14758 enum : long long { VRType = VR::SQ };
14759 enum { VMType = VM::VM1 };
14760 static const char* GetVMString() { return "1"; }
14761 };
14762 template <> struct TagToType<0x0040,0x0310> {
14763 static const char* GetVRString() { return "ST"; }
14764 typedef VRToType<VR::ST>::Type Type;
14765 enum : long long { VRType = VR::ST };
14766 enum { VMType = VM::VM1 };
14767 static const char* GetVMString() { return "1"; }
14768 };
14769 template <> struct TagToType<0x0040,0x0312> {
14770 static const char* GetVRString() { return "DS"; }
14771 typedef VRToType<VR::DS>::Type Type;
14772 enum : long long { VRType = VR::DS };
14773 enum { VMType = VM::VM1 };
14774 static const char* GetVMString() { return "1"; }
14775 };
14776 template <> struct TagToType<0x0040,0x0314> {
14777 static const char* GetVRString() { return "DS"; }
14778 typedef VRToType<VR::DS>::Type Type;
14779 enum : long long { VRType = VR::DS };
14780 enum { VMType = VM::VM1 };
14781 static const char* GetVMString() { return "1"; }
14782 };
14783 template <> struct TagToType<0x0040,0x0316> {
14784 static const char* GetVRString() { return "DS"; }
14785 typedef VRToType<VR::DS>::Type Type;
14786 enum : long long { VRType = VR::DS };
14787 enum { VMType = VM::VM1 };
14788 static const char* GetVMString() { return "1"; }
14789 };
14790 template <> struct TagToType<0x0040,0x0318> {
14791 static const char* GetVRString() { return "CS"; }
14792 typedef VRToType<VR::CS>::Type Type;
14793 enum : long long { VRType = VR::CS };
14794 enum { VMType = VM::VM1 };
14795 static const char* GetVMString() { return "1"; }
14796 };
14797 template <> struct TagToType<0x0040,0x0320> {
14798 static const char* GetVRString() { return "SQ"; }
14799 typedef VRToType<VR::SQ>::Type Type;
14800 enum : long long { VRType = VR::SQ };
14801 enum { VMType = VM::VM1 };
14802 static const char* GetVMString() { return "1"; }
14803 };
14804 template <> struct TagToType<0x0040,0x0321> {
14805 static const char* GetVRString() { return "SQ"; }
14806 typedef VRToType<VR::SQ>::Type Type;
14807 enum : long long { VRType = VR::SQ };
14808 enum { VMType = VM::VM1 };
14809 static const char* GetVMString() { return "1"; }
14810 };
14811 template <> struct TagToType<0x0040,0x0324> {
14812 static const char* GetVRString() { return "SQ"; }
14813 typedef VRToType<VR::SQ>::Type Type;
14814 enum : long long { VRType = VR::SQ };
14815 enum { VMType = VM::VM1 };
14816 static const char* GetVMString() { return "1"; }
14817 };
14818 template <> struct TagToType<0x0040,0x0330> {
14819 static const char* GetVRString() { return "SQ"; }
14820 typedef VRToType<VR::SQ>::Type Type;
14821 enum : long long { VRType = VR::SQ };
14822 enum { VMType = VM::VM1 };
14823 static const char* GetVMString() { return "1"; }
14824 };
14825 template <> struct TagToType<0x0040,0x0340> {
14826 static const char* GetVRString() { return "SQ"; }
14827 typedef VRToType<VR::SQ>::Type Type;
14828 enum : long long { VRType = VR::SQ };
14829 enum { VMType = VM::VM1 };
14830 static const char* GetVMString() { return "1"; }
14831 };
14832 template <> struct TagToType<0x0040,0x0400> {
14833 static const char* GetVRString() { return "LT"; }
14834 typedef VRToType<VR::LT>::Type Type;
14835 enum : long long { VRType = VR::LT };
14836 enum { VMType = VM::VM1 };
14837 static const char* GetVMString() { return "1"; }
14838 };
14839 template <> struct TagToType<0x0040,0x0440> {
14840 static const char* GetVRString() { return "SQ"; }
14841 typedef VRToType<VR::SQ>::Type Type;
14842 enum : long long { VRType = VR::SQ };
14843 enum { VMType = VM::VM1 };
14844 static const char* GetVMString() { return "1"; }
14845 };
14846 template <> struct TagToType<0x0040,0x0441> {
14847 static const char* GetVRString() { return "SQ"; }
14848 typedef VRToType<VR::SQ>::Type Type;
14849 enum : long long { VRType = VR::SQ };
14850 enum { VMType = VM::VM1 };
14851 static const char* GetVMString() { return "1"; }
14852 };
14853 template <> struct TagToType<0x0040,0x0500> {
14854 static const char* GetVRString() { return "SQ"; }
14855 typedef VRToType<VR::SQ>::Type Type;
14856 enum : long long { VRType = VR::SQ };
14857 enum { VMType = VM::VM1 };
14858 static const char* GetVMString() { return "1"; }
14859 };
14860 template <> struct TagToType<0x0040,0x050a> {
14861 static const char* GetVRString() { return "LO"; }
14862 typedef VRToType<VR::LO>::Type Type;
14863 enum : long long { VRType = VR::LO };
14864 enum { VMType = VM::VM1 };
14865 static const char* GetVMString() { return "1"; }
14866 };
14867 template <> struct TagToType<0x0040,0x0512> {
14868 static const char* GetVRString() { return "LO"; }
14869 typedef VRToType<VR::LO>::Type Type;
14870 enum : long long { VRType = VR::LO };
14871 enum { VMType = VM::VM1 };
14872 static const char* GetVMString() { return "1"; }
14873 };
14874 template <> struct TagToType<0x0040,0x0513> {
14875 static const char* GetVRString() { return "SQ"; }
14876 typedef VRToType<VR::SQ>::Type Type;
14877 enum : long long { VRType = VR::SQ };
14878 enum { VMType = VM::VM1 };
14879 static const char* GetVMString() { return "1"; }
14880 };
14881 template <> struct TagToType<0x0040,0x0515> {
14882 static const char* GetVRString() { return "SQ"; }
14883 typedef VRToType<VR::SQ>::Type Type;
14884 enum : long long { VRType = VR::SQ };
14885 enum { VMType = VM::VM1 };
14886 static const char* GetVMString() { return "1"; }
14887 };
14888 template <> struct TagToType<0x0040,0x0518> {
14889 static const char* GetVRString() { return "SQ"; }
14890 typedef VRToType<VR::SQ>::Type Type;
14891 enum : long long { VRType = VR::SQ };
14892 enum { VMType = VM::VM1 };
14893 static const char* GetVMString() { return "1"; }
14894 };
14895 template <> struct TagToType<0x0040,0x051a> {
14896 static const char* GetVRString() { return "LO"; }
14897 typedef VRToType<VR::LO>::Type Type;
14898 enum : long long { VRType = VR::LO };
14899 enum { VMType = VM::VM1 };
14900 static const char* GetVMString() { return "1"; }
14901 };
14902 template <> struct TagToType<0x0040,0x0520> {
14903 static const char* GetVRString() { return "SQ"; }
14904 typedef VRToType<VR::SQ>::Type Type;
14905 enum : long long { VRType = VR::SQ };
14906 enum { VMType = VM::VM1 };
14907 static const char* GetVMString() { return "1"; }
14908 };
14909 template <> struct TagToType<0x0040,0x0550> {
14910 static const char* GetVRString() { return "SQ"; }
14911 typedef VRToType<VR::SQ>::Type Type;
14912 enum : long long { VRType = VR::SQ };
14913 enum { VMType = VM::VM1 };
14914 static const char* GetVMString() { return "1"; }
14915 };
14916 template <> struct TagToType<0x0040,0x0551> {
14917 static const char* GetVRString() { return "LO"; }
14918 typedef VRToType<VR::LO>::Type Type;
14919 enum : long long { VRType = VR::LO };
14920 enum { VMType = VM::VM1 };
14921 static const char* GetVMString() { return "1"; }
14922 };
14923 template <> struct TagToType<0x0040,0x0552> {
14924 static const char* GetVRString() { return "SQ"; }
14925 typedef VRToType<VR::SQ>::Type Type;
14926 enum : long long { VRType = VR::SQ };
14927 enum { VMType = VM::VM1 };
14928 static const char* GetVMString() { return "1"; }
14929 };
14930 template <> struct TagToType<0x0040,0x0553> {
14931 static const char* GetVRString() { return "ST"; }
14932 typedef VRToType<VR::ST>::Type Type;
14933 enum : long long { VRType = VR::ST };
14934 enum { VMType = VM::VM1 };
14935 static const char* GetVMString() { return "1"; }
14936 };
14937 template <> struct TagToType<0x0040,0x0554> {
14938 static const char* GetVRString() { return "UI"; }
14939 typedef VRToType<VR::UI>::Type Type;
14940 enum : long long { VRType = VR::UI };
14941 enum { VMType = VM::VM1 };
14942 static const char* GetVMString() { return "1"; }
14943 };
14944 template <> struct TagToType<0x0040,0x0555> {
14945 static const char* GetVRString() { return "SQ"; }
14946 typedef VRToType<VR::SQ>::Type Type;
14947 enum : long long { VRType = VR::SQ };
14948 enum { VMType = VM::VM1 };
14949 static const char* GetVMString() { return "1"; }
14950 };
14951 template <> struct TagToType<0x0040,0x0556> {
14952 static const char* GetVRString() { return "ST"; }
14953 typedef VRToType<VR::ST>::Type Type;
14954 enum : long long { VRType = VR::ST };
14955 enum { VMType = VM::VM1 };
14956 static const char* GetVMString() { return "1"; }
14957 };
14958 template <> struct TagToType<0x0040,0x0560> {
14959 static const char* GetVRString() { return "SQ"; }
14960 typedef VRToType<VR::SQ>::Type Type;
14961 enum : long long { VRType = VR::SQ };
14962 enum { VMType = VM::VM1 };
14963 static const char* GetVMString() { return "1"; }
14964 };
14965 template <> struct TagToType<0x0040,0x0562> {
14966 static const char* GetVRString() { return "SQ"; }
14967 typedef VRToType<VR::SQ>::Type Type;
14968 enum : long long { VRType = VR::SQ };
14969 enum { VMType = VM::VM1 };
14970 static const char* GetVMString() { return "1"; }
14971 };
14972 template <> struct TagToType<0x0040,0x059a> {
14973 static const char* GetVRString() { return "SQ"; }
14974 typedef VRToType<VR::SQ>::Type Type;
14975 enum : long long { VRType = VR::SQ };
14976 enum { VMType = VM::VM1 };
14977 static const char* GetVMString() { return "1"; }
14978 };
14979 template <> struct TagToType<0x0040,0x0600> {
14980 static const char* GetVRString() { return "LO"; }
14981 typedef VRToType<VR::LO>::Type Type;
14982 enum : long long { VRType = VR::LO };
14983 enum { VMType = VM::VM1 };
14984 static const char* GetVMString() { return "1"; }
14985 };
14986 template <> struct TagToType<0x0040,0x0602> {
14987 static const char* GetVRString() { return "UT"; }
14988 typedef VRToType<VR::UT>::Type Type;
14989 enum : long long { VRType = VR::UT };
14990 enum { VMType = VM::VM1 };
14991 static const char* GetVMString() { return "1"; }
14992 };
14993 template <> struct TagToType<0x0040,0x0610> {
14994 static const char* GetVRString() { return "SQ"; }
14995 typedef VRToType<VR::SQ>::Type Type;
14996 enum : long long { VRType = VR::SQ };
14997 enum { VMType = VM::VM1 };
14998 static const char* GetVMString() { return "1"; }
14999 };
15000 template <> struct TagToType<0x0040,0x0612> {
15001 static const char* GetVRString() { return "SQ"; }
15002 typedef VRToType<VR::SQ>::Type Type;
15003 enum : long long { VRType = VR::SQ };
15004 enum { VMType = VM::VM1 };
15005 static const char* GetVMString() { return "1"; }
15006 };
15007 template <> struct TagToType<0x0040,0x0620> {
15008 static const char* GetVRString() { return "SQ"; }
15009 typedef VRToType<VR::SQ>::Type Type;
15010 enum : long long { VRType = VR::SQ };
15011 enum { VMType = VM::VM1 };
15012 static const char* GetVMString() { return "1"; }
15013 };
15014 template <> struct TagToType<0x0040,0x06fa> {
15015 static const char* GetVRString() { return "LO"; }
15016 typedef VRToType<VR::LO>::Type Type;
15017 enum : long long { VRType = VR::LO };
15018 enum { VMType = VM::VM1 };
15019 static const char* GetVMString() { return "1"; }
15020 };
15021 template <> struct TagToType<0x0040,0x071a> {
15022 static const char* GetVRString() { return "SQ"; }
15023 typedef VRToType<VR::SQ>::Type Type;
15024 enum : long long { VRType = VR::SQ };
15025 enum { VMType = VM::VM1 };
15026 static const char* GetVMString() { return "1"; }
15027 };
15028 template <> struct TagToType<0x0040,0x072a> {
15029 static const char* GetVRString() { return "DS"; }
15030 typedef VRToType<VR::DS>::Type Type;
15031 enum : long long { VRType = VR::DS };
15032 enum { VMType = VM::VM1 };
15033 static const char* GetVMString() { return "1"; }
15034 };
15035 template <> struct TagToType<0x0040,0x073a> {
15036 static const char* GetVRString() { return "DS"; }
15037 typedef VRToType<VR::DS>::Type Type;
15038 enum : long long { VRType = VR::DS };
15039 enum { VMType = VM::VM1 };
15040 static const char* GetVMString() { return "1"; }
15041 };
15042 template <> struct TagToType<0x0040,0x074a> {
15043 static const char* GetVRString() { return "DS"; }
15044 typedef VRToType<VR::DS>::Type Type;
15045 enum : long long { VRType = VR::DS };
15046 enum { VMType = VM::VM1 };
15047 static const char* GetVMString() { return "1"; }
15048 };
15049 template <> struct TagToType<0x0040,0x08d8> {
15050 static const char* GetVRString() { return "SQ"; }
15051 typedef VRToType<VR::SQ>::Type Type;
15052 enum : long long { VRType = VR::SQ };
15053 enum { VMType = VM::VM1 };
15054 static const char* GetVMString() { return "1"; }
15055 };
15056 template <> struct TagToType<0x0040,0x08da> {
15057 static const char* GetVRString() { return "SQ"; }
15058 typedef VRToType<VR::SQ>::Type Type;
15059 enum : long long { VRType = VR::SQ };
15060 enum { VMType = VM::VM1 };
15061 static const char* GetVMString() { return "1"; }
15062 };
15063 template <> struct TagToType<0x0040,0x08ea> {
15064 static const char* GetVRString() { return "SQ"; }
15065 typedef VRToType<VR::SQ>::Type Type;
15066 enum : long long { VRType = VR::SQ };
15067 enum { VMType = VM::VM1 };
15068 static const char* GetVMString() { return "1"; }
15069 };
15070 template <> struct TagToType<0x0040,0x09f8> {
15071 static const char* GetVRString() { return "SQ"; }
15072 typedef VRToType<VR::SQ>::Type Type;
15073 enum : long long { VRType = VR::SQ };
15074 enum { VMType = VM::VM1 };
15075 static const char* GetVMString() { return "1"; }
15076 };
15077 template <> struct TagToType<0x0040,0x1001> {
15078 static const char* GetVRString() { return "SH"; }
15079 typedef VRToType<VR::SH>::Type Type;
15080 enum : long long { VRType = VR::SH };
15081 enum { VMType = VM::VM1 };
15082 static const char* GetVMString() { return "1"; }
15083 };
15084 template <> struct TagToType<0x0040,0x1002> {
15085 static const char* GetVRString() { return "LO"; }
15086 typedef VRToType<VR::LO>::Type Type;
15087 enum : long long { VRType = VR::LO };
15088 enum { VMType = VM::VM1 };
15089 static const char* GetVMString() { return "1"; }
15090 };
15091 template <> struct TagToType<0x0040,0x1003> {
15092 static const char* GetVRString() { return "SH"; }
15093 typedef VRToType<VR::SH>::Type Type;
15094 enum : long long { VRType = VR::SH };
15095 enum { VMType = VM::VM1 };
15096 static const char* GetVMString() { return "1"; }
15097 };
15098 template <> struct TagToType<0x0040,0x1004> {
15099 static const char* GetVRString() { return "LO"; }
15100 typedef VRToType<VR::LO>::Type Type;
15101 enum : long long { VRType = VR::LO };
15102 enum { VMType = VM::VM1 };
15103 static const char* GetVMString() { return "1"; }
15104 };
15105 template <> struct TagToType<0x0040,0x1005> {
15106 static const char* GetVRString() { return "LO"; }
15107 typedef VRToType<VR::LO>::Type Type;
15108 enum : long long { VRType = VR::LO };
15109 enum { VMType = VM::VM1 };
15110 static const char* GetVMString() { return "1"; }
15111 };
15112 template <> struct TagToType<0x0040,0x1006> {
15113 static const char* GetVRString() { return "SH"; }
15114 typedef VRToType<VR::SH>::Type Type;
15115 enum : long long { VRType = VR::SH };
15116 enum { VMType = VM::VM1 };
15117 static const char* GetVMString() { return "1"; }
15118 };
15119 template <> struct TagToType<0x0040,0x1007> {
15120 static const char* GetVRString() { return "SH"; }
15121 typedef VRToType<VR::SH>::Type Type;
15122 enum : long long { VRType = VR::SH };
15123 enum { VMType = VM::VM1 };
15124 static const char* GetVMString() { return "1"; }
15125 };
15126 template <> struct TagToType<0x0040,0x1008> {
15127 static const char* GetVRString() { return "LO"; }
15128 typedef VRToType<VR::LO>::Type Type;
15129 enum : long long { VRType = VR::LO };
15130 enum { VMType = VM::VM1 };
15131 static const char* GetVMString() { return "1"; }
15132 };
15133 template <> struct TagToType<0x0040,0x1009> {
15134 static const char* GetVRString() { return "SH"; }
15135 typedef VRToType<VR::SH>::Type Type;
15136 enum : long long { VRType = VR::SH };
15137 enum { VMType = VM::VM1 };
15138 static const char* GetVMString() { return "1"; }
15139 };
15140 template <> struct TagToType<0x0040,0x100a> {
15141 static const char* GetVRString() { return "SQ"; }
15142 typedef VRToType<VR::SQ>::Type Type;
15143 enum : long long { VRType = VR::SQ };
15144 enum { VMType = VM::VM1 };
15145 static const char* GetVMString() { return "1"; }
15146 };
15147 template <> struct TagToType<0x0040,0x1010> {
15148 static const char* GetVRString() { return "PN"; }
15149 typedef VRToType<VR::PN>::Type Type;
15150 enum : long long { VRType = VR::PN };
15151 enum { VMType = VM::VM1_n };
15152 static const char* GetVMString() { return "1-n"; }
15153 };
15154 template <> struct TagToType<0x0040,0x1011> {
15155 static const char* GetVRString() { return "SQ"; }
15156 typedef VRToType<VR::SQ>::Type Type;
15157 enum : long long { VRType = VR::SQ };
15158 enum { VMType = VM::VM1 };
15159 static const char* GetVMString() { return "1"; }
15160 };
15161 template <> struct TagToType<0x0040,0x1012> {
15162 static const char* GetVRString() { return "SQ"; }
15163 typedef VRToType<VR::SQ>::Type Type;
15164 enum : long long { VRType = VR::SQ };
15165 enum { VMType = VM::VM1 };
15166 static const char* GetVMString() { return "1"; }
15167 };
15168 template <> struct TagToType<0x0040,0x1060> {
15169 static const char* GetVRString() { return "LO"; }
15170 typedef VRToType<VR::LO>::Type Type;
15171 enum : long long { VRType = VR::LO };
15172 enum { VMType = VM::VM1 };
15173 static const char* GetVMString() { return "1"; }
15174 };
15175 template <> struct TagToType<0x0040,0x1101> {
15176 static const char* GetVRString() { return "SQ"; }
15177 typedef VRToType<VR::SQ>::Type Type;
15178 enum : long long { VRType = VR::SQ };
15179 enum { VMType = VM::VM1 };
15180 static const char* GetVMString() { return "1"; }
15181 };
15182 template <> struct TagToType<0x0040,0x1102> {
15183 static const char* GetVRString() { return "ST"; }
15184 typedef VRToType<VR::ST>::Type Type;
15185 enum : long long { VRType = VR::ST };
15186 enum { VMType = VM::VM1 };
15187 static const char* GetVMString() { return "1"; }
15188 };
15189 template <> struct TagToType<0x0040,0x1103> {
15190 static const char* GetVRString() { return "LO"; }
15191 typedef VRToType<VR::LO>::Type Type;
15192 enum : long long { VRType = VR::LO };
15193 enum { VMType = VM::VM1_n };
15194 static const char* GetVMString() { return "1-n"; }
15195 };
15196 template <> struct TagToType<0x0040,0x1104> {
15197 static const char* GetVRString() { return "LT"; }
15198 typedef VRToType<VR::LT>::Type Type;
15199 enum : long long { VRType = VR::LT };
15200 enum { VMType = VM::VM1 };
15201 static const char* GetVMString() { return "1"; }
15202 };
15203 template <> struct TagToType<0x0040,0x1400> {
15204 static const char* GetVRString() { return "LT"; }
15205 typedef VRToType<VR::LT>::Type Type;
15206 enum : long long { VRType = VR::LT };
15207 enum { VMType = VM::VM1 };
15208 static const char* GetVMString() { return "1"; }
15209 };
15210 template <> struct TagToType<0x0040,0x2001> {
15211 static const char* GetVRString() { return "LO"; }
15212 typedef VRToType<VR::LO>::Type Type;
15213 enum : long long { VRType = VR::LO };
15214 enum { VMType = VM::VM1 };
15215 static const char* GetVMString() { return "1"; }
15216 };
15217 template <> struct TagToType<0x0040,0x2004> {
15218 static const char* GetVRString() { return "DA"; }
15219 typedef VRToType<VR::DA>::Type Type;
15220 enum : long long { VRType = VR::DA };
15221 enum { VMType = VM::VM1 };
15222 static const char* GetVMString() { return "1"; }
15223 };
15224 template <> struct TagToType<0x0040,0x2005> {
15225 static const char* GetVRString() { return "TM"; }
15226 typedef VRToType<VR::TM>::Type Type;
15227 enum : long long { VRType = VR::TM };
15228 enum { VMType = VM::VM1 };
15229 static const char* GetVMString() { return "1"; }
15230 };
15231 template <> struct TagToType<0x0040,0x2006> {
15232 static const char* GetVRString() { return "SH"; }
15233 typedef VRToType<VR::SH>::Type Type;
15234 enum : long long { VRType = VR::SH };
15235 enum { VMType = VM::VM1 };
15236 static const char* GetVMString() { return "1"; }
15237 };
15238 template <> struct TagToType<0x0040,0x2007> {
15239 static const char* GetVRString() { return "SH"; }
15240 typedef VRToType<VR::SH>::Type Type;
15241 enum : long long { VRType = VR::SH };
15242 enum { VMType = VM::VM1 };
15243 static const char* GetVMString() { return "1"; }
15244 };
15245 template <> struct TagToType<0x0040,0x2008> {
15246 static const char* GetVRString() { return "PN"; }
15247 typedef VRToType<VR::PN>::Type Type;
15248 enum : long long { VRType = VR::PN };
15249 enum { VMType = VM::VM1 };
15250 static const char* GetVMString() { return "1"; }
15251 };
15252 template <> struct TagToType<0x0040,0x2009> {
15253 static const char* GetVRString() { return "SH"; }
15254 typedef VRToType<VR::SH>::Type Type;
15255 enum : long long { VRType = VR::SH };
15256 enum { VMType = VM::VM1 };
15257 static const char* GetVMString() { return "1"; }
15258 };
15259 template <> struct TagToType<0x0040,0x2010> {
15260 static const char* GetVRString() { return "SH"; }
15261 typedef VRToType<VR::SH>::Type Type;
15262 enum : long long { VRType = VR::SH };
15263 enum { VMType = VM::VM1 };
15264 static const char* GetVMString() { return "1"; }
15265 };
15266 template <> struct TagToType<0x0040,0x2011> {
15267 static const char* GetVRString() { return "LT"; }
15268 typedef VRToType<VR::LT>::Type Type;
15269 enum : long long { VRType = VR::LT };
15270 enum { VMType = VM::VM1 };
15271 static const char* GetVMString() { return "1"; }
15272 };
15273 template <> struct TagToType<0x0040,0x2016> {
15274 static const char* GetVRString() { return "LO"; }
15275 typedef VRToType<VR::LO>::Type Type;
15276 enum : long long { VRType = VR::LO };
15277 enum { VMType = VM::VM1 };
15278 static const char* GetVMString() { return "1"; }
15279 };
15280 template <> struct TagToType<0x0040,0x2017> {
15281 static const char* GetVRString() { return "LO"; }
15282 typedef VRToType<VR::LO>::Type Type;
15283 enum : long long { VRType = VR::LO };
15284 enum { VMType = VM::VM1 };
15285 static const char* GetVMString() { return "1"; }
15286 };
15287 template <> struct TagToType<0x0040,0x2400> {
15288 static const char* GetVRString() { return "LT"; }
15289 typedef VRToType<VR::LT>::Type Type;
15290 enum : long long { VRType = VR::LT };
15291 enum { VMType = VM::VM1 };
15292 static const char* GetVMString() { return "1"; }
15293 };
15294 template <> struct TagToType<0x0040,0x3001> {
15295 static const char* GetVRString() { return "LO"; }
15296 typedef VRToType<VR::LO>::Type Type;
15297 enum : long long { VRType = VR::LO };
15298 enum { VMType = VM::VM1 };
15299 static const char* GetVMString() { return "1"; }
15300 };
15301 template <> struct TagToType<0x0040,0x4001> {
15302 static const char* GetVRString() { return "CS"; }
15303 typedef VRToType<VR::CS>::Type Type;
15304 enum : long long { VRType = VR::CS };
15305 enum { VMType = VM::VM1 };
15306 static const char* GetVMString() { return "1"; }
15307 };
15308 template <> struct TagToType<0x0040,0x4002> {
15309 static const char* GetVRString() { return "CS"; }
15310 typedef VRToType<VR::CS>::Type Type;
15311 enum : long long { VRType = VR::CS };
15312 enum { VMType = VM::VM1 };
15313 static const char* GetVMString() { return "1"; }
15314 };
15315 template <> struct TagToType<0x0040,0x4003> {
15316 static const char* GetVRString() { return "CS"; }
15317 typedef VRToType<VR::CS>::Type Type;
15318 enum : long long { VRType = VR::CS };
15319 enum { VMType = VM::VM1 };
15320 static const char* GetVMString() { return "1"; }
15321 };
15322 template <> struct TagToType<0x0040,0x4004> {
15323 static const char* GetVRString() { return "SQ"; }
15324 typedef VRToType<VR::SQ>::Type Type;
15325 enum : long long { VRType = VR::SQ };
15326 enum { VMType = VM::VM1 };
15327 static const char* GetVMString() { return "1"; }
15328 };
15329 template <> struct TagToType<0x0040,0x4005> {
15330 static const char* GetVRString() { return "DT"; }
15331 typedef VRToType<VR::DT>::Type Type;
15332 enum : long long { VRType = VR::DT };
15333 enum { VMType = VM::VM1 };
15334 static const char* GetVMString() { return "1"; }
15335 };
15336 template <> struct TagToType<0x0040,0x4006> {
15337 static const char* GetVRString() { return "CS"; }
15338 typedef VRToType<VR::CS>::Type Type;
15339 enum : long long { VRType = VR::CS };
15340 enum { VMType = VM::VM1 };
15341 static const char* GetVMString() { return "1"; }
15342 };
15343 template <> struct TagToType<0x0040,0x4007> {
15344 static const char* GetVRString() { return "SQ"; }
15345 typedef VRToType<VR::SQ>::Type Type;
15346 enum : long long { VRType = VR::SQ };
15347 enum { VMType = VM::VM1 };
15348 static const char* GetVMString() { return "1"; }
15349 };
15350 template <> struct TagToType<0x0040,0x4009> {
15351 static const char* GetVRString() { return "SQ"; }
15352 typedef VRToType<VR::SQ>::Type Type;
15353 enum : long long { VRType = VR::SQ };
15354 enum { VMType = VM::VM1 };
15355 static const char* GetVMString() { return "1"; }
15356 };
15357 template <> struct TagToType<0x0040,0x4010> {
15358 static const char* GetVRString() { return "DT"; }
15359 typedef VRToType<VR::DT>::Type Type;
15360 enum : long long { VRType = VR::DT };
15361 enum { VMType = VM::VM1 };
15362 static const char* GetVMString() { return "1"; }
15363 };
15364 template <> struct TagToType<0x0040,0x4011> {
15365 static const char* GetVRString() { return "DT"; }
15366 typedef VRToType<VR::DT>::Type Type;
15367 enum : long long { VRType = VR::DT };
15368 enum { VMType = VM::VM1 };
15369 static const char* GetVMString() { return "1"; }
15370 };
15371 template <> struct TagToType<0x0040,0x4015> {
15372 static const char* GetVRString() { return "SQ"; }
15373 typedef VRToType<VR::SQ>::Type Type;
15374 enum : long long { VRType = VR::SQ };
15375 enum { VMType = VM::VM1 };
15376 static const char* GetVMString() { return "1"; }
15377 };
15378 template <> struct TagToType<0x0040,0x4016> {
15379 static const char* GetVRString() { return "SQ"; }
15380 typedef VRToType<VR::SQ>::Type Type;
15381 enum : long long { VRType = VR::SQ };
15382 enum { VMType = VM::VM1 };
15383 static const char* GetVMString() { return "1"; }
15384 };
15385 template <> struct TagToType<0x0040,0x4018> {
15386 static const char* GetVRString() { return "SQ"; }
15387 typedef VRToType<VR::SQ>::Type Type;
15388 enum : long long { VRType = VR::SQ };
15389 enum { VMType = VM::VM1 };
15390 static const char* GetVMString() { return "1"; }
15391 };
15392 template <> struct TagToType<0x0040,0x4019> {
15393 static const char* GetVRString() { return "SQ"; }
15394 typedef VRToType<VR::SQ>::Type Type;
15395 enum : long long { VRType = VR::SQ };
15396 enum { VMType = VM::VM1 };
15397 static const char* GetVMString() { return "1"; }
15398 };
15399 template <> struct TagToType<0x0040,0x4020> {
15400 static const char* GetVRString() { return "CS"; }
15401 typedef VRToType<VR::CS>::Type Type;
15402 enum : long long { VRType = VR::CS };
15403 enum { VMType = VM::VM1 };
15404 static const char* GetVMString() { return "1"; }
15405 };
15406 template <> struct TagToType<0x0040,0x4021> {
15407 static const char* GetVRString() { return "SQ"; }
15408 typedef VRToType<VR::SQ>::Type Type;
15409 enum : long long { VRType = VR::SQ };
15410 enum { VMType = VM::VM1 };
15411 static const char* GetVMString() { return "1"; }
15412 };
15413 template <> struct TagToType<0x0040,0x4022> {
15414 static const char* GetVRString() { return "SQ"; }
15415 typedef VRToType<VR::SQ>::Type Type;
15416 enum : long long { VRType = VR::SQ };
15417 enum { VMType = VM::VM1 };
15418 static const char* GetVMString() { return "1"; }
15419 };
15420 template <> struct TagToType<0x0040,0x4023> {
15421 static const char* GetVRString() { return "UI"; }
15422 typedef VRToType<VR::UI>::Type Type;
15423 enum : long long { VRType = VR::UI };
15424 enum { VMType = VM::VM1 };
15425 static const char* GetVMString() { return "1"; }
15426 };
15427 template <> struct TagToType<0x0040,0x4025> {
15428 static const char* GetVRString() { return "SQ"; }
15429 typedef VRToType<VR::SQ>::Type Type;
15430 enum : long long { VRType = VR::SQ };
15431 enum { VMType = VM::VM1 };
15432 static const char* GetVMString() { return "1"; }
15433 };
15434 template <> struct TagToType<0x0040,0x4026> {
15435 static const char* GetVRString() { return "SQ"; }
15436 typedef VRToType<VR::SQ>::Type Type;
15437 enum : long long { VRType = VR::SQ };
15438 enum { VMType = VM::VM1 };
15439 static const char* GetVMString() { return "1"; }
15440 };
15441 template <> struct TagToType<0x0040,0x4027> {
15442 static const char* GetVRString() { return "SQ"; }
15443 typedef VRToType<VR::SQ>::Type Type;
15444 enum : long long { VRType = VR::SQ };
15445 enum { VMType = VM::VM1 };
15446 static const char* GetVMString() { return "1"; }
15447 };
15448 template <> struct TagToType<0x0040,0x4028> {
15449 static const char* GetVRString() { return "SQ"; }
15450 typedef VRToType<VR::SQ>::Type Type;
15451 enum : long long { VRType = VR::SQ };
15452 enum { VMType = VM::VM1 };
15453 static const char* GetVMString() { return "1"; }
15454 };
15455 template <> struct TagToType<0x0040,0x4029> {
15456 static const char* GetVRString() { return "SQ"; }
15457 typedef VRToType<VR::SQ>::Type Type;
15458 enum : long long { VRType = VR::SQ };
15459 enum { VMType = VM::VM1 };
15460 static const char* GetVMString() { return "1"; }
15461 };
15462 template <> struct TagToType<0x0040,0x4030> {
15463 static const char* GetVRString() { return "SQ"; }
15464 typedef VRToType<VR::SQ>::Type Type;
15465 enum : long long { VRType = VR::SQ };
15466 enum { VMType = VM::VM1 };
15467 static const char* GetVMString() { return "1"; }
15468 };
15469 template <> struct TagToType<0x0040,0x4031> {
15470 static const char* GetVRString() { return "SQ"; }
15471 typedef VRToType<VR::SQ>::Type Type;
15472 enum : long long { VRType = VR::SQ };
15473 enum { VMType = VM::VM1 };
15474 static const char* GetVMString() { return "1"; }
15475 };
15476 template <> struct TagToType<0x0040,0x4032> {
15477 static const char* GetVRString() { return "SQ"; }
15478 typedef VRToType<VR::SQ>::Type Type;
15479 enum : long long { VRType = VR::SQ };
15480 enum { VMType = VM::VM1 };
15481 static const char* GetVMString() { return "1"; }
15482 };
15483 template <> struct TagToType<0x0040,0x4033> {
15484 static const char* GetVRString() { return "SQ"; }
15485 typedef VRToType<VR::SQ>::Type Type;
15486 enum : long long { VRType = VR::SQ };
15487 enum { VMType = VM::VM1 };
15488 static const char* GetVMString() { return "1"; }
15489 };
15490 template <> struct TagToType<0x0040,0x4034> {
15491 static const char* GetVRString() { return "SQ"; }
15492 typedef VRToType<VR::SQ>::Type Type;
15493 enum : long long { VRType = VR::SQ };
15494 enum { VMType = VM::VM1 };
15495 static const char* GetVMString() { return "1"; }
15496 };
15497 template <> struct TagToType<0x0040,0x4035> {
15498 static const char* GetVRString() { return "SQ"; }
15499 typedef VRToType<VR::SQ>::Type Type;
15500 enum : long long { VRType = VR::SQ };
15501 enum { VMType = VM::VM1 };
15502 static const char* GetVMString() { return "1"; }
15503 };
15504 template <> struct TagToType<0x0040,0x4036> {
15505 static const char* GetVRString() { return "LO"; }
15506 typedef VRToType<VR::LO>::Type Type;
15507 enum : long long { VRType = VR::LO };
15508 enum { VMType = VM::VM1 };
15509 static const char* GetVMString() { return "1"; }
15510 };
15511 template <> struct TagToType<0x0040,0x4037> {
15512 static const char* GetVRString() { return "PN"; }
15513 typedef VRToType<VR::PN>::Type Type;
15514 enum : long long { VRType = VR::PN };
15515 enum { VMType = VM::VM1 };
15516 static const char* GetVMString() { return "1"; }
15517 };
15518 template <> struct TagToType<0x0040,0x4040> {
15519 static const char* GetVRString() { return "CS"; }
15520 typedef VRToType<VR::CS>::Type Type;
15521 enum : long long { VRType = VR::CS };
15522 enum { VMType = VM::VM1 };
15523 static const char* GetVMString() { return "1"; }
15524 };
15525 template <> struct TagToType<0x0040,0x4041> {
15526 static const char* GetVRString() { return "CS"; }
15527 typedef VRToType<VR::CS>::Type Type;
15528 enum : long long { VRType = VR::CS };
15529 enum { VMType = VM::VM1 };
15530 static const char* GetVMString() { return "1"; }
15531 };
15532 template <> struct TagToType<0x0040,0x4050> {
15533 static const char* GetVRString() { return "DT"; }
15534 typedef VRToType<VR::DT>::Type Type;
15535 enum : long long { VRType = VR::DT };
15536 enum { VMType = VM::VM1 };
15537 static const char* GetVMString() { return "1"; }
15538 };
15539 template <> struct TagToType<0x0040,0x4051> {
15540 static const char* GetVRString() { return "DT"; }
15541 typedef VRToType<VR::DT>::Type Type;
15542 enum : long long { VRType = VR::DT };
15543 enum { VMType = VM::VM1 };
15544 static const char* GetVMString() { return "1"; }
15545 };
15546 template <> struct TagToType<0x0040,0x4052> {
15547 static const char* GetVRString() { return "DT"; }
15548 typedef VRToType<VR::DT>::Type Type;
15549 enum : long long { VRType = VR::DT };
15550 enum { VMType = VM::VM1 };
15551 static const char* GetVMString() { return "1"; }
15552 };
15553 template <> struct TagToType<0x0040,0x4070> {
15554 static const char* GetVRString() { return "SQ"; }
15555 typedef VRToType<VR::SQ>::Type Type;
15556 enum : long long { VRType = VR::SQ };
15557 enum { VMType = VM::VM1 };
15558 static const char* GetVMString() { return "1"; }
15559 };
15560 template <> struct TagToType<0x0040,0x4071> {
15561 static const char* GetVRString() { return "SQ"; }
15562 typedef VRToType<VR::SQ>::Type Type;
15563 enum : long long { VRType = VR::SQ };
15564 enum { VMType = VM::VM1 };
15565 static const char* GetVMString() { return "1"; }
15566 };
15567 template <> struct TagToType<0x0040,0x4072> {
15568 static const char* GetVRString() { return "SQ"; }
15569 typedef VRToType<VR::SQ>::Type Type;
15570 enum : long long { VRType = VR::SQ };
15571 enum { VMType = VM::VM1 };
15572 static const char* GetVMString() { return "1"; }
15573 };
15574 template <> struct TagToType<0x0040,0x4073> {
15575 static const char* GetVRString() { return "UR"; }
15576 typedef VRToType<VR::UR>::Type Type;
15577 enum : long long { VRType = VR::UR };
15578 enum { VMType = VM::VM1 };
15579 static const char* GetVMString() { return "1"; }
15580 };
15581 template <> struct TagToType<0x0040,0x4074> {
15582 static const char* GetVRString() { return "SQ"; }
15583 typedef VRToType<VR::SQ>::Type Type;
15584 enum : long long { VRType = VR::SQ };
15585 enum { VMType = VM::VM1 };
15586 static const char* GetVMString() { return "1"; }
15587 };
15588 template <> struct TagToType<0x0040,0x8302> {
15589 static const char* GetVRString() { return "DS"; }
15590 typedef VRToType<VR::DS>::Type Type;
15591 enum : long long { VRType = VR::DS };
15592 enum { VMType = VM::VM1 };
15593 static const char* GetVMString() { return "1"; }
15594 };
15595 template <> struct TagToType<0x0040,0x9092> {
15596 static const char* GetVRString() { return "SQ"; }
15597 typedef VRToType<VR::SQ>::Type Type;
15598 enum : long long { VRType = VR::SQ };
15599 enum { VMType = VM::VM1 };
15600 static const char* GetVMString() { return "1"; }
15601 };
15602 template <> struct TagToType<0x0040,0x9094> {
15603 static const char* GetVRString() { return "SQ"; }
15604 typedef VRToType<VR::SQ>::Type Type;
15605 enum : long long { VRType = VR::SQ };
15606 enum { VMType = VM::VM1 };
15607 static const char* GetVMString() { return "1"; }
15608 };
15609 template <> struct TagToType<0x0040,0x9096> {
15610 static const char* GetVRString() { return "SQ"; }
15611 typedef VRToType<VR::SQ>::Type Type;
15612 enum : long long { VRType = VR::SQ };
15613 enum { VMType = VM::VM1 };
15614 static const char* GetVMString() { return "1"; }
15615 };
15616 template <> struct TagToType<0x0040,0x9098> {
15617 static const char* GetVRString() { return "SQ"; }
15618 typedef VRToType<VR::SQ>::Type Type;
15619 enum : long long { VRType = VR::SQ };
15620 enum { VMType = VM::VM1 };
15621 static const char* GetVMString() { return "1"; }
15622 };
15623 template <> struct TagToType<0x0040,0x9210> {
15624 static const char* GetVRString() { return "SH"; }
15625 typedef VRToType<VR::SH>::Type Type;
15626 enum : long long { VRType = VR::SH };
15627 enum { VMType = VM::VM1 };
15628 static const char* GetVMString() { return "1"; }
15629 };
15630 template <> struct TagToType<0x0040,0x9212> {
15631 static const char* GetVRString() { return "FD"; }
15632 typedef VRToType<VR::FD>::Type Type;
15633 enum : long long { VRType = VR::FD };
15634 enum { VMType = VM::VM1_n };
15635 static const char* GetVMString() { return "1-n"; }
15636 };
15637 template <> struct TagToType<0x0040,0x9213> {
15638 static const char* GetVRString() { return "FD"; }
15639 typedef VRToType<VR::FD>::Type Type;
15640 enum : long long { VRType = VR::FD };
15641 enum { VMType = VM::VM1 };
15642 static const char* GetVMString() { return "1"; }
15643 };
15644 template <> struct TagToType<0x0040,0x9214> {
15645 static const char* GetVRString() { return "FD"; }
15646 typedef VRToType<VR::FD>::Type Type;
15647 enum : long long { VRType = VR::FD };
15648 enum { VMType = VM::VM1 };
15649 static const char* GetVMString() { return "1"; }
15650 };
15651 template <> struct TagToType<0x0040,0x9220> {
15652 static const char* GetVRString() { return "SQ"; }
15653 typedef VRToType<VR::SQ>::Type Type;
15654 enum : long long { VRType = VR::SQ };
15655 enum { VMType = VM::VM1 };
15656 static const char* GetVMString() { return "1"; }
15657 };
15658 template <> struct TagToType<0x0040,0x9224> {
15659 static const char* GetVRString() { return "FD"; }
15660 typedef VRToType<VR::FD>::Type Type;
15661 enum : long long { VRType = VR::FD };
15662 enum { VMType = VM::VM1 };
15663 static const char* GetVMString() { return "1"; }
15664 };
15665 template <> struct TagToType<0x0040,0x9225> {
15666 static const char* GetVRString() { return "FD"; }
15667 typedef VRToType<VR::FD>::Type Type;
15668 enum : long long { VRType = VR::FD };
15669 enum { VMType = VM::VM1 };
15670 static const char* GetVMString() { return "1"; }
15671 };
15672 template <> struct TagToType<0x0040,0xa007> {
15673 static const char* GetVRString() { return "CS"; }
15674 typedef VRToType<VR::CS>::Type Type;
15675 enum : long long { VRType = VR::CS };
15676 enum { VMType = VM::VM1 };
15677 static const char* GetVMString() { return "1"; }
15678 };
15679 template <> struct TagToType<0x0040,0xa010> {
15680 static const char* GetVRString() { return "CS"; }
15681 typedef VRToType<VR::CS>::Type Type;
15682 enum : long long { VRType = VR::CS };
15683 enum { VMType = VM::VM1 };
15684 static const char* GetVMString() { return "1"; }
15685 };
15686 template <> struct TagToType<0x0040,0xa020> {
15687 static const char* GetVRString() { return "SQ"; }
15688 typedef VRToType<VR::SQ>::Type Type;
15689 enum : long long { VRType = VR::SQ };
15690 enum { VMType = VM::VM1 };
15691 static const char* GetVMString() { return "1"; }
15692 };
15693 template <> struct TagToType<0x0040,0xa021> {
15694 static const char* GetVRString() { return "UI"; }
15695 typedef VRToType<VR::UI>::Type Type;
15696 enum : long long { VRType = VR::UI };
15697 enum { VMType = VM::VM1 };
15698 static const char* GetVMString() { return "1"; }
15699 };
15700 template <> struct TagToType<0x0040,0xa022> {
15701 static const char* GetVRString() { return "UI"; }
15702 typedef VRToType<VR::UI>::Type Type;
15703 enum : long long { VRType = VR::UI };
15704 enum { VMType = VM::VM1 };
15705 static const char* GetVMString() { return "1"; }
15706 };
15707 template <> struct TagToType<0x0040,0xa023> {
15708 static const char* GetVRString() { return "DA"; }
15709 typedef VRToType<VR::DA>::Type Type;
15710 enum : long long { VRType = VR::DA };
15711 enum { VMType = VM::VM1 };
15712 static const char* GetVMString() { return "1"; }
15713 };
15714 template <> struct TagToType<0x0040,0xa024> {
15715 static const char* GetVRString() { return "TM"; }
15716 typedef VRToType<VR::TM>::Type Type;
15717 enum : long long { VRType = VR::TM };
15718 enum { VMType = VM::VM1 };
15719 static const char* GetVMString() { return "1"; }
15720 };
15721 template <> struct TagToType<0x0040,0xa026> {
15722 static const char* GetVRString() { return "SQ"; }
15723 typedef VRToType<VR::SQ>::Type Type;
15724 enum : long long { VRType = VR::SQ };
15725 enum { VMType = VM::VM1 };
15726 static const char* GetVMString() { return "1"; }
15727 };
15728 template <> struct TagToType<0x0040,0xa027> {
15729 static const char* GetVRString() { return "LO"; }
15730 typedef VRToType<VR::LO>::Type Type;
15731 enum : long long { VRType = VR::LO };
15732 enum { VMType = VM::VM1 };
15733 static const char* GetVMString() { return "1"; }
15734 };
15735 template <> struct TagToType<0x0040,0xa028> {
15736 static const char* GetVRString() { return "SQ"; }
15737 typedef VRToType<VR::SQ>::Type Type;
15738 enum : long long { VRType = VR::SQ };
15739 enum { VMType = VM::VM1 };
15740 static const char* GetVMString() { return "1"; }
15741 };
15742 template <> struct TagToType<0x0040,0xa030> {
15743 static const char* GetVRString() { return "DT"; }
15744 typedef VRToType<VR::DT>::Type Type;
15745 enum : long long { VRType = VR::DT };
15746 enum { VMType = VM::VM1 };
15747 static const char* GetVMString() { return "1"; }
15748 };
15749 template <> struct TagToType<0x0040,0xa032> {
15750 static const char* GetVRString() { return "DT"; }
15751 typedef VRToType<VR::DT>::Type Type;
15752 enum : long long { VRType = VR::DT };
15753 enum { VMType = VM::VM1 };
15754 static const char* GetVMString() { return "1"; }
15755 };
15756 template <> struct TagToType<0x0040,0xa040> {
15757 static const char* GetVRString() { return "CS"; }
15758 typedef VRToType<VR::CS>::Type Type;
15759 enum : long long { VRType = VR::CS };
15760 enum { VMType = VM::VM1 };
15761 static const char* GetVMString() { return "1"; }
15762 };
15763 template <> struct TagToType<0x0040,0xa043> {
15764 static const char* GetVRString() { return "SQ"; }
15765 typedef VRToType<VR::SQ>::Type Type;
15766 enum : long long { VRType = VR::SQ };
15767 enum { VMType = VM::VM1 };
15768 static const char* GetVMString() { return "1"; }
15769 };
15770 template <> struct TagToType<0x0040,0xa047> {
15771 static const char* GetVRString() { return "LO"; }
15772 typedef VRToType<VR::LO>::Type Type;
15773 enum : long long { VRType = VR::LO };
15774 enum { VMType = VM::VM1 };
15775 static const char* GetVMString() { return "1"; }
15776 };
15777 template <> struct TagToType<0x0040,0xa050> {
15778 static const char* GetVRString() { return "CS"; }
15779 typedef VRToType<VR::CS>::Type Type;
15780 enum : long long { VRType = VR::CS };
15781 enum { VMType = VM::VM1 };
15782 static const char* GetVMString() { return "1"; }
15783 };
15784 template <> struct TagToType<0x0040,0xa057> {
15785 static const char* GetVRString() { return "CS"; }
15786 typedef VRToType<VR::CS>::Type Type;
15787 enum : long long { VRType = VR::CS };
15788 enum { VMType = VM::VM1_n };
15789 static const char* GetVMString() { return "1-n"; }
15790 };
15791 template <> struct TagToType<0x0040,0xa060> {
15792 static const char* GetVRString() { return "LO"; }
15793 typedef VRToType<VR::LO>::Type Type;
15794 enum : long long { VRType = VR::LO };
15795 enum { VMType = VM::VM1 };
15796 static const char* GetVMString() { return "1"; }
15797 };
15798 template <> struct TagToType<0x0040,0xa066> {
15799 static const char* GetVRString() { return "SQ"; }
15800 typedef VRToType<VR::SQ>::Type Type;
15801 enum : long long { VRType = VR::SQ };
15802 enum { VMType = VM::VM1 };
15803 static const char* GetVMString() { return "1"; }
15804 };
15805 template <> struct TagToType<0x0040,0xa067> {
15806 static const char* GetVRString() { return "PN"; }
15807 typedef VRToType<VR::PN>::Type Type;
15808 enum : long long { VRType = VR::PN };
15809 enum { VMType = VM::VM1 };
15810 static const char* GetVMString() { return "1"; }
15811 };
15812 template <> struct TagToType<0x0040,0xa068> {
15813 static const char* GetVRString() { return "SQ"; }
15814 typedef VRToType<VR::SQ>::Type Type;
15815 enum : long long { VRType = VR::SQ };
15816 enum { VMType = VM::VM1 };
15817 static const char* GetVMString() { return "1"; }
15818 };
15819 template <> struct TagToType<0x0040,0xa070> {
15820 static const char* GetVRString() { return "SQ"; }
15821 typedef VRToType<VR::SQ>::Type Type;
15822 enum : long long { VRType = VR::SQ };
15823 enum { VMType = VM::VM1 };
15824 static const char* GetVMString() { return "1"; }
15825 };
15826 template <> struct TagToType<0x0040,0xa073> {
15827 static const char* GetVRString() { return "SQ"; }
15828 typedef VRToType<VR::SQ>::Type Type;
15829 enum : long long { VRType = VR::SQ };
15830 enum { VMType = VM::VM1 };
15831 static const char* GetVMString() { return "1"; }
15832 };
15833 template <> struct TagToType<0x0040,0xa074> {
15834 static const char* GetVRString() { return "OB"; }
15835 typedef VRToType<VR::OB>::Type Type;
15836 enum : long long { VRType = VR::OB };
15837 enum { VMType = VM::VM1 };
15838 static const char* GetVMString() { return "1"; }
15839 };
15840 template <> struct TagToType<0x0040,0xa075> {
15841 static const char* GetVRString() { return "PN"; }
15842 typedef VRToType<VR::PN>::Type Type;
15843 enum : long long { VRType = VR::PN };
15844 enum { VMType = VM::VM1 };
15845 static const char* GetVMString() { return "1"; }
15846 };
15847 template <> struct TagToType<0x0040,0xa076> {
15848 static const char* GetVRString() { return "SQ"; }
15849 typedef VRToType<VR::SQ>::Type Type;
15850 enum : long long { VRType = VR::SQ };
15851 enum { VMType = VM::VM1 };
15852 static const char* GetVMString() { return "1"; }
15853 };
15854 template <> struct TagToType<0x0040,0xa078> {
15855 static const char* GetVRString() { return "SQ"; }
15856 typedef VRToType<VR::SQ>::Type Type;
15857 enum : long long { VRType = VR::SQ };
15858 enum { VMType = VM::VM1 };
15859 static const char* GetVMString() { return "1"; }
15860 };
15861 template <> struct TagToType<0x0040,0xa07a> {
15862 static const char* GetVRString() { return "SQ"; }
15863 typedef VRToType<VR::SQ>::Type Type;
15864 enum : long long { VRType = VR::SQ };
15865 enum { VMType = VM::VM1 };
15866 static const char* GetVMString() { return "1"; }
15867 };
15868 template <> struct TagToType<0x0040,0xa07c> {
15869 static const char* GetVRString() { return "SQ"; }
15870 typedef VRToType<VR::SQ>::Type Type;
15871 enum : long long { VRType = VR::SQ };
15872 enum { VMType = VM::VM1 };
15873 static const char* GetVMString() { return "1"; }
15874 };
15875 template <> struct TagToType<0x0040,0xa080> {
15876 static const char* GetVRString() { return "CS"; }
15877 typedef VRToType<VR::CS>::Type Type;
15878 enum : long long { VRType = VR::CS };
15879 enum { VMType = VM::VM1 };
15880 static const char* GetVMString() { return "1"; }
15881 };
15882 template <> struct TagToType<0x0040,0xa082> {
15883 static const char* GetVRString() { return "DT"; }
15884 typedef VRToType<VR::DT>::Type Type;
15885 enum : long long { VRType = VR::DT };
15886 enum { VMType = VM::VM1 };
15887 static const char* GetVMString() { return "1"; }
15888 };
15889 template <> struct TagToType<0x0040,0xa084> {
15890 static const char* GetVRString() { return "CS"; }
15891 typedef VRToType<VR::CS>::Type Type;
15892 enum : long long { VRType = VR::CS };
15893 enum { VMType = VM::VM1 };
15894 static const char* GetVMString() { return "1"; }
15895 };
15896 template <> struct TagToType<0x0040,0xa085> {
15897 static const char* GetVRString() { return "SQ"; }
15898 typedef VRToType<VR::SQ>::Type Type;
15899 enum : long long { VRType = VR::SQ };
15900 enum { VMType = VM::VM1 };
15901 static const char* GetVMString() { return "1"; }
15902 };
15903 template <> struct TagToType<0x0040,0xa088> {
15904 static const char* GetVRString() { return "SQ"; }
15905 typedef VRToType<VR::SQ>::Type Type;
15906 enum : long long { VRType = VR::SQ };
15907 enum { VMType = VM::VM1 };
15908 static const char* GetVMString() { return "1"; }
15909 };
15910 template <> struct TagToType<0x0040,0xa089> {
15911 static const char* GetVRString() { return "OB"; }
15912 typedef VRToType<VR::OB>::Type Type;
15913 enum : long long { VRType = VR::OB };
15914 enum { VMType = VM::VM1 };
15915 static const char* GetVMString() { return "1"; }
15916 };
15917 template <> struct TagToType<0x0040,0xa090> {
15918 static const char* GetVRString() { return "SQ"; }
15919 typedef VRToType<VR::SQ>::Type Type;
15920 enum : long long { VRType = VR::SQ };
15921 enum { VMType = VM::VM1 };
15922 static const char* GetVMString() { return "1"; }
15923 };
15924 template <> struct TagToType<0x0040,0xa0b0> {
15925 static const char* GetVRString() { return "US"; }
15926 typedef VRToType<VR::US>::Type Type;
15927 enum : long long { VRType = VR::US };
15928 enum { VMType = VM::VM2_2n };
15929 static const char* GetVMString() { return "2-2n"; }
15930 };
15931 template <> struct TagToType<0x0040,0xa110> {
15932 static const char* GetVRString() { return "DA"; }
15933 typedef VRToType<VR::DA>::Type Type;
15934 enum : long long { VRType = VR::DA };
15935 enum { VMType = VM::VM1 };
15936 static const char* GetVMString() { return "1"; }
15937 };
15938 template <> struct TagToType<0x0040,0xa112> {
15939 static const char* GetVRString() { return "TM"; }
15940 typedef VRToType<VR::TM>::Type Type;
15941 enum : long long { VRType = VR::TM };
15942 enum { VMType = VM::VM1 };
15943 static const char* GetVMString() { return "1"; }
15944 };
15945 template <> struct TagToType<0x0040,0xa120> {
15946 static const char* GetVRString() { return "DT"; }
15947 typedef VRToType<VR::DT>::Type Type;
15948 enum : long long { VRType = VR::DT };
15949 enum { VMType = VM::VM1 };
15950 static const char* GetVMString() { return "1"; }
15951 };
15952 template <> struct TagToType<0x0040,0xa121> {
15953 static const char* GetVRString() { return "DA"; }
15954 typedef VRToType<VR::DA>::Type Type;
15955 enum : long long { VRType = VR::DA };
15956 enum { VMType = VM::VM1 };
15957 static const char* GetVMString() { return "1"; }
15958 };
15959 template <> struct TagToType<0x0040,0xa122> {
15960 static const char* GetVRString() { return "TM"; }
15961 typedef VRToType<VR::TM>::Type Type;
15962 enum : long long { VRType = VR::TM };
15963 enum { VMType = VM::VM1 };
15964 static const char* GetVMString() { return "1"; }
15965 };
15966 template <> struct TagToType<0x0040,0xa123> {
15967 static const char* GetVRString() { return "PN"; }
15968 typedef VRToType<VR::PN>::Type Type;
15969 enum : long long { VRType = VR::PN };
15970 enum { VMType = VM::VM1 };
15971 static const char* GetVMString() { return "1"; }
15972 };
15973 template <> struct TagToType<0x0040,0xa124> {
15974 static const char* GetVRString() { return "UI"; }
15975 typedef VRToType<VR::UI>::Type Type;
15976 enum : long long { VRType = VR::UI };
15977 enum { VMType = VM::VM1 };
15978 static const char* GetVMString() { return "1"; }
15979 };
15980 template <> struct TagToType<0x0040,0xa125> {
15981 static const char* GetVRString() { return "CS"; }
15982 typedef VRToType<VR::CS>::Type Type;
15983 enum : long long { VRType = VR::CS };
15984 enum { VMType = VM::VM2 };
15985 static const char* GetVMString() { return "2"; }
15986 };
15987 template <> struct TagToType<0x0040,0xa130> {
15988 static const char* GetVRString() { return "CS"; }
15989 typedef VRToType<VR::CS>::Type Type;
15990 enum : long long { VRType = VR::CS };
15991 enum { VMType = VM::VM1 };
15992 static const char* GetVMString() { return "1"; }
15993 };
15994 template <> struct TagToType<0x0040,0xa132> {
15995 static const char* GetVRString() { return "UL"; }
15996 typedef VRToType<VR::UL>::Type Type;
15997 enum : long long { VRType = VR::UL };
15998 enum { VMType = VM::VM1_n };
15999 static const char* GetVMString() { return "1-n"; }
16000 };
16001 template <> struct TagToType<0x0040,0xa136> {
16002 static const char* GetVRString() { return "US"; }
16003 typedef VRToType<VR::US>::Type Type;
16004 enum : long long { VRType = VR::US };
16005 enum { VMType = VM::VM1_n };
16006 static const char* GetVMString() { return "1-n"; }
16007 };
16008 template <> struct TagToType<0x0040,0xa138> {
16009 static const char* GetVRString() { return "DS"; }
16010 typedef VRToType<VR::DS>::Type Type;
16011 enum : long long { VRType = VR::DS };
16012 enum { VMType = VM::VM1_n };
16013 static const char* GetVMString() { return "1-n"; }
16014 };
16015 template <> struct TagToType<0x0040,0xa13a> {
16016 static const char* GetVRString() { return "DT"; }
16017 typedef VRToType<VR::DT>::Type Type;
16018 enum : long long { VRType = VR::DT };
16019 enum { VMType = VM::VM1_n };
16020 static const char* GetVMString() { return "1-n"; }
16021 };
16022 template <> struct TagToType<0x0040,0xa160> {
16023 static const char* GetVRString() { return "UT"; }
16024 typedef VRToType<VR::UT>::Type Type;
16025 enum : long long { VRType = VR::UT };
16026 enum { VMType = VM::VM1 };
16027 static const char* GetVMString() { return "1"; }
16028 };
16029 template <> struct TagToType<0x0040,0xa161> {
16030 static const char* GetVRString() { return "FD"; }
16031 typedef VRToType<VR::FD>::Type Type;
16032 enum : long long { VRType = VR::FD };
16033 enum { VMType = VM::VM1_n };
16034 static const char* GetVMString() { return "1-n"; }
16035 };
16036 template <> struct TagToType<0x0040,0xa162> {
16037 static const char* GetVRString() { return "SL"; }
16038 typedef VRToType<VR::SL>::Type Type;
16039 enum : long long { VRType = VR::SL };
16040 enum { VMType = VM::VM1_n };
16041 static const char* GetVMString() { return "1-n"; }
16042 };
16043 template <> struct TagToType<0x0040,0xa163> {
16044 static const char* GetVRString() { return "UL"; }
16045 typedef VRToType<VR::UL>::Type Type;
16046 enum : long long { VRType = VR::UL };
16047 enum { VMType = VM::VM1_n };
16048 static const char* GetVMString() { return "1-n"; }
16049 };
16050 template <> struct TagToType<0x0040,0xa167> {
16051 static const char* GetVRString() { return "SQ"; }
16052 typedef VRToType<VR::SQ>::Type Type;
16053 enum : long long { VRType = VR::SQ };
16054 enum { VMType = VM::VM1 };
16055 static const char* GetVMString() { return "1"; }
16056 };
16057 template <> struct TagToType<0x0040,0xa168> {
16058 static const char* GetVRString() { return "SQ"; }
16059 typedef VRToType<VR::SQ>::Type Type;
16060 enum : long long { VRType = VR::SQ };
16061 enum { VMType = VM::VM1 };
16062 static const char* GetVMString() { return "1"; }
16063 };
16064 template <> struct TagToType<0x0040,0xa16a> {
16065 static const char* GetVRString() { return "ST"; }
16066 typedef VRToType<VR::ST>::Type Type;
16067 enum : long long { VRType = VR::ST };
16068 enum { VMType = VM::VM1 };
16069 static const char* GetVMString() { return "1"; }
16070 };
16071 template <> struct TagToType<0x0040,0xa170> {
16072 static const char* GetVRString() { return "SQ"; }
16073 typedef VRToType<VR::SQ>::Type Type;
16074 enum : long long { VRType = VR::SQ };
16075 enum { VMType = VM::VM1 };
16076 static const char* GetVMString() { return "1"; }
16077 };
16078 template <> struct TagToType<0x0040,0xa171> {
16079 static const char* GetVRString() { return "UI"; }
16080 typedef VRToType<VR::UI>::Type Type;
16081 enum : long long { VRType = VR::UI };
16082 enum { VMType = VM::VM1 };
16083 static const char* GetVMString() { return "1"; }
16084 };
16085 template <> struct TagToType<0x0040,0xa172> {
16086 static const char* GetVRString() { return "UI"; }
16087 typedef VRToType<VR::UI>::Type Type;
16088 enum : long long { VRType = VR::UI };
16089 enum { VMType = VM::VM1 };
16090 static const char* GetVMString() { return "1"; }
16091 };
16092 template <> struct TagToType<0x0040,0xa173> {
16093 static const char* GetVRString() { return "CS"; }
16094 typedef VRToType<VR::CS>::Type Type;
16095 enum : long long { VRType = VR::CS };
16096 enum { VMType = VM::VM1 };
16097 static const char* GetVMString() { return "1"; }
16098 };
16099 template <> struct TagToType<0x0040,0xa174> {
16100 static const char* GetVRString() { return "CS"; }
16101 typedef VRToType<VR::CS>::Type Type;
16102 enum : long long { VRType = VR::CS };
16103 enum { VMType = VM::VM1 };
16104 static const char* GetVMString() { return "1"; }
16105 };
16106 template <> struct TagToType<0x0040,0xa180> {
16107 static const char* GetVRString() { return "US"; }
16108 typedef VRToType<VR::US>::Type Type;
16109 enum : long long { VRType = VR::US };
16110 enum { VMType = VM::VM1 };
16111 static const char* GetVMString() { return "1"; }
16112 };
16113 template <> struct TagToType<0x0040,0xa192> {
16114 static const char* GetVRString() { return "DA"; }
16115 typedef VRToType<VR::DA>::Type Type;
16116 enum : long long { VRType = VR::DA };
16117 enum { VMType = VM::VM1 };
16118 static const char* GetVMString() { return "1"; }
16119 };
16120 template <> struct TagToType<0x0040,0xa193> {
16121 static const char* GetVRString() { return "TM"; }
16122 typedef VRToType<VR::TM>::Type Type;
16123 enum : long long { VRType = VR::TM };
16124 enum { VMType = VM::VM1 };
16125 static const char* GetVMString() { return "1"; }
16126 };
16127 template <> struct TagToType<0x0040,0xa194> {
16128 static const char* GetVRString() { return "CS"; }
16129 typedef VRToType<VR::CS>::Type Type;
16130 enum : long long { VRType = VR::CS };
16131 enum { VMType = VM::VM1 };
16132 static const char* GetVMString() { return "1"; }
16133 };
16134 template <> struct TagToType<0x0040,0xa195> {
16135 static const char* GetVRString() { return "SQ"; }
16136 typedef VRToType<VR::SQ>::Type Type;
16137 enum : long long { VRType = VR::SQ };
16138 enum { VMType = VM::VM1 };
16139 static const char* GetVMString() { return "1"; }
16140 };
16141 template <> struct TagToType<0x0040,0xa224> {
16142 static const char* GetVRString() { return "ST"; }
16143 typedef VRToType<VR::ST>::Type Type;
16144 enum : long long { VRType = VR::ST };
16145 enum { VMType = VM::VM1 };
16146 static const char* GetVMString() { return "1"; }
16147 };
16148 template <> struct TagToType<0x0040,0xa290> {
16149 static const char* GetVRString() { return "CS"; }
16150 typedef VRToType<VR::CS>::Type Type;
16151 enum : long long { VRType = VR::CS };
16152 enum { VMType = VM::VM1 };
16153 static const char* GetVMString() { return "1"; }
16154 };
16155 template <> struct TagToType<0x0040,0xa296> {
16156 static const char* GetVRString() { return "SQ"; }
16157 typedef VRToType<VR::SQ>::Type Type;
16158 enum : long long { VRType = VR::SQ };
16159 enum { VMType = VM::VM1 };
16160 static const char* GetVMString() { return "1"; }
16161 };
16162 template <> struct TagToType<0x0040,0xa297> {
16163 static const char* GetVRString() { return "ST"; }
16164 typedef VRToType<VR::ST>::Type Type;
16165 enum : long long { VRType = VR::ST };
16166 enum { VMType = VM::VM1 };
16167 static const char* GetVMString() { return "1"; }
16168 };
16169 template <> struct TagToType<0x0040,0xa29a> {
16170 static const char* GetVRString() { return "SL"; }
16171 typedef VRToType<VR::SL>::Type Type;
16172 enum : long long { VRType = VR::SL };
16173 enum { VMType = VM::VM2_2n };
16174 static const char* GetVMString() { return "2-2n"; }
16175 };
16176 template <> struct TagToType<0x0040,0xa300> {
16177 static const char* GetVRString() { return "SQ"; }
16178 typedef VRToType<VR::SQ>::Type Type;
16179 enum : long long { VRType = VR::SQ };
16180 enum { VMType = VM::VM1 };
16181 static const char* GetVMString() { return "1"; }
16182 };
16183 template <> struct TagToType<0x0040,0xa301> {
16184 static const char* GetVRString() { return "SQ"; }
16185 typedef VRToType<VR::SQ>::Type Type;
16186 enum : long long { VRType = VR::SQ };
16187 enum { VMType = VM::VM1 };
16188 static const char* GetVMString() { return "1"; }
16189 };
16190 template <> struct TagToType<0x0040,0xa307> {
16191 static const char* GetVRString() { return "PN"; }
16192 typedef VRToType<VR::PN>::Type Type;
16193 enum : long long { VRType = VR::PN };
16194 enum { VMType = VM::VM1 };
16195 static const char* GetVMString() { return "1"; }
16196 };
16197 template <> struct TagToType<0x0040,0xa30a> {
16198 static const char* GetVRString() { return "DS"; }
16199 typedef VRToType<VR::DS>::Type Type;
16200 enum : long long { VRType = VR::DS };
16201 enum { VMType = VM::VM1_n };
16202 static const char* GetVMString() { return "1-n"; }
16203 };
16204 template <> struct TagToType<0x0040,0xa313> {
16205 static const char* GetVRString() { return "SQ"; }
16206 typedef VRToType<VR::SQ>::Type Type;
16207 enum : long long { VRType = VR::SQ };
16208 enum { VMType = VM::VM1 };
16209 static const char* GetVMString() { return "1"; }
16210 };
16211 template <> struct TagToType<0x0040,0xa33a> {
16212 static const char* GetVRString() { return "ST"; }
16213 typedef VRToType<VR::ST>::Type Type;
16214 enum : long long { VRType = VR::ST };
16215 enum { VMType = VM::VM1 };
16216 static const char* GetVMString() { return "1"; }
16217 };
16218 template <> struct TagToType<0x0040,0xa340> {
16219 static const char* GetVRString() { return "SQ"; }
16220 typedef VRToType<VR::SQ>::Type Type;
16221 enum : long long { VRType = VR::SQ };
16222 enum { VMType = VM::VM1 };
16223 static const char* GetVMString() { return "1"; }
16224 };
16225 template <> struct TagToType<0x0040,0xa352> {
16226 static const char* GetVRString() { return "PN"; }
16227 typedef VRToType<VR::PN>::Type Type;
16228 enum : long long { VRType = VR::PN };
16229 enum { VMType = VM::VM1 };
16230 static const char* GetVMString() { return "1"; }
16231 };
16232 template <> struct TagToType<0x0040,0xa353> {
16233 static const char* GetVRString() { return "ST"; }
16234 typedef VRToType<VR::ST>::Type Type;
16235 enum : long long { VRType = VR::ST };
16236 enum { VMType = VM::VM1 };
16237 static const char* GetVMString() { return "1"; }
16238 };
16239 template <> struct TagToType<0x0040,0xa354> {
16240 static const char* GetVRString() { return "LO"; }
16241 typedef VRToType<VR::LO>::Type Type;
16242 enum : long long { VRType = VR::LO };
16243 enum { VMType = VM::VM1 };
16244 static const char* GetVMString() { return "1"; }
16245 };
16246 template <> struct TagToType<0x0040,0xa358> {
16247 static const char* GetVRString() { return "SQ"; }
16248 typedef VRToType<VR::SQ>::Type Type;
16249 enum : long long { VRType = VR::SQ };
16250 enum { VMType = VM::VM1 };
16251 static const char* GetVMString() { return "1"; }
16252 };
16253 template <> struct TagToType<0x0040,0xa360> {
16254 static const char* GetVRString() { return "SQ"; }
16255 typedef VRToType<VR::SQ>::Type Type;
16256 enum : long long { VRType = VR::SQ };
16257 enum { VMType = VM::VM1 };
16258 static const char* GetVMString() { return "1"; }
16259 };
16260 template <> struct TagToType<0x0040,0xa370> {
16261 static const char* GetVRString() { return "SQ"; }
16262 typedef VRToType<VR::SQ>::Type Type;
16263 enum : long long { VRType = VR::SQ };
16264 enum { VMType = VM::VM1 };
16265 static const char* GetVMString() { return "1"; }
16266 };
16267 template <> struct TagToType<0x0040,0xa372> {
16268 static const char* GetVRString() { return "SQ"; }
16269 typedef VRToType<VR::SQ>::Type Type;
16270 enum : long long { VRType = VR::SQ };
16271 enum { VMType = VM::VM1 };
16272 static const char* GetVMString() { return "1"; }
16273 };
16274 template <> struct TagToType<0x0040,0xa375> {
16275 static const char* GetVRString() { return "SQ"; }
16276 typedef VRToType<VR::SQ>::Type Type;
16277 enum : long long { VRType = VR::SQ };
16278 enum { VMType = VM::VM1 };
16279 static const char* GetVMString() { return "1"; }
16280 };
16281 template <> struct TagToType<0x0040,0xa380> {
16282 static const char* GetVRString() { return "SQ"; }
16283 typedef VRToType<VR::SQ>::Type Type;
16284 enum : long long { VRType = VR::SQ };
16285 enum { VMType = VM::VM1 };
16286 static const char* GetVMString() { return "1"; }
16287 };
16288 template <> struct TagToType<0x0040,0xa385> {
16289 static const char* GetVRString() { return "SQ"; }
16290 typedef VRToType<VR::SQ>::Type Type;
16291 enum : long long { VRType = VR::SQ };
16292 enum { VMType = VM::VM1 };
16293 static const char* GetVMString() { return "1"; }
16294 };
16295 template <> struct TagToType<0x0040,0xa390> {
16296 static const char* GetVRString() { return "SQ"; }
16297 typedef VRToType<VR::SQ>::Type Type;
16298 enum : long long { VRType = VR::SQ };
16299 enum { VMType = VM::VM1 };
16300 static const char* GetVMString() { return "1"; }
16301 };
16302 template <> struct TagToType<0x0040,0xa402> {
16303 static const char* GetVRString() { return "UI"; }
16304 typedef VRToType<VR::UI>::Type Type;
16305 enum : long long { VRType = VR::UI };
16306 enum { VMType = VM::VM1 };
16307 static const char* GetVMString() { return "1"; }
16308 };
16309 template <> struct TagToType<0x0040,0xa403> {
16310 static const char* GetVRString() { return "CS"; }
16311 typedef VRToType<VR::CS>::Type Type;
16312 enum : long long { VRType = VR::CS };
16313 enum { VMType = VM::VM1 };
16314 static const char* GetVMString() { return "1"; }
16315 };
16316 template <> struct TagToType<0x0040,0xa404> {
16317 static const char* GetVRString() { return "SQ"; }
16318 typedef VRToType<VR::SQ>::Type Type;
16319 enum : long long { VRType = VR::SQ };
16320 enum { VMType = VM::VM1 };
16321 static const char* GetVMString() { return "1"; }
16322 };
16323 template <> struct TagToType<0x0040,0xa491> {
16324 static const char* GetVRString() { return "CS"; }
16325 typedef VRToType<VR::CS>::Type Type;
16326 enum : long long { VRType = VR::CS };
16327 enum { VMType = VM::VM1 };
16328 static const char* GetVMString() { return "1"; }
16329 };
16330 template <> struct TagToType<0x0040,0xa492> {
16331 static const char* GetVRString() { return "LO"; }
16332 typedef VRToType<VR::LO>::Type Type;
16333 enum : long long { VRType = VR::LO };
16334 enum { VMType = VM::VM1 };
16335 static const char* GetVMString() { return "1"; }
16336 };
16337 template <> struct TagToType<0x0040,0xa493> {
16338 static const char* GetVRString() { return "CS"; }
16339 typedef VRToType<VR::CS>::Type Type;
16340 enum : long long { VRType = VR::CS };
16341 enum { VMType = VM::VM1 };
16342 static const char* GetVMString() { return "1"; }
16343 };
16344 template <> struct TagToType<0x0040,0xa494> {
16345 static const char* GetVRString() { return "CS"; }
16346 typedef VRToType<VR::CS>::Type Type;
16347 enum : long long { VRType = VR::CS };
16348 enum { VMType = VM::VM1 };
16349 static const char* GetVMString() { return "1"; }
16350 };
16351 template <> struct TagToType<0x0040,0xa496> {
16352 static const char* GetVRString() { return "CS"; }
16353 typedef VRToType<VR::CS>::Type Type;
16354 enum : long long { VRType = VR::CS };
16355 enum { VMType = VM::VM1 };
16356 static const char* GetVMString() { return "1"; }
16357 };
16358 template <> struct TagToType<0x0040,0xa504> {
16359 static const char* GetVRString() { return "SQ"; }
16360 typedef VRToType<VR::SQ>::Type Type;
16361 enum : long long { VRType = VR::SQ };
16362 enum { VMType = VM::VM1 };
16363 static const char* GetVMString() { return "1"; }
16364 };
16365 template <> struct TagToType<0x0040,0xa525> {
16366 static const char* GetVRString() { return "SQ"; }
16367 typedef VRToType<VR::SQ>::Type Type;
16368 enum : long long { VRType = VR::SQ };
16369 enum { VMType = VM::VM1 };
16370 static const char* GetVMString() { return "1"; }
16371 };
16372 template <> struct TagToType<0x0040,0xa600> {
16373 static const char* GetVRString() { return "CS"; }
16374 typedef VRToType<VR::CS>::Type Type;
16375 enum : long long { VRType = VR::CS };
16376 enum { VMType = VM::VM1 };
16377 static const char* GetVMString() { return "1"; }
16378 };
16379 template <> struct TagToType<0x0040,0xa601> {
16380 static const char* GetVRString() { return "CS"; }
16381 typedef VRToType<VR::CS>::Type Type;
16382 enum : long long { VRType = VR::CS };
16383 enum { VMType = VM::VM1 };
16384 static const char* GetVMString() { return "1"; }
16385 };
16386 template <> struct TagToType<0x0040,0xa603> {
16387 static const char* GetVRString() { return "CS"; }
16388 typedef VRToType<VR::CS>::Type Type;
16389 enum : long long { VRType = VR::CS };
16390 enum { VMType = VM::VM1 };
16391 static const char* GetVMString() { return "1"; }
16392 };
16393 template <> struct TagToType<0x0040,0xa730> {
16394 static const char* GetVRString() { return "SQ"; }
16395 typedef VRToType<VR::SQ>::Type Type;
16396 enum : long long { VRType = VR::SQ };
16397 enum { VMType = VM::VM1 };
16398 static const char* GetVMString() { return "1"; }
16399 };
16400 template <> struct TagToType<0x0040,0xa731> {
16401 static const char* GetVRString() { return "SQ"; }
16402 typedef VRToType<VR::SQ>::Type Type;
16403 enum : long long { VRType = VR::SQ };
16404 enum { VMType = VM::VM1 };
16405 static const char* GetVMString() { return "1"; }
16406 };
16407 template <> struct TagToType<0x0040,0xa732> {
16408 static const char* GetVRString() { return "SQ"; }
16409 typedef VRToType<VR::SQ>::Type Type;
16410 enum : long long { VRType = VR::SQ };
16411 enum { VMType = VM::VM1 };
16412 static const char* GetVMString() { return "1"; }
16413 };
16414 template <> struct TagToType<0x0040,0xa744> {
16415 static const char* GetVRString() { return "SQ"; }
16416 typedef VRToType<VR::SQ>::Type Type;
16417 enum : long long { VRType = VR::SQ };
16418 enum { VMType = VM::VM1 };
16419 static const char* GetVMString() { return "1"; }
16420 };
16421 template <> struct TagToType<0x0040,0xa992> {
16422 static const char* GetVRString() { return "ST"; }
16423 typedef VRToType<VR::ST>::Type Type;
16424 enum : long long { VRType = VR::ST };
16425 enum { VMType = VM::VM1 };
16426 static const char* GetVMString() { return "1"; }
16427 };
16428 template <> struct TagToType<0x0040,0xb020> {
16429 static const char* GetVRString() { return "SQ"; }
16430 typedef VRToType<VR::SQ>::Type Type;
16431 enum : long long { VRType = VR::SQ };
16432 enum { VMType = VM::VM1 };
16433 static const char* GetVMString() { return "1"; }
16434 };
16435 template <> struct TagToType<0x0040,0xdb00> {
16436 static const char* GetVRString() { return "CS"; }
16437 typedef VRToType<VR::CS>::Type Type;
16438 enum : long long { VRType = VR::CS };
16439 enum { VMType = VM::VM1 };
16440 static const char* GetVMString() { return "1"; }
16441 };
16442 template <> struct TagToType<0x0040,0xdb06> {
16443 static const char* GetVRString() { return "DT"; }
16444 typedef VRToType<VR::DT>::Type Type;
16445 enum : long long { VRType = VR::DT };
16446 enum { VMType = VM::VM1 };
16447 static const char* GetVMString() { return "1"; }
16448 };
16449 template <> struct TagToType<0x0040,0xdb07> {
16450 static const char* GetVRString() { return "DT"; }
16451 typedef VRToType<VR::DT>::Type Type;
16452 enum : long long { VRType = VR::DT };
16453 enum { VMType = VM::VM1 };
16454 static const char* GetVMString() { return "1"; }
16455 };
16456 template <> struct TagToType<0x0040,0xdb0b> {
16457 static const char* GetVRString() { return "CS"; }
16458 typedef VRToType<VR::CS>::Type Type;
16459 enum : long long { VRType = VR::CS };
16460 enum { VMType = VM::VM1 };
16461 static const char* GetVMString() { return "1"; }
16462 };
16463 template <> struct TagToType<0x0040,0xdb0c> {
16464 static const char* GetVRString() { return "UI"; }
16465 typedef VRToType<VR::UI>::Type Type;
16466 enum : long long { VRType = VR::UI };
16467 enum { VMType = VM::VM1 };
16468 static const char* GetVMString() { return "1"; }
16469 };
16470 template <> struct TagToType<0x0040,0xdb0d> {
16471 static const char* GetVRString() { return "UI"; }
16472 typedef VRToType<VR::UI>::Type Type;
16473 enum : long long { VRType = VR::UI };
16474 enum { VMType = VM::VM1 };
16475 static const char* GetVMString() { return "1"; }
16476 };
16477 template <> struct TagToType<0x0040,0xdb73> {
16478 static const char* GetVRString() { return "UL"; }
16479 typedef VRToType<VR::UL>::Type Type;
16480 enum : long long { VRType = VR::UL };
16481 enum { VMType = VM::VM1_n };
16482 static const char* GetVMString() { return "1-n"; }
16483 };
16484 template <> struct TagToType<0x0040,0xe001> {
16485 static const char* GetVRString() { return "ST"; }
16486 typedef VRToType<VR::ST>::Type Type;
16487 enum : long long { VRType = VR::ST };
16488 enum { VMType = VM::VM1 };
16489 static const char* GetVMString() { return "1"; }
16490 };
16491 template <> struct TagToType<0x0040,0xe004> {
16492 static const char* GetVRString() { return "DT"; }
16493 typedef VRToType<VR::DT>::Type Type;
16494 enum : long long { VRType = VR::DT };
16495 enum { VMType = VM::VM1 };
16496 static const char* GetVMString() { return "1"; }
16497 };
16498 template <> struct TagToType<0x0040,0xe006> {
16499 static const char* GetVRString() { return "SQ"; }
16500 typedef VRToType<VR::SQ>::Type Type;
16501 enum : long long { VRType = VR::SQ };
16502 enum { VMType = VM::VM1 };
16503 static const char* GetVMString() { return "1"; }
16504 };
16505 template <> struct TagToType<0x0040,0xe008> {
16506 static const char* GetVRString() { return "SQ"; }
16507 typedef VRToType<VR::SQ>::Type Type;
16508 enum : long long { VRType = VR::SQ };
16509 enum { VMType = VM::VM1 };
16510 static const char* GetVMString() { return "1"; }
16511 };
16512 template <> struct TagToType<0x0040,0xe010> {
16513 static const char* GetVRString() { return "UR"; }
16514 typedef VRToType<VR::UR>::Type Type;
16515 enum : long long { VRType = VR::UR };
16516 enum { VMType = VM::VM1 };
16517 static const char* GetVMString() { return "1"; }
16518 };
16519 template <> struct TagToType<0x0040,0xe011> {
16520 static const char* GetVRString() { return "UI"; }
16521 typedef VRToType<VR::UI>::Type Type;
16522 enum : long long { VRType = VR::UI };
16523 enum { VMType = VM::VM1 };
16524 static const char* GetVMString() { return "1"; }
16525 };
16526 template <> struct TagToType<0x0040,0xe020> {
16527 static const char* GetVRString() { return "CS"; }
16528 typedef VRToType<VR::CS>::Type Type;
16529 enum : long long { VRType = VR::CS };
16530 enum { VMType = VM::VM1 };
16531 static const char* GetVMString() { return "1"; }
16532 };
16533 template <> struct TagToType<0x0040,0xe021> {
16534 static const char* GetVRString() { return "SQ"; }
16535 typedef VRToType<VR::SQ>::Type Type;
16536 enum : long long { VRType = VR::SQ };
16537 enum { VMType = VM::VM1 };
16538 static const char* GetVMString() { return "1"; }
16539 };
16540 template <> struct TagToType<0x0040,0xe022> {
16541 static const char* GetVRString() { return "SQ"; }
16542 typedef VRToType<VR::SQ>::Type Type;
16543 enum : long long { VRType = VR::SQ };
16544 enum { VMType = VM::VM1 };
16545 static const char* GetVMString() { return "1"; }
16546 };
16547 template <> struct TagToType<0x0040,0xe023> {
16548 static const char* GetVRString() { return "SQ"; }
16549 typedef VRToType<VR::SQ>::Type Type;
16550 enum : long long { VRType = VR::SQ };
16551 enum { VMType = VM::VM1 };
16552 static const char* GetVMString() { return "1"; }
16553 };
16554 template <> struct TagToType<0x0040,0xe024> {
16555 static const char* GetVRString() { return "SQ"; }
16556 typedef VRToType<VR::SQ>::Type Type;
16557 enum : long long { VRType = VR::SQ };
16558 enum { VMType = VM::VM1 };
16559 static const char* GetVMString() { return "1"; }
16560 };
16561 template <> struct TagToType<0x0040,0xe025> {
16562 static const char* GetVRString() { return "SQ"; }
16563 typedef VRToType<VR::SQ>::Type Type;
16564 enum : long long { VRType = VR::SQ };
16565 enum { VMType = VM::VM1 };
16566 static const char* GetVMString() { return "1"; }
16567 };
16568 template <> struct TagToType<0x0040,0xe030> {
16569 static const char* GetVRString() { return "UI"; }
16570 typedef VRToType<VR::UI>::Type Type;
16571 enum : long long { VRType = VR::UI };
16572 enum { VMType = VM::VM1 };
16573 static const char* GetVMString() { return "1"; }
16574 };
16575 template <> struct TagToType<0x0040,0xe031> {
16576 static const char* GetVRString() { return "UI"; }
16577 typedef VRToType<VR::UI>::Type Type;
16578 enum : long long { VRType = VR::UI };
16579 enum { VMType = VM::VM1 };
16580 static const char* GetVMString() { return "1"; }
16581 };
16582 template <> struct TagToType<0x0042,0x0010> {
16583 static const char* GetVRString() { return "ST"; }
16584 typedef VRToType<VR::ST>::Type Type;
16585 enum : long long { VRType = VR::ST };
16586 enum { VMType = VM::VM1 };
16587 static const char* GetVMString() { return "1"; }
16588 };
16589 template <> struct TagToType<0x0042,0x0011> {
16590 static const char* GetVRString() { return "OB"; }
16591 typedef VRToType<VR::OB>::Type Type;
16592 enum : long long { VRType = VR::OB };
16593 enum { VMType = VM::VM1 };
16594 static const char* GetVMString() { return "1"; }
16595 };
16596 template <> struct TagToType<0x0042,0x0012> {
16597 static const char* GetVRString() { return "LO"; }
16598 typedef VRToType<VR::LO>::Type Type;
16599 enum : long long { VRType = VR::LO };
16600 enum { VMType = VM::VM1 };
16601 static const char* GetVMString() { return "1"; }
16602 };
16603 template <> struct TagToType<0x0042,0x0013> {
16604 static const char* GetVRString() { return "SQ"; }
16605 typedef VRToType<VR::SQ>::Type Type;
16606 enum : long long { VRType = VR::SQ };
16607 enum { VMType = VM::VM1 };
16608 static const char* GetVMString() { return "1"; }
16609 };
16610 template <> struct TagToType<0x0042,0x0014> {
16611 static const char* GetVRString() { return "LO"; }
16612 typedef VRToType<VR::LO>::Type Type;
16613 enum : long long { VRType = VR::LO };
16614 enum { VMType = VM::VM1_n };
16615 static const char* GetVMString() { return "1-n"; }
16616 };
16617 template <> struct TagToType<0x0044,0x0001> {
16618 static const char* GetVRString() { return "ST"; }
16619 typedef VRToType<VR::ST>::Type Type;
16620 enum : long long { VRType = VR::ST };
16621 enum { VMType = VM::VM1 };
16622 static const char* GetVMString() { return "1"; }
16623 };
16624 template <> struct TagToType<0x0044,0x0002> {
16625 static const char* GetVRString() { return "CS"; }
16626 typedef VRToType<VR::CS>::Type Type;
16627 enum : long long { VRType = VR::CS };
16628 enum { VMType = VM::VM1 };
16629 static const char* GetVMString() { return "1"; }
16630 };
16631 template <> struct TagToType<0x0044,0x0003> {
16632 static const char* GetVRString() { return "LT"; }
16633 typedef VRToType<VR::LT>::Type Type;
16634 enum : long long { VRType = VR::LT };
16635 enum { VMType = VM::VM1 };
16636 static const char* GetVMString() { return "1"; }
16637 };
16638 template <> struct TagToType<0x0044,0x0004> {
16639 static const char* GetVRString() { return "DT"; }
16640 typedef VRToType<VR::DT>::Type Type;
16641 enum : long long { VRType = VR::DT };
16642 enum { VMType = VM::VM1 };
16643 static const char* GetVMString() { return "1"; }
16644 };
16645 template <> struct TagToType<0x0044,0x0007> {
16646 static const char* GetVRString() { return "SQ"; }
16647 typedef VRToType<VR::SQ>::Type Type;
16648 enum : long long { VRType = VR::SQ };
16649 enum { VMType = VM::VM1 };
16650 static const char* GetVMString() { return "1"; }
16651 };
16652 template <> struct TagToType<0x0044,0x0008> {
16653 static const char* GetVRString() { return "LO"; }
16654 typedef VRToType<VR::LO>::Type Type;
16655 enum : long long { VRType = VR::LO };
16656 enum { VMType = VM::VM1_n };
16657 static const char* GetVMString() { return "1-n"; }
16658 };
16659 template <> struct TagToType<0x0044,0x0009> {
16660 static const char* GetVRString() { return "LT"; }
16661 typedef VRToType<VR::LT>::Type Type;
16662 enum : long long { VRType = VR::LT };
16663 enum { VMType = VM::VM1 };
16664 static const char* GetVMString() { return "1"; }
16665 };
16666 template <> struct TagToType<0x0044,0x000a> {
16667 static const char* GetVRString() { return "LO"; }
16668 typedef VRToType<VR::LO>::Type Type;
16669 enum : long long { VRType = VR::LO };
16670 enum { VMType = VM::VM1 };
16671 static const char* GetVMString() { return "1"; }
16672 };
16673 template <> struct TagToType<0x0044,0x000b> {
16674 static const char* GetVRString() { return "DT"; }
16675 typedef VRToType<VR::DT>::Type Type;
16676 enum : long long { VRType = VR::DT };
16677 enum { VMType = VM::VM1 };
16678 static const char* GetVMString() { return "1"; }
16679 };
16680 template <> struct TagToType<0x0044,0x0010> {
16681 static const char* GetVRString() { return "DT"; }
16682 typedef VRToType<VR::DT>::Type Type;
16683 enum : long long { VRType = VR::DT };
16684 enum { VMType = VM::VM1 };
16685 static const char* GetVMString() { return "1"; }
16686 };
16687 template <> struct TagToType<0x0044,0x0011> {
16688 static const char* GetVRString() { return "LO"; }
16689 typedef VRToType<VR::LO>::Type Type;
16690 enum : long long { VRType = VR::LO };
16691 enum { VMType = VM::VM1 };
16692 static const char* GetVMString() { return "1"; }
16693 };
16694 template <> struct TagToType<0x0044,0x0012> {
16695 static const char* GetVRString() { return "LO"; }
16696 typedef VRToType<VR::LO>::Type Type;
16697 enum : long long { VRType = VR::LO };
16698 enum { VMType = VM::VM1 };
16699 static const char* GetVMString() { return "1"; }
16700 };
16701 template <> struct TagToType<0x0044,0x0013> {
16702 static const char* GetVRString() { return "SQ"; }
16703 typedef VRToType<VR::SQ>::Type Type;
16704 enum : long long { VRType = VR::SQ };
16705 enum { VMType = VM::VM1 };
16706 static const char* GetVMString() { return "1"; }
16707 };
16708 template <> struct TagToType<0x0044,0x0019> {
16709 static const char* GetVRString() { return "SQ"; }
16710 typedef VRToType<VR::SQ>::Type Type;
16711 enum : long long { VRType = VR::SQ };
16712 enum { VMType = VM::VM1 };
16713 static const char* GetVMString() { return "1"; }
16714 };
16715 template <> struct TagToType<0x0046,0x0012> {
16716 static const char* GetVRString() { return "LO"; }
16717 typedef VRToType<VR::LO>::Type Type;
16718 enum : long long { VRType = VR::LO };
16719 enum { VMType = VM::VM1 };
16720 static const char* GetVMString() { return "1"; }
16721 };
16722 template <> struct TagToType<0x0046,0x0014> {
16723 static const char* GetVRString() { return "SQ"; }
16724 typedef VRToType<VR::SQ>::Type Type;
16725 enum : long long { VRType = VR::SQ };
16726 enum { VMType = VM::VM1 };
16727 static const char* GetVMString() { return "1"; }
16728 };
16729 template <> struct TagToType<0x0046,0x0015> {
16730 static const char* GetVRString() { return "SQ"; }
16731 typedef VRToType<VR::SQ>::Type Type;
16732 enum : long long { VRType = VR::SQ };
16733 enum { VMType = VM::VM1 };
16734 static const char* GetVMString() { return "1"; }
16735 };
16736 template <> struct TagToType<0x0046,0x0016> {
16737 static const char* GetVRString() { return "SQ"; }
16738 typedef VRToType<VR::SQ>::Type Type;
16739 enum : long long { VRType = VR::SQ };
16740 enum { VMType = VM::VM1 };
16741 static const char* GetVMString() { return "1"; }
16742 };
16743 template <> struct TagToType<0x0046,0x0018> {
16744 static const char* GetVRString() { return "SQ"; }
16745 typedef VRToType<VR::SQ>::Type Type;
16746 enum : long long { VRType = VR::SQ };
16747 enum { VMType = VM::VM1 };
16748 static const char* GetVMString() { return "1"; }
16749 };
16750 template <> struct TagToType<0x0046,0x0028> {
16751 static const char* GetVRString() { return "SQ"; }
16752 typedef VRToType<VR::SQ>::Type Type;
16753 enum : long long { VRType = VR::SQ };
16754 enum { VMType = VM::VM1 };
16755 static const char* GetVMString() { return "1"; }
16756 };
16757 template <> struct TagToType<0x0046,0x0030> {
16758 static const char* GetVRString() { return "FD"; }
16759 typedef VRToType<VR::FD>::Type Type;
16760 enum : long long { VRType = VR::FD };
16761 enum { VMType = VM::VM1 };
16762 static const char* GetVMString() { return "1"; }
16763 };
16764 template <> struct TagToType<0x0046,0x0032> {
16765 static const char* GetVRString() { return "CS"; }
16766 typedef VRToType<VR::CS>::Type Type;
16767 enum : long long { VRType = VR::CS };
16768 enum { VMType = VM::VM1 };
16769 static const char* GetVMString() { return "1"; }
16770 };
16771 template <> struct TagToType<0x0046,0x0034> {
16772 static const char* GetVRString() { return "FD"; }
16773 typedef VRToType<VR::FD>::Type Type;
16774 enum : long long { VRType = VR::FD };
16775 enum { VMType = VM::VM1 };
16776 static const char* GetVMString() { return "1"; }
16777 };
16778 template <> struct TagToType<0x0046,0x0036> {
16779 static const char* GetVRString() { return "CS"; }
16780 typedef VRToType<VR::CS>::Type Type;
16781 enum : long long { VRType = VR::CS };
16782 enum { VMType = VM::VM1 };
16783 static const char* GetVMString() { return "1"; }
16784 };
16785 template <> struct TagToType<0x0046,0x0038> {
16786 static const char* GetVRString() { return "CS"; }
16787 typedef VRToType<VR::CS>::Type Type;
16788 enum : long long { VRType = VR::CS };
16789 enum { VMType = VM::VM1 };
16790 static const char* GetVMString() { return "1"; }
16791 };
16792 template <> struct TagToType<0x0046,0x0040> {
16793 static const char* GetVRString() { return "FD"; }
16794 typedef VRToType<VR::FD>::Type Type;
16795 enum : long long { VRType = VR::FD };
16796 enum { VMType = VM::VM1 };
16797 static const char* GetVMString() { return "1"; }
16798 };
16799 template <> struct TagToType<0x0046,0x0042> {
16800 static const char* GetVRString() { return "FD"; }
16801 typedef VRToType<VR::FD>::Type Type;
16802 enum : long long { VRType = VR::FD };
16803 enum { VMType = VM::VM1 };
16804 static const char* GetVMString() { return "1"; }
16805 };
16806 template <> struct TagToType<0x0046,0x0044> {
16807 static const char* GetVRString() { return "FD"; }
16808 typedef VRToType<VR::FD>::Type Type;
16809 enum : long long { VRType = VR::FD };
16810 enum { VMType = VM::VM1 };
16811 static const char* GetVMString() { return "1"; }
16812 };
16813 template <> struct TagToType<0x0046,0x0046> {
16814 static const char* GetVRString() { return "FD"; }
16815 typedef VRToType<VR::FD>::Type Type;
16816 enum : long long { VRType = VR::FD };
16817 enum { VMType = VM::VM1 };
16818 static const char* GetVMString() { return "1"; }
16819 };
16820 template <> struct TagToType<0x0046,0x0050> {
16821 static const char* GetVRString() { return "SQ"; }
16822 typedef VRToType<VR::SQ>::Type Type;
16823 enum : long long { VRType = VR::SQ };
16824 enum { VMType = VM::VM1 };
16825 static const char* GetVMString() { return "1"; }
16826 };
16827 template <> struct TagToType<0x0046,0x0052> {
16828 static const char* GetVRString() { return "SQ"; }
16829 typedef VRToType<VR::SQ>::Type Type;
16830 enum : long long { VRType = VR::SQ };
16831 enum { VMType = VM::VM1 };
16832 static const char* GetVMString() { return "1"; }
16833 };
16834 template <> struct TagToType<0x0046,0x0060> {
16835 static const char* GetVRString() { return "FD"; }
16836 typedef VRToType<VR::FD>::Type Type;
16837 enum : long long { VRType = VR::FD };
16838 enum { VMType = VM::VM1 };
16839 static const char* GetVMString() { return "1"; }
16840 };
16841 template <> struct TagToType<0x0046,0x0062> {
16842 static const char* GetVRString() { return "FD"; }
16843 typedef VRToType<VR::FD>::Type Type;
16844 enum : long long { VRType = VR::FD };
16845 enum { VMType = VM::VM1 };
16846 static const char* GetVMString() { return "1"; }
16847 };
16848 template <> struct TagToType<0x0046,0x0063> {
16849 static const char* GetVRString() { return "FD"; }
16850 typedef VRToType<VR::FD>::Type Type;
16851 enum : long long { VRType = VR::FD };
16852 enum { VMType = VM::VM1 };
16853 static const char* GetVMString() { return "1"; }
16854 };
16855 template <> struct TagToType<0x0046,0x0064> {
16856 static const char* GetVRString() { return "FD"; }
16857 typedef VRToType<VR::FD>::Type Type;
16858 enum : long long { VRType = VR::FD };
16859 enum { VMType = VM::VM1 };
16860 static const char* GetVMString() { return "1"; }
16861 };
16862 template <> struct TagToType<0x0046,0x0070> {
16863 static const char* GetVRString() { return "SQ"; }
16864 typedef VRToType<VR::SQ>::Type Type;
16865 enum : long long { VRType = VR::SQ };
16866 enum { VMType = VM::VM1 };
16867 static const char* GetVMString() { return "1"; }
16868 };
16869 template <> struct TagToType<0x0046,0x0071> {
16870 static const char* GetVRString() { return "SQ"; }
16871 typedef VRToType<VR::SQ>::Type Type;
16872 enum : long long { VRType = VR::SQ };
16873 enum { VMType = VM::VM1 };
16874 static const char* GetVMString() { return "1"; }
16875 };
16876 template <> struct TagToType<0x0046,0x0074> {
16877 static const char* GetVRString() { return "SQ"; }
16878 typedef VRToType<VR::SQ>::Type Type;
16879 enum : long long { VRType = VR::SQ };
16880 enum { VMType = VM::VM1 };
16881 static const char* GetVMString() { return "1"; }
16882 };
16883 template <> struct TagToType<0x0046,0x0075> {
16884 static const char* GetVRString() { return "FD"; }
16885 typedef VRToType<VR::FD>::Type Type;
16886 enum : long long { VRType = VR::FD };
16887 enum { VMType = VM::VM1 };
16888 static const char* GetVMString() { return "1"; }
16889 };
16890 template <> struct TagToType<0x0046,0x0076> {
16891 static const char* GetVRString() { return "FD"; }
16892 typedef VRToType<VR::FD>::Type Type;
16893 enum : long long { VRType = VR::FD };
16894 enum { VMType = VM::VM1 };
16895 static const char* GetVMString() { return "1"; }
16896 };
16897 template <> struct TagToType<0x0046,0x0077> {
16898 static const char* GetVRString() { return "FD"; }
16899 typedef VRToType<VR::FD>::Type Type;
16900 enum : long long { VRType = VR::FD };
16901 enum { VMType = VM::VM1 };
16902 static const char* GetVMString() { return "1"; }
16903 };
16904 template <> struct TagToType<0x0046,0x0080> {
16905 static const char* GetVRString() { return "SQ"; }
16906 typedef VRToType<VR::SQ>::Type Type;
16907 enum : long long { VRType = VR::SQ };
16908 enum { VMType = VM::VM1 };
16909 static const char* GetVMString() { return "1"; }
16910 };
16911 template <> struct TagToType<0x0046,0x0092> {
16912 static const char* GetVRString() { return "CS"; }
16913 typedef VRToType<VR::CS>::Type Type;
16914 enum : long long { VRType = VR::CS };
16915 enum { VMType = VM::VM1 };
16916 static const char* GetVMString() { return "1"; }
16917 };
16918 template <> struct TagToType<0x0046,0x0094> {
16919 static const char* GetVRString() { return "CS"; }
16920 typedef VRToType<VR::CS>::Type Type;
16921 enum : long long { VRType = VR::CS };
16922 enum { VMType = VM::VM1 };
16923 static const char* GetVMString() { return "1"; }
16924 };
16925 template <> struct TagToType<0x0046,0x0095> {
16926 static const char* GetVRString() { return "CS"; }
16927 typedef VRToType<VR::CS>::Type Type;
16928 enum : long long { VRType = VR::CS };
16929 enum { VMType = VM::VM1 };
16930 static const char* GetVMString() { return "1"; }
16931 };
16932 template <> struct TagToType<0x0046,0x0097> {
16933 static const char* GetVRString() { return "SQ"; }
16934 typedef VRToType<VR::SQ>::Type Type;
16935 enum : long long { VRType = VR::SQ };
16936 enum { VMType = VM::VM1 };
16937 static const char* GetVMString() { return "1"; }
16938 };
16939 template <> struct TagToType<0x0046,0x0098> {
16940 static const char* GetVRString() { return "SQ"; }
16941 typedef VRToType<VR::SQ>::Type Type;
16942 enum : long long { VRType = VR::SQ };
16943 enum { VMType = VM::VM1 };
16944 static const char* GetVMString() { return "1"; }
16945 };
16946 template <> struct TagToType<0x0046,0x0100> {
16947 static const char* GetVRString() { return "SQ"; }
16948 typedef VRToType<VR::SQ>::Type Type;
16949 enum : long long { VRType = VR::SQ };
16950 enum { VMType = VM::VM1 };
16951 static const char* GetVMString() { return "1"; }
16952 };
16953 template <> struct TagToType<0x0046,0x0101> {
16954 static const char* GetVRString() { return "SQ"; }
16955 typedef VRToType<VR::SQ>::Type Type;
16956 enum : long long { VRType = VR::SQ };
16957 enum { VMType = VM::VM1 };
16958 static const char* GetVMString() { return "1"; }
16959 };
16960 template <> struct TagToType<0x0046,0x0102> {
16961 static const char* GetVRString() { return "SQ"; }
16962 typedef VRToType<VR::SQ>::Type Type;
16963 enum : long long { VRType = VR::SQ };
16964 enum { VMType = VM::VM1 };
16965 static const char* GetVMString() { return "1"; }
16966 };
16967 template <> struct TagToType<0x0046,0x0104> {
16968 static const char* GetVRString() { return "FD"; }
16969 typedef VRToType<VR::FD>::Type Type;
16970 enum : long long { VRType = VR::FD };
16971 enum { VMType = VM::VM1 };
16972 static const char* GetVMString() { return "1"; }
16973 };
16974 template <> struct TagToType<0x0046,0x0106> {
16975 static const char* GetVRString() { return "FD"; }
16976 typedef VRToType<VR::FD>::Type Type;
16977 enum : long long { VRType = VR::FD };
16978 enum { VMType = VM::VM1 };
16979 static const char* GetVMString() { return "1"; }
16980 };
16981 template <> struct TagToType<0x0046,0x0121> {
16982 static const char* GetVRString() { return "SQ"; }
16983 typedef VRToType<VR::SQ>::Type Type;
16984 enum : long long { VRType = VR::SQ };
16985 enum { VMType = VM::VM1 };
16986 static const char* GetVMString() { return "1"; }
16987 };
16988 template <> struct TagToType<0x0046,0x0122> {
16989 static const char* GetVRString() { return "SQ"; }
16990 typedef VRToType<VR::SQ>::Type Type;
16991 enum : long long { VRType = VR::SQ };
16992 enum { VMType = VM::VM1 };
16993 static const char* GetVMString() { return "1"; }
16994 };
16995 template <> struct TagToType<0x0046,0x0123> {
16996 static const char* GetVRString() { return "SQ"; }
16997 typedef VRToType<VR::SQ>::Type Type;
16998 enum : long long { VRType = VR::SQ };
16999 enum { VMType = VM::VM1 };
17000 static const char* GetVMString() { return "1"; }
17001 };
17002 template <> struct TagToType<0x0046,0x0124> {
17003 static const char* GetVRString() { return "SQ"; }
17004 typedef VRToType<VR::SQ>::Type Type;
17005 enum : long long { VRType = VR::SQ };
17006 enum { VMType = VM::VM1 };
17007 static const char* GetVMString() { return "1"; }
17008 };
17009 template <> struct TagToType<0x0046,0x0125> {
17010 static const char* GetVRString() { return "CS"; }
17011 typedef VRToType<VR::CS>::Type Type;
17012 enum : long long { VRType = VR::CS };
17013 enum { VMType = VM::VM1 };
17014 static const char* GetVMString() { return "1"; }
17015 };
17016 template <> struct TagToType<0x0046,0x0135> {
17017 static const char* GetVRString() { return "SS"; }
17018 typedef VRToType<VR::SS>::Type Type;
17019 enum : long long { VRType = VR::SS };
17020 enum { VMType = VM::VM2 };
17021 static const char* GetVMString() { return "2"; }
17022 };
17023 template <> struct TagToType<0x0046,0x0137> {
17024 static const char* GetVRString() { return "FD"; }
17025 typedef VRToType<VR::FD>::Type Type;
17026 enum : long long { VRType = VR::FD };
17027 enum { VMType = VM::VM1 };
17028 static const char* GetVMString() { return "1"; }
17029 };
17030 template <> struct TagToType<0x0046,0x0139> {
17031 static const char* GetVRString() { return "LO"; }
17032 typedef VRToType<VR::LO>::Type Type;
17033 enum : long long { VRType = VR::LO };
17034 enum { VMType = VM::VM1 };
17035 static const char* GetVMString() { return "1"; }
17036 };
17037 template <> struct TagToType<0x0046,0x0145> {
17038 static const char* GetVRString() { return "SQ"; }
17039 typedef VRToType<VR::SQ>::Type Type;
17040 enum : long long { VRType = VR::SQ };
17041 enum { VMType = VM::VM1 };
17042 static const char* GetVMString() { return "1"; }
17043 };
17044 template <> struct TagToType<0x0046,0x0146> {
17045 static const char* GetVRString() { return "FD"; }
17046 typedef VRToType<VR::FD>::Type Type;
17047 enum : long long { VRType = VR::FD };
17048 enum { VMType = VM::VM1 };
17049 static const char* GetVMString() { return "1"; }
17050 };
17051 template <> struct TagToType<0x0046,0x0147> {
17052 static const char* GetVRString() { return "FD"; }
17053 typedef VRToType<VR::FD>::Type Type;
17054 enum : long long { VRType = VR::FD };
17055 enum { VMType = VM::VM1 };
17056 static const char* GetVMString() { return "1"; }
17057 };
17058 template <> struct TagToType<0x0046,0x0201> {
17059 static const char* GetVRString() { return "CS"; }
17060 typedef VRToType<VR::CS>::Type Type;
17061 enum : long long { VRType = VR::CS };
17062 enum { VMType = VM::VM1 };
17063 static const char* GetVMString() { return "1"; }
17064 };
17065 template <> struct TagToType<0x0046,0x0202> {
17066 static const char* GetVRString() { return "FL"; }
17067 typedef VRToType<VR::FL>::Type Type;
17068 enum : long long { VRType = VR::FL };
17069 enum { VMType = VM::VM2 };
17070 static const char* GetVMString() { return "2"; }
17071 };
17072 template <> struct TagToType<0x0046,0x0203> {
17073 static const char* GetVRString() { return "FL"; }
17074 typedef VRToType<VR::FL>::Type Type;
17075 enum : long long { VRType = VR::FL };
17076 enum { VMType = VM::VM1 };
17077 static const char* GetVMString() { return "1"; }
17078 };
17079 template <> struct TagToType<0x0046,0x0204> {
17080 static const char* GetVRString() { return "FL"; }
17081 typedef VRToType<VR::FL>::Type Type;
17082 enum : long long { VRType = VR::FL };
17083 enum { VMType = VM::VM1 };
17084 static const char* GetVMString() { return "1"; }
17085 };
17086 template <> struct TagToType<0x0046,0x0205> {
17087 static const char* GetVRString() { return "FL"; }
17088 typedef VRToType<VR::FL>::Type Type;
17089 enum : long long { VRType = VR::FL };
17090 enum { VMType = VM::VM1 };
17091 static const char* GetVMString() { return "1"; }
17092 };
17093 template <> struct TagToType<0x0046,0x0207> {
17094 static const char* GetVRString() { return "SQ"; }
17095 typedef VRToType<VR::SQ>::Type Type;
17096 enum : long long { VRType = VR::SQ };
17097 enum { VMType = VM::VM1 };
17098 static const char* GetVMString() { return "1"; }
17099 };
17100 template <> struct TagToType<0x0046,0x0208> {
17101 static const char* GetVRString() { return "IS"; }
17102 typedef VRToType<VR::IS>::Type Type;
17103 enum : long long { VRType = VR::IS };
17104 enum { VMType = VM::VM2_2n };
17105 static const char* GetVMString() { return "2-2n"; }
17106 };
17107 template <> struct TagToType<0x0046,0x0210> {
17108 static const char* GetVRString() { return "SQ"; }
17109 typedef VRToType<VR::SQ>::Type Type;
17110 enum : long long { VRType = VR::SQ };
17111 enum { VMType = VM::VM1 };
17112 static const char* GetVMString() { return "1"; }
17113 };
17114 template <> struct TagToType<0x0046,0x0211> {
17115 static const char* GetVRString() { return "SQ"; }
17116 typedef VRToType<VR::SQ>::Type Type;
17117 enum : long long { VRType = VR::SQ };
17118 enum { VMType = VM::VM1 };
17119 static const char* GetVMString() { return "1"; }
17120 };
17121 template <> struct TagToType<0x0046,0x0212> {
17122 static const char* GetVRString() { return "FL"; }
17123 typedef VRToType<VR::FL>::Type Type;
17124 enum : long long { VRType = VR::FL };
17125 enum { VMType = VM::VM1 };
17126 static const char* GetVMString() { return "1"; }
17127 };
17128 template <> struct TagToType<0x0046,0x0213> {
17129 static const char* GetVRString() { return "FL"; }
17130 typedef VRToType<VR::FL>::Type Type;
17131 enum : long long { VRType = VR::FL };
17132 enum { VMType = VM::VM2 };
17133 static const char* GetVMString() { return "2"; }
17134 };
17135 template <> struct TagToType<0x0046,0x0215> {
17136 static const char* GetVRString() { return "SQ"; }
17137 typedef VRToType<VR::SQ>::Type Type;
17138 enum : long long { VRType = VR::SQ };
17139 enum { VMType = VM::VM1 };
17140 static const char* GetVMString() { return "1"; }
17141 };
17142 template <> struct TagToType<0x0046,0x0218> {
17143 static const char* GetVRString() { return "SQ"; }
17144 typedef VRToType<VR::SQ>::Type Type;
17145 enum : long long { VRType = VR::SQ };
17146 enum { VMType = VM::VM1 };
17147 static const char* GetVMString() { return "1"; }
17148 };
17149 template <> struct TagToType<0x0046,0x0220> {
17150 static const char* GetVRString() { return "FL"; }
17151 typedef VRToType<VR::FL>::Type Type;
17152 enum : long long { VRType = VR::FL };
17153 enum { VMType = VM::VM1 };
17154 static const char* GetVMString() { return "1"; }
17155 };
17156 template <> struct TagToType<0x0046,0x0224> {
17157 static const char* GetVRString() { return "FL"; }
17158 typedef VRToType<VR::FL>::Type Type;
17159 enum : long long { VRType = VR::FL };
17160 enum { VMType = VM::VM1 };
17161 static const char* GetVMString() { return "1"; }
17162 };
17163 template <> struct TagToType<0x0046,0x0227> {
17164 static const char* GetVRString() { return "FL"; }
17165 typedef VRToType<VR::FL>::Type Type;
17166 enum : long long { VRType = VR::FL };
17167 enum { VMType = VM::VM1 };
17168 static const char* GetVMString() { return "1"; }
17169 };
17170 template <> struct TagToType<0x0046,0x0230> {
17171 static const char* GetVRString() { return "FL"; }
17172 typedef VRToType<VR::FL>::Type Type;
17173 enum : long long { VRType = VR::FL };
17174 enum { VMType = VM::VM1 };
17175 static const char* GetVMString() { return "1"; }
17176 };
17177 template <> struct TagToType<0x0046,0x0232> {
17178 static const char* GetVRString() { return "FL"; }
17179 typedef VRToType<VR::FL>::Type Type;
17180 enum : long long { VRType = VR::FL };
17181 enum { VMType = VM::VM1 };
17182 static const char* GetVMString() { return "1"; }
17183 };
17184 template <> struct TagToType<0x0046,0x0234> {
17185 static const char* GetVRString() { return "FL"; }
17186 typedef VRToType<VR::FL>::Type Type;
17187 enum : long long { VRType = VR::FL };
17188 enum { VMType = VM::VM1 };
17189 static const char* GetVMString() { return "1"; }
17190 };
17191 template <> struct TagToType<0x0046,0x0236> {
17192 static const char* GetVRString() { return "FL"; }
17193 typedef VRToType<VR::FL>::Type Type;
17194 enum : long long { VRType = VR::FL };
17195 enum { VMType = VM::VM1 };
17196 static const char* GetVMString() { return "1"; }
17197 };
17198 template <> struct TagToType<0x0046,0x0238> {
17199 static const char* GetVRString() { return "FL"; }
17200 typedef VRToType<VR::FL>::Type Type;
17201 enum : long long { VRType = VR::FL };
17202 enum { VMType = VM::VM1 };
17203 static const char* GetVMString() { return "1"; }
17204 };
17205 template <> struct TagToType<0x0046,0x0242> {
17206 static const char* GetVRString() { return "CS"; }
17207 typedef VRToType<VR::CS>::Type Type;
17208 enum : long long { VRType = VR::CS };
17209 enum { VMType = VM::VM1 };
17210 static const char* GetVMString() { return "1"; }
17211 };
17212 template <> struct TagToType<0x0046,0x0244> {
17213 static const char* GetVRString() { return "SQ"; }
17214 typedef VRToType<VR::SQ>::Type Type;
17215 enum : long long { VRType = VR::SQ };
17216 enum { VMType = VM::VM1 };
17217 static const char* GetVMString() { return "1"; }
17218 };
17219 template <> struct TagToType<0x0046,0x0247> {
17220 static const char* GetVRString() { return "FL"; }
17221 typedef VRToType<VR::FL>::Type Type;
17222 enum : long long { VRType = VR::FL };
17223 enum { VMType = VM::VM3 };
17224 static const char* GetVMString() { return "3"; }
17225 };
17226 template <> struct TagToType<0x0046,0x0248> {
17227 static const char* GetVRString() { return "CS"; }
17228 typedef VRToType<VR::CS>::Type Type;
17229 enum : long long { VRType = VR::CS };
17230 enum { VMType = VM::VM1 };
17231 static const char* GetVMString() { return "1"; }
17232 };
17233 template <> struct TagToType<0x0046,0x0249> {
17234 static const char* GetVRString() { return "FL"; }
17235 typedef VRToType<VR::FL>::Type Type;
17236 enum : long long { VRType = VR::FL };
17237 enum { VMType = VM::VM1 };
17238 static const char* GetVMString() { return "1"; }
17239 };
17240 template <> struct TagToType<0x0046,0x0250> {
17241 static const char* GetVRString() { return "FL"; }
17242 typedef VRToType<VR::FL>::Type Type;
17243 enum : long long { VRType = VR::FL };
17244 enum { VMType = VM::VM1 };
17245 static const char* GetVMString() { return "1"; }
17246 };
17247 template <> struct TagToType<0x0046,0x0251> {
17248 static const char* GetVRString() { return "FL"; }
17249 typedef VRToType<VR::FL>::Type Type;
17250 enum : long long { VRType = VR::FL };
17251 enum { VMType = VM::VM1 };
17252 static const char* GetVMString() { return "1"; }
17253 };
17254 template <> struct TagToType<0x0046,0x0252> {
17255 static const char* GetVRString() { return "FL"; }
17256 typedef VRToType<VR::FL>::Type Type;
17257 enum : long long { VRType = VR::FL };
17258 enum { VMType = VM::VM1 };
17259 static const char* GetVMString() { return "1"; }
17260 };
17261 template <> struct TagToType<0x0046,0x0253> {
17262 static const char* GetVRString() { return "FL"; }
17263 typedef VRToType<VR::FL>::Type Type;
17264 enum : long long { VRType = VR::FL };
17265 enum { VMType = VM::VM1 };
17266 static const char* GetVMString() { return "1"; }
17267 };
17268 template <> struct TagToType<0x0048,0x0001> {
17269 static const char* GetVRString() { return "FL"; }
17270 typedef VRToType<VR::FL>::Type Type;
17271 enum : long long { VRType = VR::FL };
17272 enum { VMType = VM::VM1 };
17273 static const char* GetVMString() { return "1"; }
17274 };
17275 template <> struct TagToType<0x0048,0x0002> {
17276 static const char* GetVRString() { return "FL"; }
17277 typedef VRToType<VR::FL>::Type Type;
17278 enum : long long { VRType = VR::FL };
17279 enum { VMType = VM::VM1 };
17280 static const char* GetVMString() { return "1"; }
17281 };
17282 template <> struct TagToType<0x0048,0x0003> {
17283 static const char* GetVRString() { return "FL"; }
17284 typedef VRToType<VR::FL>::Type Type;
17285 enum : long long { VRType = VR::FL };
17286 enum { VMType = VM::VM1 };
17287 static const char* GetVMString() { return "1"; }
17288 };
17289 template <> struct TagToType<0x0048,0x0006> {
17290 static const char* GetVRString() { return "UL"; }
17291 typedef VRToType<VR::UL>::Type Type;
17292 enum : long long { VRType = VR::UL };
17293 enum { VMType = VM::VM1 };
17294 static const char* GetVMString() { return "1"; }
17295 };
17296 template <> struct TagToType<0x0048,0x0007> {
17297 static const char* GetVRString() { return "UL"; }
17298 typedef VRToType<VR::UL>::Type Type;
17299 enum : long long { VRType = VR::UL };
17300 enum { VMType = VM::VM1 };
17301 static const char* GetVMString() { return "1"; }
17302 };
17303 template <> struct TagToType<0x0048,0x0008> {
17304 static const char* GetVRString() { return "SQ"; }
17305 typedef VRToType<VR::SQ>::Type Type;
17306 enum : long long { VRType = VR::SQ };
17307 enum { VMType = VM::VM1 };
17308 static const char* GetVMString() { return "1"; }
17309 };
17310 template <> struct TagToType<0x0048,0x0010> {
17311 static const char* GetVRString() { return "CS"; }
17312 typedef VRToType<VR::CS>::Type Type;
17313 enum : long long { VRType = VR::CS };
17314 enum { VMType = VM::VM1 };
17315 static const char* GetVMString() { return "1"; }
17316 };
17317 template <> struct TagToType<0x0048,0x0011> {
17318 static const char* GetVRString() { return "CS"; }
17319 typedef VRToType<VR::CS>::Type Type;
17320 enum : long long { VRType = VR::CS };
17321 enum { VMType = VM::VM1 };
17322 static const char* GetVMString() { return "1"; }
17323 };
17324 template <> struct TagToType<0x0048,0x0012> {
17325 static const char* GetVRString() { return "CS"; }
17326 typedef VRToType<VR::CS>::Type Type;
17327 enum : long long { VRType = VR::CS };
17328 enum { VMType = VM::VM1 };
17329 static const char* GetVMString() { return "1"; }
17330 };
17331 template <> struct TagToType<0x0048,0x0013> {
17332 static const char* GetVRString() { return "US"; }
17333 typedef VRToType<VR::US>::Type Type;
17334 enum : long long { VRType = VR::US };
17335 enum { VMType = VM::VM1 };
17336 static const char* GetVMString() { return "1"; }
17337 };
17338 template <> struct TagToType<0x0048,0x0014> {
17339 static const char* GetVRString() { return "FL"; }
17340 typedef VRToType<VR::FL>::Type Type;
17341 enum : long long { VRType = VR::FL };
17342 enum { VMType = VM::VM1 };
17343 static const char* GetVMString() { return "1"; }
17344 };
17345 template <> struct TagToType<0x0048,0x0015> {
17346 static const char* GetVRString() { return "US"; }
17347 typedef VRToType<VR::US>::Type Type;
17348 enum : long long { VRType = VR::US };
17349 enum { VMType = VM::VM3 };
17350 static const char* GetVMString() { return "3"; }
17351 };
17352 template <> struct TagToType<0x0048,0x0100> {
17353 static const char* GetVRString() { return "SQ"; }
17354 typedef VRToType<VR::SQ>::Type Type;
17355 enum : long long { VRType = VR::SQ };
17356 enum { VMType = VM::VM1 };
17357 static const char* GetVMString() { return "1"; }
17358 };
17359 template <> struct TagToType<0x0048,0x0102> {
17360 static const char* GetVRString() { return "DS"; }
17361 typedef VRToType<VR::DS>::Type Type;
17362 enum : long long { VRType = VR::DS };
17363 enum { VMType = VM::VM6 };
17364 static const char* GetVMString() { return "6"; }
17365 };
17366 template <> struct TagToType<0x0048,0x0105> {
17367 static const char* GetVRString() { return "SQ"; }
17368 typedef VRToType<VR::SQ>::Type Type;
17369 enum : long long { VRType = VR::SQ };
17370 enum { VMType = VM::VM1 };
17371 static const char* GetVMString() { return "1"; }
17372 };
17373 template <> struct TagToType<0x0048,0x0106> {
17374 static const char* GetVRString() { return "SH"; }
17375 typedef VRToType<VR::SH>::Type Type;
17376 enum : long long { VRType = VR::SH };
17377 enum { VMType = VM::VM1 };
17378 static const char* GetVMString() { return "1"; }
17379 };
17380 template <> struct TagToType<0x0048,0x0107> {
17381 static const char* GetVRString() { return "ST"; }
17382 typedef VRToType<VR::ST>::Type Type;
17383 enum : long long { VRType = VR::ST };
17384 enum { VMType = VM::VM1 };
17385 static const char* GetVMString() { return "1"; }
17386 };
17387 template <> struct TagToType<0x0048,0x0108> {
17388 static const char* GetVRString() { return "SQ"; }
17389 typedef VRToType<VR::SQ>::Type Type;
17390 enum : long long { VRType = VR::SQ };
17391 enum { VMType = VM::VM1 };
17392 static const char* GetVMString() { return "1"; }
17393 };
17394 template <> struct TagToType<0x0048,0x0110> {
17395 static const char* GetVRString() { return "SQ"; }
17396 typedef VRToType<VR::SQ>::Type Type;
17397 enum : long long { VRType = VR::SQ };
17398 enum { VMType = VM::VM1 };
17399 static const char* GetVMString() { return "1"; }
17400 };
17401 template <> struct TagToType<0x0048,0x0111> {
17402 static const char* GetVRString() { return "DS"; }
17403 typedef VRToType<VR::DS>::Type Type;
17404 enum : long long { VRType = VR::DS };
17405 enum { VMType = VM::VM1 };
17406 static const char* GetVMString() { return "1"; }
17407 };
17408 template <> struct TagToType<0x0048,0x0112> {
17409 static const char* GetVRString() { return "DS"; }
17410 typedef VRToType<VR::DS>::Type Type;
17411 enum : long long { VRType = VR::DS };
17412 enum { VMType = VM::VM1 };
17413 static const char* GetVMString() { return "1"; }
17414 };
17415 template <> struct TagToType<0x0048,0x0113> {
17416 static const char* GetVRString() { return "DS"; }
17417 typedef VRToType<VR::DS>::Type Type;
17418 enum : long long { VRType = VR::DS };
17419 enum { VMType = VM::VM1 };
17420 static const char* GetVMString() { return "1"; }
17421 };
17422 template <> struct TagToType<0x0048,0x0120> {
17423 static const char* GetVRString() { return "SQ"; }
17424 typedef VRToType<VR::SQ>::Type Type;
17425 enum : long long { VRType = VR::SQ };
17426 enum { VMType = VM::VM1 };
17427 static const char* GetVMString() { return "1"; }
17428 };
17429 template <> struct TagToType<0x0048,0x0200> {
17430 static const char* GetVRString() { return "SQ"; }
17431 typedef VRToType<VR::SQ>::Type Type;
17432 enum : long long { VRType = VR::SQ };
17433 enum { VMType = VM::VM1 };
17434 static const char* GetVMString() { return "1"; }
17435 };
17436 template <> struct TagToType<0x0048,0x0201> {
17437 static const char* GetVRString() { return "US"; }
17438 typedef VRToType<VR::US>::Type Type;
17439 enum : long long { VRType = VR::US };
17440 enum { VMType = VM::VM2 };
17441 static const char* GetVMString() { return "2"; }
17442 };
17443 template <> struct TagToType<0x0048,0x0202> {
17444 static const char* GetVRString() { return "US"; }
17445 typedef VRToType<VR::US>::Type Type;
17446 enum : long long { VRType = VR::US };
17447 enum { VMType = VM::VM2 };
17448 static const char* GetVMString() { return "2"; }
17449 };
17450 template <> struct TagToType<0x0048,0x0207> {
17451 static const char* GetVRString() { return "SQ"; }
17452 typedef VRToType<VR::SQ>::Type Type;
17453 enum : long long { VRType = VR::SQ };
17454 enum { VMType = VM::VM1 };
17455 static const char* GetVMString() { return "1"; }
17456 };
17457 template <> struct TagToType<0x0048,0x021a> {
17458 static const char* GetVRString() { return "SQ"; }
17459 typedef VRToType<VR::SQ>::Type Type;
17460 enum : long long { VRType = VR::SQ };
17461 enum { VMType = VM::VM1 };
17462 static const char* GetVMString() { return "1"; }
17463 };
17464 template <> struct TagToType<0x0048,0x021e> {
17465 static const char* GetVRString() { return "SL"; }
17466 typedef VRToType<VR::SL>::Type Type;
17467 enum : long long { VRType = VR::SL };
17468 enum { VMType = VM::VM1 };
17469 static const char* GetVMString() { return "1"; }
17470 };
17471 template <> struct TagToType<0x0048,0x021f> {
17472 static const char* GetVRString() { return "SL"; }
17473 typedef VRToType<VR::SL>::Type Type;
17474 enum : long long { VRType = VR::SL };
17475 enum { VMType = VM::VM1 };
17476 static const char* GetVMString() { return "1"; }
17477 };
17478 template <> struct TagToType<0x0048,0x0301> {
17479 static const char* GetVRString() { return "CS"; }
17480 typedef VRToType<VR::CS>::Type Type;
17481 enum : long long { VRType = VR::CS };
17482 enum { VMType = VM::VM1 };
17483 static const char* GetVMString() { return "1"; }
17484 };
17485 template <> struct TagToType<0x0050,0x0004> {
17486 static const char* GetVRString() { return "CS"; }
17487 typedef VRToType<VR::CS>::Type Type;
17488 enum : long long { VRType = VR::CS };
17489 enum { VMType = VM::VM1 };
17490 static const char* GetVMString() { return "1"; }
17491 };
17492 template <> struct TagToType<0x0050,0x0010> {
17493 static const char* GetVRString() { return "SQ"; }
17494 typedef VRToType<VR::SQ>::Type Type;
17495 enum : long long { VRType = VR::SQ };
17496 enum { VMType = VM::VM1 };
17497 static const char* GetVMString() { return "1"; }
17498 };
17499 template <> struct TagToType<0x0050,0x0012> {
17500 static const char* GetVRString() { return "SQ"; }
17501 typedef VRToType<VR::SQ>::Type Type;
17502 enum : long long { VRType = VR::SQ };
17503 enum { VMType = VM::VM1 };
17504 static const char* GetVMString() { return "1"; }
17505 };
17506 template <> struct TagToType<0x0050,0x0013> {
17507 static const char* GetVRString() { return "FD"; }
17508 typedef VRToType<VR::FD>::Type Type;
17509 enum : long long { VRType = VR::FD };
17510 enum { VMType = VM::VM1 };
17511 static const char* GetVMString() { return "1"; }
17512 };
17513 template <> struct TagToType<0x0050,0x0014> {
17514 static const char* GetVRString() { return "DS"; }
17515 typedef VRToType<VR::DS>::Type Type;
17516 enum : long long { VRType = VR::DS };
17517 enum { VMType = VM::VM1 };
17518 static const char* GetVMString() { return "1"; }
17519 };
17520 template <> struct TagToType<0x0050,0x0015> {
17521 static const char* GetVRString() { return "FD"; }
17522 typedef VRToType<VR::FD>::Type Type;
17523 enum : long long { VRType = VR::FD };
17524 enum { VMType = VM::VM1 };
17525 static const char* GetVMString() { return "1"; }
17526 };
17527 template <> struct TagToType<0x0050,0x0016> {
17528 static const char* GetVRString() { return "DS"; }
17529 typedef VRToType<VR::DS>::Type Type;
17530 enum : long long { VRType = VR::DS };
17531 enum { VMType = VM::VM1 };
17532 static const char* GetVMString() { return "1"; }
17533 };
17534 template <> struct TagToType<0x0050,0x0017> {
17535 static const char* GetVRString() { return "CS"; }
17536 typedef VRToType<VR::CS>::Type Type;
17537 enum : long long { VRType = VR::CS };
17538 enum { VMType = VM::VM1 };
17539 static const char* GetVMString() { return "1"; }
17540 };
17541 template <> struct TagToType<0x0050,0x0018> {
17542 static const char* GetVRString() { return "DS"; }
17543 typedef VRToType<VR::DS>::Type Type;
17544 enum : long long { VRType = VR::DS };
17545 enum { VMType = VM::VM1 };
17546 static const char* GetVMString() { return "1"; }
17547 };
17548 template <> struct TagToType<0x0050,0x0019> {
17549 static const char* GetVRString() { return "DS"; }
17550 typedef VRToType<VR::DS>::Type Type;
17551 enum : long long { VRType = VR::DS };
17552 enum { VMType = VM::VM1 };
17553 static const char* GetVMString() { return "1"; }
17554 };
17555 template <> struct TagToType<0x0050,0x001a> {
17556 static const char* GetVRString() { return "CS"; }
17557 typedef VRToType<VR::CS>::Type Type;
17558 enum : long long { VRType = VR::CS };
17559 enum { VMType = VM::VM1 };
17560 static const char* GetVMString() { return "1"; }
17561 };
17562 template <> struct TagToType<0x0050,0x001b> {
17563 static const char* GetVRString() { return "LO"; }
17564 typedef VRToType<VR::LO>::Type Type;
17565 enum : long long { VRType = VR::LO };
17566 enum { VMType = VM::VM1 };
17567 static const char* GetVMString() { return "1"; }
17568 };
17569 template <> struct TagToType<0x0050,0x001c> {
17570 static const char* GetVRString() { return "FD"; }
17571 typedef VRToType<VR::FD>::Type Type;
17572 enum : long long { VRType = VR::FD };
17573 enum { VMType = VM::VM1 };
17574 static const char* GetVMString() { return "1"; }
17575 };
17576 template <> struct TagToType<0x0050,0x001d> {
17577 static const char* GetVRString() { return "FD"; }
17578 typedef VRToType<VR::FD>::Type Type;
17579 enum : long long { VRType = VR::FD };
17580 enum { VMType = VM::VM1 };
17581 static const char* GetVMString() { return "1"; }
17582 };
17583 template <> struct TagToType<0x0050,0x001e> {
17584 static const char* GetVRString() { return "LO"; }
17585 typedef VRToType<VR::LO>::Type Type;
17586 enum : long long { VRType = VR::LO };
17587 enum { VMType = VM::VM1 };
17588 static const char* GetVMString() { return "1"; }
17589 };
17590 template <> struct TagToType<0x0050,0x0020> {
17591 static const char* GetVRString() { return "LO"; }
17592 typedef VRToType<VR::LO>::Type Type;
17593 enum : long long { VRType = VR::LO };
17594 enum { VMType = VM::VM1 };
17595 static const char* GetVMString() { return "1"; }
17596 };
17597 template <> struct TagToType<0x0052,0x0001> {
17598 static const char* GetVRString() { return "FL"; }
17599 typedef VRToType<VR::FL>::Type Type;
17600 enum : long long { VRType = VR::FL };
17601 enum { VMType = VM::VM1 };
17602 static const char* GetVMString() { return "1"; }
17603 };
17604 template <> struct TagToType<0x0052,0x0002> {
17605 static const char* GetVRString() { return "FD"; }
17606 typedef VRToType<VR::FD>::Type Type;
17607 enum : long long { VRType = VR::FD };
17608 enum { VMType = VM::VM1 };
17609 static const char* GetVMString() { return "1"; }
17610 };
17611 template <> struct TagToType<0x0052,0x0003> {
17612 static const char* GetVRString() { return "FD"; }
17613 typedef VRToType<VR::FD>::Type Type;
17614 enum : long long { VRType = VR::FD };
17615 enum { VMType = VM::VM1 };
17616 static const char* GetVMString() { return "1"; }
17617 };
17618 template <> struct TagToType<0x0052,0x0004> {
17619 static const char* GetVRString() { return "FD"; }
17620 typedef VRToType<VR::FD>::Type Type;
17621 enum : long long { VRType = VR::FD };
17622 enum { VMType = VM::VM1 };
17623 static const char* GetVMString() { return "1"; }
17624 };
17625 template <> struct TagToType<0x0052,0x0006> {
17626 static const char* GetVRString() { return "CS"; }
17627 typedef VRToType<VR::CS>::Type Type;
17628 enum : long long { VRType = VR::CS };
17629 enum { VMType = VM::VM1 };
17630 static const char* GetVMString() { return "1"; }
17631 };
17632 template <> struct TagToType<0x0052,0x0007> {
17633 static const char* GetVRString() { return "FD"; }
17634 typedef VRToType<VR::FD>::Type Type;
17635 enum : long long { VRType = VR::FD };
17636 enum { VMType = VM::VM1 };
17637 static const char* GetVMString() { return "1"; }
17638 };
17639 template <> struct TagToType<0x0052,0x0008> {
17640 static const char* GetVRString() { return "FD"; }
17641 typedef VRToType<VR::FD>::Type Type;
17642 enum : long long { VRType = VR::FD };
17643 enum { VMType = VM::VM1 };
17644 static const char* GetVMString() { return "1"; }
17645 };
17646 template <> struct TagToType<0x0052,0x0009> {
17647 static const char* GetVRString() { return "FD"; }
17648 typedef VRToType<VR::FD>::Type Type;
17649 enum : long long { VRType = VR::FD };
17650 enum { VMType = VM::VM1 };
17651 static const char* GetVMString() { return "1"; }
17652 };
17653 template <> struct TagToType<0x0052,0x0011> {
17654 static const char* GetVRString() { return "FD"; }
17655 typedef VRToType<VR::FD>::Type Type;
17656 enum : long long { VRType = VR::FD };
17657 enum { VMType = VM::VM1 };
17658 static const char* GetVMString() { return "1"; }
17659 };
17660 template <> struct TagToType<0x0052,0x0012> {
17661 static const char* GetVRString() { return "US"; }
17662 typedef VRToType<VR::US>::Type Type;
17663 enum : long long { VRType = VR::US };
17664 enum { VMType = VM::VM1 };
17665 static const char* GetVMString() { return "1"; }
17666 };
17667 template <> struct TagToType<0x0052,0x0013> {
17668 static const char* GetVRString() { return "FD"; }
17669 typedef VRToType<VR::FD>::Type Type;
17670 enum : long long { VRType = VR::FD };
17671 enum { VMType = VM::VM1 };
17672 static const char* GetVMString() { return "1"; }
17673 };
17674 template <> struct TagToType<0x0052,0x0014> {
17675 static const char* GetVRString() { return "FD"; }
17676 typedef VRToType<VR::FD>::Type Type;
17677 enum : long long { VRType = VR::FD };
17678 enum { VMType = VM::VM1 };
17679 static const char* GetVMString() { return "1"; }
17680 };
17681 template <> struct TagToType<0x0052,0x0016> {
17682 static const char* GetVRString() { return "SQ"; }
17683 typedef VRToType<VR::SQ>::Type Type;
17684 enum : long long { VRType = VR::SQ };
17685 enum { VMType = VM::VM1 };
17686 static const char* GetVMString() { return "1"; }
17687 };
17688 template <> struct TagToType<0x0052,0x0025> {
17689 static const char* GetVRString() { return "SQ"; }
17690 typedef VRToType<VR::SQ>::Type Type;
17691 enum : long long { VRType = VR::SQ };
17692 enum { VMType = VM::VM1 };
17693 static const char* GetVMString() { return "1"; }
17694 };
17695 template <> struct TagToType<0x0052,0x0026> {
17696 static const char* GetVRString() { return "CS"; }
17697 typedef VRToType<VR::CS>::Type Type;
17698 enum : long long { VRType = VR::CS };
17699 enum { VMType = VM::VM1 };
17700 static const char* GetVMString() { return "1"; }
17701 };
17702 template <> struct TagToType<0x0052,0x0027> {
17703 static const char* GetVRString() { return "SQ"; }
17704 typedef VRToType<VR::SQ>::Type Type;
17705 enum : long long { VRType = VR::SQ };
17706 enum { VMType = VM::VM1 };
17707 static const char* GetVMString() { return "1"; }
17708 };
17709 template <> struct TagToType<0x0052,0x0028> {
17710 static const char* GetVRString() { return "FD"; }
17711 typedef VRToType<VR::FD>::Type Type;
17712 enum : long long { VRType = VR::FD };
17713 enum { VMType = VM::VM1 };
17714 static const char* GetVMString() { return "1"; }
17715 };
17716 template <> struct TagToType<0x0052,0x0029> {
17717 static const char* GetVRString() { return "SQ"; }
17718 typedef VRToType<VR::SQ>::Type Type;
17719 enum : long long { VRType = VR::SQ };
17720 enum { VMType = VM::VM1 };
17721 static const char* GetVMString() { return "1"; }
17722 };
17723 template <> struct TagToType<0x0052,0x0030> {
17724 static const char* GetVRString() { return "SS"; }
17725 typedef VRToType<VR::SS>::Type Type;
17726 enum : long long { VRType = VR::SS };
17727 enum { VMType = VM::VM1 };
17728 static const char* GetVMString() { return "1"; }
17729 };
17730 template <> struct TagToType<0x0052,0x0031> {
17731 static const char* GetVRString() { return "CS"; }
17732 typedef VRToType<VR::CS>::Type Type;
17733 enum : long long { VRType = VR::CS };
17734 enum { VMType = VM::VM1 };
17735 static const char* GetVMString() { return "1"; }
17736 };
17737 template <> struct TagToType<0x0052,0x0033> {
17738 static const char* GetVRString() { return "FD"; }
17739 typedef VRToType<VR::FD>::Type Type;
17740 enum : long long { VRType = VR::FD };
17741 enum { VMType = VM::VM1 };
17742 static const char* GetVMString() { return "1"; }
17743 };
17744 template <> struct TagToType<0x0052,0x0034> {
17745 static const char* GetVRString() { return "FD"; }
17746 typedef VRToType<VR::FD>::Type Type;
17747 enum : long long { VRType = VR::FD };
17748 enum { VMType = VM::VM1 };
17749 static const char* GetVMString() { return "1"; }
17750 };
17751 template <> struct TagToType<0x0052,0x0036> {
17752 static const char* GetVRString() { return "US"; }
17753 typedef VRToType<VR::US>::Type Type;
17754 enum : long long { VRType = VR::US };
17755 enum { VMType = VM::VM1 };
17756 static const char* GetVMString() { return "1"; }
17757 };
17758 template <> struct TagToType<0x0052,0x0038> {
17759 static const char* GetVRString() { return "US"; }
17760 typedef VRToType<VR::US>::Type Type;
17761 enum : long long { VRType = VR::US };
17762 enum { VMType = VM::VM1 };
17763 static const char* GetVMString() { return "1"; }
17764 };
17765 template <> struct TagToType<0x0052,0x0039> {
17766 static const char* GetVRString() { return "CS"; }
17767 typedef VRToType<VR::CS>::Type Type;
17768 enum : long long { VRType = VR::CS };
17769 enum { VMType = VM::VM1 };
17770 static const char* GetVMString() { return "1"; }
17771 };
17772 template <> struct TagToType<0x0052,0x003a> {
17773 static const char* GetVRString() { return "CS"; }
17774 typedef VRToType<VR::CS>::Type Type;
17775 enum : long long { VRType = VR::CS };
17776 enum { VMType = VM::VM1 };
17777 static const char* GetVMString() { return "1"; }
17778 };
17779 template <> struct TagToType<0x0054,0x0010> {
17780 static const char* GetVRString() { return "US"; }
17781 typedef VRToType<VR::US>::Type Type;
17782 enum : long long { VRType = VR::US };
17783 enum { VMType = VM::VM1_n };
17784 static const char* GetVMString() { return "1-n"; }
17785 };
17786 template <> struct TagToType<0x0054,0x0011> {
17787 static const char* GetVRString() { return "US"; }
17788 typedef VRToType<VR::US>::Type Type;
17789 enum : long long { VRType = VR::US };
17790 enum { VMType = VM::VM1 };
17791 static const char* GetVMString() { return "1"; }
17792 };
17793 template <> struct TagToType<0x0054,0x0012> {
17794 static const char* GetVRString() { return "SQ"; }
17795 typedef VRToType<VR::SQ>::Type Type;
17796 enum : long long { VRType = VR::SQ };
17797 enum { VMType = VM::VM1 };
17798 static const char* GetVMString() { return "1"; }
17799 };
17800 template <> struct TagToType<0x0054,0x0013> {
17801 static const char* GetVRString() { return "SQ"; }
17802 typedef VRToType<VR::SQ>::Type Type;
17803 enum : long long { VRType = VR::SQ };
17804 enum { VMType = VM::VM1 };
17805 static const char* GetVMString() { return "1"; }
17806 };
17807 template <> struct TagToType<0x0054,0x0014> {
17808 static const char* GetVRString() { return "DS"; }
17809 typedef VRToType<VR::DS>::Type Type;
17810 enum : long long { VRType = VR::DS };
17811 enum { VMType = VM::VM1 };
17812 static const char* GetVMString() { return "1"; }
17813 };
17814 template <> struct TagToType<0x0054,0x0015> {
17815 static const char* GetVRString() { return "DS"; }
17816 typedef VRToType<VR::DS>::Type Type;
17817 enum : long long { VRType = VR::DS };
17818 enum { VMType = VM::VM1 };
17819 static const char* GetVMString() { return "1"; }
17820 };
17821 template <> struct TagToType<0x0054,0x0016> {
17822 static const char* GetVRString() { return "SQ"; }
17823 typedef VRToType<VR::SQ>::Type Type;
17824 enum : long long { VRType = VR::SQ };
17825 enum { VMType = VM::VM1 };
17826 static const char* GetVMString() { return "1"; }
17827 };
17828 template <> struct TagToType<0x0054,0x0017> {
17829 static const char* GetVRString() { return "IS"; }
17830 typedef VRToType<VR::IS>::Type Type;
17831 enum : long long { VRType = VR::IS };
17832 enum { VMType = VM::VM1 };
17833 static const char* GetVMString() { return "1"; }
17834 };
17835 template <> struct TagToType<0x0054,0x0018> {
17836 static const char* GetVRString() { return "SH"; }
17837 typedef VRToType<VR::SH>::Type Type;
17838 enum : long long { VRType = VR::SH };
17839 enum { VMType = VM::VM1 };
17840 static const char* GetVMString() { return "1"; }
17841 };
17842 template <> struct TagToType<0x0054,0x0020> {
17843 static const char* GetVRString() { return "US"; }
17844 typedef VRToType<VR::US>::Type Type;
17845 enum : long long { VRType = VR::US };
17846 enum { VMType = VM::VM1_n };
17847 static const char* GetVMString() { return "1-n"; }
17848 };
17849 template <> struct TagToType<0x0054,0x0021> {
17850 static const char* GetVRString() { return "US"; }
17851 typedef VRToType<VR::US>::Type Type;
17852 enum : long long { VRType = VR::US };
17853 enum { VMType = VM::VM1 };
17854 static const char* GetVMString() { return "1"; }
17855 };
17856 template <> struct TagToType<0x0054,0x0022> {
17857 static const char* GetVRString() { return "SQ"; }
17858 typedef VRToType<VR::SQ>::Type Type;
17859 enum : long long { VRType = VR::SQ };
17860 enum { VMType = VM::VM1 };
17861 static const char* GetVMString() { return "1"; }
17862 };
17863 template <> struct TagToType<0x0054,0x0030> {
17864 static const char* GetVRString() { return "US"; }
17865 typedef VRToType<VR::US>::Type Type;
17866 enum : long long { VRType = VR::US };
17867 enum { VMType = VM::VM1_n };
17868 static const char* GetVMString() { return "1-n"; }
17869 };
17870 template <> struct TagToType<0x0054,0x0031> {
17871 static const char* GetVRString() { return "US"; }
17872 typedef VRToType<VR::US>::Type Type;
17873 enum : long long { VRType = VR::US };
17874 enum { VMType = VM::VM1 };
17875 static const char* GetVMString() { return "1"; }
17876 };
17877 template <> struct TagToType<0x0054,0x0032> {
17878 static const char* GetVRString() { return "SQ"; }
17879 typedef VRToType<VR::SQ>::Type Type;
17880 enum : long long { VRType = VR::SQ };
17881 enum { VMType = VM::VM1 };
17882 static const char* GetVMString() { return "1"; }
17883 };
17884 template <> struct TagToType<0x0054,0x0033> {
17885 static const char* GetVRString() { return "US"; }
17886 typedef VRToType<VR::US>::Type Type;
17887 enum : long long { VRType = VR::US };
17888 enum { VMType = VM::VM1 };
17889 static const char* GetVMString() { return "1"; }
17890 };
17891 template <> struct TagToType<0x0054,0x0036> {
17892 static const char* GetVRString() { return "IS"; }
17893 typedef VRToType<VR::IS>::Type Type;
17894 enum : long long { VRType = VR::IS };
17895 enum { VMType = VM::VM1 };
17896 static const char* GetVMString() { return "1"; }
17897 };
17898 template <> struct TagToType<0x0054,0x0038> {
17899 static const char* GetVRString() { return "IS"; }
17900 typedef VRToType<VR::IS>::Type Type;
17901 enum : long long { VRType = VR::IS };
17902 enum { VMType = VM::VM1 };
17903 static const char* GetVMString() { return "1"; }
17904 };
17905 template <> struct TagToType<0x0054,0x0039> {
17906 static const char* GetVRString() { return "CS"; }
17907 typedef VRToType<VR::CS>::Type Type;
17908 enum : long long { VRType = VR::CS };
17909 enum { VMType = VM::VM1 };
17910 static const char* GetVMString() { return "1"; }
17911 };
17912 template <> struct TagToType<0x0054,0x0050> {
17913 static const char* GetVRString() { return "US"; }
17914 typedef VRToType<VR::US>::Type Type;
17915 enum : long long { VRType = VR::US };
17916 enum { VMType = VM::VM1_n };
17917 static const char* GetVMString() { return "1-n"; }
17918 };
17919 template <> struct TagToType<0x0054,0x0051> {
17920 static const char* GetVRString() { return "US"; }
17921 typedef VRToType<VR::US>::Type Type;
17922 enum : long long { VRType = VR::US };
17923 enum { VMType = VM::VM1 };
17924 static const char* GetVMString() { return "1"; }
17925 };
17926 template <> struct TagToType<0x0054,0x0052> {
17927 static const char* GetVRString() { return "SQ"; }
17928 typedef VRToType<VR::SQ>::Type Type;
17929 enum : long long { VRType = VR::SQ };
17930 enum { VMType = VM::VM1 };
17931 static const char* GetVMString() { return "1"; }
17932 };
17933 template <> struct TagToType<0x0054,0x0053> {
17934 static const char* GetVRString() { return "US"; }
17935 typedef VRToType<VR::US>::Type Type;
17936 enum : long long { VRType = VR::US };
17937 enum { VMType = VM::VM1 };
17938 static const char* GetVMString() { return "1"; }
17939 };
17940 template <> struct TagToType<0x0054,0x0060> {
17941 static const char* GetVRString() { return "US"; }
17942 typedef VRToType<VR::US>::Type Type;
17943 enum : long long { VRType = VR::US };
17944 enum { VMType = VM::VM1_n };
17945 static const char* GetVMString() { return "1-n"; }
17946 };
17947 template <> struct TagToType<0x0054,0x0061> {
17948 static const char* GetVRString() { return "US"; }
17949 typedef VRToType<VR::US>::Type Type;
17950 enum : long long { VRType = VR::US };
17951 enum { VMType = VM::VM1 };
17952 static const char* GetVMString() { return "1"; }
17953 };
17954 template <> struct TagToType<0x0054,0x0062> {
17955 static const char* GetVRString() { return "SQ"; }
17956 typedef VRToType<VR::SQ>::Type Type;
17957 enum : long long { VRType = VR::SQ };
17958 enum { VMType = VM::VM1 };
17959 static const char* GetVMString() { return "1"; }
17960 };
17961 template <> struct TagToType<0x0054,0x0063> {
17962 static const char* GetVRString() { return "SQ"; }
17963 typedef VRToType<VR::SQ>::Type Type;
17964 enum : long long { VRType = VR::SQ };
17965 enum { VMType = VM::VM1 };
17966 static const char* GetVMString() { return "1"; }
17967 };
17968 template <> struct TagToType<0x0054,0x0070> {
17969 static const char* GetVRString() { return "US"; }
17970 typedef VRToType<VR::US>::Type Type;
17971 enum : long long { VRType = VR::US };
17972 enum { VMType = VM::VM1_n };
17973 static const char* GetVMString() { return "1-n"; }
17974 };
17975 template <> struct TagToType<0x0054,0x0071> {
17976 static const char* GetVRString() { return "US"; }
17977 typedef VRToType<VR::US>::Type Type;
17978 enum : long long { VRType = VR::US };
17979 enum { VMType = VM::VM1 };
17980 static const char* GetVMString() { return "1"; }
17981 };
17982 template <> struct TagToType<0x0054,0x0072> {
17983 static const char* GetVRString() { return "SQ"; }
17984 typedef VRToType<VR::SQ>::Type Type;
17985 enum : long long { VRType = VR::SQ };
17986 enum { VMType = VM::VM1 };
17987 static const char* GetVMString() { return "1"; }
17988 };
17989 template <> struct TagToType<0x0054,0x0073> {
17990 static const char* GetVRString() { return "DS"; }
17991 typedef VRToType<VR::DS>::Type Type;
17992 enum : long long { VRType = VR::DS };
17993 enum { VMType = VM::VM1 };
17994 static const char* GetVMString() { return "1"; }
17995 };
17996 template <> struct TagToType<0x0054,0x0080> {
17997 static const char* GetVRString() { return "US"; }
17998 typedef VRToType<VR::US>::Type Type;
17999 enum : long long { VRType = VR::US };
18000 enum { VMType = VM::VM1_n };
18001 static const char* GetVMString() { return "1-n"; }
18002 };
18003 template <> struct TagToType<0x0054,0x0081> {
18004 static const char* GetVRString() { return "US"; }
18005 typedef VRToType<VR::US>::Type Type;
18006 enum : long long { VRType = VR::US };
18007 enum { VMType = VM::VM1 };
18008 static const char* GetVMString() { return "1"; }
18009 };
18010 template <> struct TagToType<0x0054,0x0090> {
18011 static const char* GetVRString() { return "US"; }
18012 typedef VRToType<VR::US>::Type Type;
18013 enum : long long { VRType = VR::US };
18014 enum { VMType = VM::VM1_n };
18015 static const char* GetVMString() { return "1-n"; }
18016 };
18017 template <> struct TagToType<0x0054,0x0100> {
18018 static const char* GetVRString() { return "US"; }
18019 typedef VRToType<VR::US>::Type Type;
18020 enum : long long { VRType = VR::US };
18021 enum { VMType = VM::VM1_n };
18022 static const char* GetVMString() { return "1-n"; }
18023 };
18024 template <> struct TagToType<0x0054,0x0101> {
18025 static const char* GetVRString() { return "US"; }
18026 typedef VRToType<VR::US>::Type Type;
18027 enum : long long { VRType = VR::US };
18028 enum { VMType = VM::VM1 };
18029 static const char* GetVMString() { return "1"; }
18030 };
18031 template <> struct TagToType<0x0054,0x0200> {
18032 static const char* GetVRString() { return "DS"; }
18033 typedef VRToType<VR::DS>::Type Type;
18034 enum : long long { VRType = VR::DS };
18035 enum { VMType = VM::VM1 };
18036 static const char* GetVMString() { return "1"; }
18037 };
18038 template <> struct TagToType<0x0054,0x0202> {
18039 static const char* GetVRString() { return "CS"; }
18040 typedef VRToType<VR::CS>::Type Type;
18041 enum : long long { VRType = VR::CS };
18042 enum { VMType = VM::VM1 };
18043 static const char* GetVMString() { return "1"; }
18044 };
18045 template <> struct TagToType<0x0054,0x0210> {
18046 static const char* GetVRString() { return "IS"; }
18047 typedef VRToType<VR::IS>::Type Type;
18048 enum : long long { VRType = VR::IS };
18049 enum { VMType = VM::VM1_n };
18050 static const char* GetVMString() { return "1-n"; }
18051 };
18052 template <> struct TagToType<0x0054,0x0211> {
18053 static const char* GetVRString() { return "US"; }
18054 typedef VRToType<VR::US>::Type Type;
18055 enum : long long { VRType = VR::US };
18056 enum { VMType = VM::VM1 };
18057 static const char* GetVMString() { return "1"; }
18058 };
18059 template <> struct TagToType<0x0054,0x0220> {
18060 static const char* GetVRString() { return "SQ"; }
18061 typedef VRToType<VR::SQ>::Type Type;
18062 enum : long long { VRType = VR::SQ };
18063 enum { VMType = VM::VM1 };
18064 static const char* GetVMString() { return "1"; }
18065 };
18066 template <> struct TagToType<0x0054,0x0222> {
18067 static const char* GetVRString() { return "SQ"; }
18068 typedef VRToType<VR::SQ>::Type Type;
18069 enum : long long { VRType = VR::SQ };
18070 enum { VMType = VM::VM1 };
18071 static const char* GetVMString() { return "1"; }
18072 };
18073 template <> struct TagToType<0x0054,0x0300> {
18074 static const char* GetVRString() { return "SQ"; }
18075 typedef VRToType<VR::SQ>::Type Type;
18076 enum : long long { VRType = VR::SQ };
18077 enum { VMType = VM::VM1 };
18078 static const char* GetVMString() { return "1"; }
18079 };
18080 template <> struct TagToType<0x0054,0x0302> {
18081 static const char* GetVRString() { return "SQ"; }
18082 typedef VRToType<VR::SQ>::Type Type;
18083 enum : long long { VRType = VR::SQ };
18084 enum { VMType = VM::VM1 };
18085 static const char* GetVMString() { return "1"; }
18086 };
18087 template <> struct TagToType<0x0054,0x0304> {
18088 static const char* GetVRString() { return "SQ"; }
18089 typedef VRToType<VR::SQ>::Type Type;
18090 enum : long long { VRType = VR::SQ };
18091 enum { VMType = VM::VM1 };
18092 static const char* GetVMString() { return "1"; }
18093 };
18094 template <> struct TagToType<0x0054,0x0306> {
18095 static const char* GetVRString() { return "SQ"; }
18096 typedef VRToType<VR::SQ>::Type Type;
18097 enum : long long { VRType = VR::SQ };
18098 enum { VMType = VM::VM1 };
18099 static const char* GetVMString() { return "1"; }
18100 };
18101 template <> struct TagToType<0x0054,0x0308> {
18102 static const char* GetVRString() { return "US"; }
18103 typedef VRToType<VR::US>::Type Type;
18104 enum : long long { VRType = VR::US };
18105 enum { VMType = VM::VM1 };
18106 static const char* GetVMString() { return "1"; }
18107 };
18108 template <> struct TagToType<0x0054,0x0400> {
18109 static const char* GetVRString() { return "SH"; }
18110 typedef VRToType<VR::SH>::Type Type;
18111 enum : long long { VRType = VR::SH };
18112 enum { VMType = VM::VM1 };
18113 static const char* GetVMString() { return "1"; }
18114 };
18115 template <> struct TagToType<0x0054,0x0410> {
18116 static const char* GetVRString() { return "SQ"; }
18117 typedef VRToType<VR::SQ>::Type Type;
18118 enum : long long { VRType = VR::SQ };
18119 enum { VMType = VM::VM1 };
18120 static const char* GetVMString() { return "1"; }
18121 };
18122 template <> struct TagToType<0x0054,0x0412> {
18123 static const char* GetVRString() { return "SQ"; }
18124 typedef VRToType<VR::SQ>::Type Type;
18125 enum : long long { VRType = VR::SQ };
18126 enum { VMType = VM::VM1 };
18127 static const char* GetVMString() { return "1"; }
18128 };
18129 template <> struct TagToType<0x0054,0x0414> {
18130 static const char* GetVRString() { return "SQ"; }
18131 typedef VRToType<VR::SQ>::Type Type;
18132 enum : long long { VRType = VR::SQ };
18133 enum { VMType = VM::VM1 };
18134 static const char* GetVMString() { return "1"; }
18135 };
18136 template <> struct TagToType<0x0054,0x0500> {
18137 static const char* GetVRString() { return "CS"; }
18138 typedef VRToType<VR::CS>::Type Type;
18139 enum : long long { VRType = VR::CS };
18140 enum { VMType = VM::VM1 };
18141 static const char* GetVMString() { return "1"; }
18142 };
18143 template <> struct TagToType<0x0054,0x0501> {
18144 static const char* GetVRString() { return "CS"; }
18145 typedef VRToType<VR::CS>::Type Type;
18146 enum : long long { VRType = VR::CS };
18147 enum { VMType = VM::VM1 };
18148 static const char* GetVMString() { return "1"; }
18149 };
18150 template <> struct TagToType<0x0054,0x1000> {
18151 static const char* GetVRString() { return "CS"; }
18152 typedef VRToType<VR::CS>::Type Type;
18153 enum : long long { VRType = VR::CS };
18154 enum { VMType = VM::VM2 };
18155 static const char* GetVMString() { return "2"; }
18156 };
18157 template <> struct TagToType<0x0054,0x1001> {
18158 static const char* GetVRString() { return "CS"; }
18159 typedef VRToType<VR::CS>::Type Type;
18160 enum : long long { VRType = VR::CS };
18161 enum { VMType = VM::VM1 };
18162 static const char* GetVMString() { return "1"; }
18163 };
18164 template <> struct TagToType<0x0054,0x1002> {
18165 static const char* GetVRString() { return "CS"; }
18166 typedef VRToType<VR::CS>::Type Type;
18167 enum : long long { VRType = VR::CS };
18168 enum { VMType = VM::VM1 };
18169 static const char* GetVMString() { return "1"; }
18170 };
18171 template <> struct TagToType<0x0054,0x1004> {
18172 static const char* GetVRString() { return "CS"; }
18173 typedef VRToType<VR::CS>::Type Type;
18174 enum : long long { VRType = VR::CS };
18175 enum { VMType = VM::VM1 };
18176 static const char* GetVMString() { return "1"; }
18177 };
18178 template <> struct TagToType<0x0054,0x1006> {
18179 static const char* GetVRString() { return "CS"; }
18180 typedef VRToType<VR::CS>::Type Type;
18181 enum : long long { VRType = VR::CS };
18182 enum { VMType = VM::VM1 };
18183 static const char* GetVMString() { return "1"; }
18184 };
18185 template <> struct TagToType<0x0054,0x1100> {
18186 static const char* GetVRString() { return "CS"; }
18187 typedef VRToType<VR::CS>::Type Type;
18188 enum : long long { VRType = VR::CS };
18189 enum { VMType = VM::VM1 };
18190 static const char* GetVMString() { return "1"; }
18191 };
18192 template <> struct TagToType<0x0054,0x1101> {
18193 static const char* GetVRString() { return "LO"; }
18194 typedef VRToType<VR::LO>::Type Type;
18195 enum : long long { VRType = VR::LO };
18196 enum { VMType = VM::VM1 };
18197 static const char* GetVMString() { return "1"; }
18198 };
18199 template <> struct TagToType<0x0054,0x1102> {
18200 static const char* GetVRString() { return "CS"; }
18201 typedef VRToType<VR::CS>::Type Type;
18202 enum : long long { VRType = VR::CS };
18203 enum { VMType = VM::VM1 };
18204 static const char* GetVMString() { return "1"; }
18205 };
18206 template <> struct TagToType<0x0054,0x1103> {
18207 static const char* GetVRString() { return "LO"; }
18208 typedef VRToType<VR::LO>::Type Type;
18209 enum : long long { VRType = VR::LO };
18210 enum { VMType = VM::VM1 };
18211 static const char* GetVMString() { return "1"; }
18212 };
18213 template <> struct TagToType<0x0054,0x1104> {
18214 static const char* GetVRString() { return "LO"; }
18215 typedef VRToType<VR::LO>::Type Type;
18216 enum : long long { VRType = VR::LO };
18217 enum { VMType = VM::VM1 };
18218 static const char* GetVMString() { return "1"; }
18219 };
18220 template <> struct TagToType<0x0054,0x1105> {
18221 static const char* GetVRString() { return "LO"; }
18222 typedef VRToType<VR::LO>::Type Type;
18223 enum : long long { VRType = VR::LO };
18224 enum { VMType = VM::VM1 };
18225 static const char* GetVMString() { return "1"; }
18226 };
18227 template <> struct TagToType<0x0054,0x1200> {
18228 static const char* GetVRString() { return "DS"; }
18229 typedef VRToType<VR::DS>::Type Type;
18230 enum : long long { VRType = VR::DS };
18231 enum { VMType = VM::VM1 };
18232 static const char* GetVMString() { return "1"; }
18233 };
18234 template <> struct TagToType<0x0054,0x1201> {
18235 static const char* GetVRString() { return "IS"; }
18236 typedef VRToType<VR::IS>::Type Type;
18237 enum : long long { VRType = VR::IS };
18238 enum { VMType = VM::VM2 };
18239 static const char* GetVMString() { return "2"; }
18240 };
18241 template <> struct TagToType<0x0054,0x1202> {
18242 static const char* GetVRString() { return "IS"; }
18243 typedef VRToType<VR::IS>::Type Type;
18244 enum : long long { VRType = VR::IS };
18245 enum { VMType = VM::VM1 };
18246 static const char* GetVMString() { return "1"; }
18247 };
18248 template <> struct TagToType<0x0054,0x1203> {
18249 static const char* GetVRString() { return "DS"; }
18250 typedef VRToType<VR::DS>::Type Type;
18251 enum : long long { VRType = VR::DS };
18252 enum { VMType = VM::VM2 };
18253 static const char* GetVMString() { return "2"; }
18254 };
18255 template <> struct TagToType<0x0054,0x1210> {
18256 static const char* GetVRString() { return "DS"; }
18257 typedef VRToType<VR::DS>::Type Type;
18258 enum : long long { VRType = VR::DS };
18259 enum { VMType = VM::VM1 };
18260 static const char* GetVMString() { return "1"; }
18261 };
18262 template <> struct TagToType<0x0054,0x1220> {
18263 static const char* GetVRString() { return "CS"; }
18264 typedef VRToType<VR::CS>::Type Type;
18265 enum : long long { VRType = VR::CS };
18266 enum { VMType = VM::VM1_n };
18267 static const char* GetVMString() { return "1-n"; }
18268 };
18269 template <> struct TagToType<0x0054,0x1300> {
18270 static const char* GetVRString() { return "DS"; }
18271 typedef VRToType<VR::DS>::Type Type;
18272 enum : long long { VRType = VR::DS };
18273 enum { VMType = VM::VM1 };
18274 static const char* GetVMString() { return "1"; }
18275 };
18276 template <> struct TagToType<0x0054,0x1310> {
18277 static const char* GetVRString() { return "IS"; }
18278 typedef VRToType<VR::IS>::Type Type;
18279 enum : long long { VRType = VR::IS };
18280 enum { VMType = VM::VM1 };
18281 static const char* GetVMString() { return "1"; }
18282 };
18283 template <> struct TagToType<0x0054,0x1311> {
18284 static const char* GetVRString() { return "IS"; }
18285 typedef VRToType<VR::IS>::Type Type;
18286 enum : long long { VRType = VR::IS };
18287 enum { VMType = VM::VM1_n };
18288 static const char* GetVMString() { return "1-n"; }
18289 };
18290 template <> struct TagToType<0x0054,0x1320> {
18291 static const char* GetVRString() { return "DS"; }
18292 typedef VRToType<VR::DS>::Type Type;
18293 enum : long long { VRType = VR::DS };
18294 enum { VMType = VM::VM1 };
18295 static const char* GetVMString() { return "1"; }
18296 };
18297 template <> struct TagToType<0x0054,0x1321> {
18298 static const char* GetVRString() { return "DS"; }
18299 typedef VRToType<VR::DS>::Type Type;
18300 enum : long long { VRType = VR::DS };
18301 enum { VMType = VM::VM1 };
18302 static const char* GetVMString() { return "1"; }
18303 };
18304 template <> struct TagToType<0x0054,0x1322> {
18305 static const char* GetVRString() { return "DS"; }
18306 typedef VRToType<VR::DS>::Type Type;
18307 enum : long long { VRType = VR::DS };
18308 enum { VMType = VM::VM1 };
18309 static const char* GetVMString() { return "1"; }
18310 };
18311 template <> struct TagToType<0x0054,0x1323> {
18312 static const char* GetVRString() { return "DS"; }
18313 typedef VRToType<VR::DS>::Type Type;
18314 enum : long long { VRType = VR::DS };
18315 enum { VMType = VM::VM1 };
18316 static const char* GetVMString() { return "1"; }
18317 };
18318 template <> struct TagToType<0x0054,0x1324> {
18319 static const char* GetVRString() { return "DS"; }
18320 typedef VRToType<VR::DS>::Type Type;
18321 enum : long long { VRType = VR::DS };
18322 enum { VMType = VM::VM1 };
18323 static const char* GetVMString() { return "1"; }
18324 };
18325 template <> struct TagToType<0x0054,0x1330> {
18326 static const char* GetVRString() { return "US"; }
18327 typedef VRToType<VR::US>::Type Type;
18328 enum : long long { VRType = VR::US };
18329 enum { VMType = VM::VM1 };
18330 static const char* GetVMString() { return "1"; }
18331 };
18332 template <> struct TagToType<0x0054,0x1400> {
18333 static const char* GetVRString() { return "CS"; }
18334 typedef VRToType<VR::CS>::Type Type;
18335 enum : long long { VRType = VR::CS };
18336 enum { VMType = VM::VM1_n };
18337 static const char* GetVMString() { return "1-n"; }
18338 };
18339 template <> struct TagToType<0x0054,0x1401> {
18340 static const char* GetVRString() { return "CS"; }
18341 typedef VRToType<VR::CS>::Type Type;
18342 enum : long long { VRType = VR::CS };
18343 enum { VMType = VM::VM1 };
18344 static const char* GetVMString() { return "1"; }
18345 };
18346 template <> struct TagToType<0x0060,0x3000> {
18347 static const char* GetVRString() { return "SQ"; }
18348 typedef VRToType<VR::SQ>::Type Type;
18349 enum : long long { VRType = VR::SQ };
18350 enum { VMType = VM::VM1 };
18351 static const char* GetVMString() { return "1"; }
18352 };
18353 template <> struct TagToType<0x0060,0x3002> {
18354 static const char* GetVRString() { return "US"; }
18355 typedef VRToType<VR::US>::Type Type;
18356 enum : long long { VRType = VR::US };
18357 enum { VMType = VM::VM1 };
18358 static const char* GetVMString() { return "1"; }
18359 };
18360 template <> struct TagToType<0x0060,0x3008> {
18361 static const char* GetVRString() { return "US"; }
18362 typedef VRToType<VR::US>::Type Type;
18363 enum : long long { VRType = VR::US };
18364 enum { VMType = VM::VM1 };
18365 static const char* GetVMString() { return "1"; }
18366 };
18367 template <> struct TagToType<0x0060,0x3010> {
18368 static const char* GetVRString() { return "LO"; }
18369 typedef VRToType<VR::LO>::Type Type;
18370 enum : long long { VRType = VR::LO };
18371 enum { VMType = VM::VM1 };
18372 static const char* GetVMString() { return "1"; }
18373 };
18374 template <> struct TagToType<0x0060,0x3020> {
18375 static const char* GetVRString() { return "UL"; }
18376 typedef VRToType<VR::UL>::Type Type;
18377 enum : long long { VRType = VR::UL };
18378 enum { VMType = VM::VM1_n };
18379 static const char* GetVMString() { return "1-n"; }
18380 };
18381 template <> struct TagToType<0x0062,0x0001> {
18382 static const char* GetVRString() { return "CS"; }
18383 typedef VRToType<VR::CS>::Type Type;
18384 enum : long long { VRType = VR::CS };
18385 enum { VMType = VM::VM1 };
18386 static const char* GetVMString() { return "1"; }
18387 };
18388 template <> struct TagToType<0x0062,0x0002> {
18389 static const char* GetVRString() { return "SQ"; }
18390 typedef VRToType<VR::SQ>::Type Type;
18391 enum : long long { VRType = VR::SQ };
18392 enum { VMType = VM::VM1 };
18393 static const char* GetVMString() { return "1"; }
18394 };
18395 template <> struct TagToType<0x0062,0x0003> {
18396 static const char* GetVRString() { return "SQ"; }
18397 typedef VRToType<VR::SQ>::Type Type;
18398 enum : long long { VRType = VR::SQ };
18399 enum { VMType = VM::VM1 };
18400 static const char* GetVMString() { return "1"; }
18401 };
18402 template <> struct TagToType<0x0062,0x0004> {
18403 static const char* GetVRString() { return "US"; }
18404 typedef VRToType<VR::US>::Type Type;
18405 enum : long long { VRType = VR::US };
18406 enum { VMType = VM::VM1 };
18407 static const char* GetVMString() { return "1"; }
18408 };
18409 template <> struct TagToType<0x0062,0x0005> {
18410 static const char* GetVRString() { return "LO"; }
18411 typedef VRToType<VR::LO>::Type Type;
18412 enum : long long { VRType = VR::LO };
18413 enum { VMType = VM::VM1 };
18414 static const char* GetVMString() { return "1"; }
18415 };
18416 template <> struct TagToType<0x0062,0x0006> {
18417 static const char* GetVRString() { return "ST"; }
18418 typedef VRToType<VR::ST>::Type Type;
18419 enum : long long { VRType = VR::ST };
18420 enum { VMType = VM::VM1 };
18421 static const char* GetVMString() { return "1"; }
18422 };
18423 template <> struct TagToType<0x0062,0x0007> {
18424 static const char* GetVRString() { return "SQ"; }
18425 typedef VRToType<VR::SQ>::Type Type;
18426 enum : long long { VRType = VR::SQ };
18427 enum { VMType = VM::VM1 };
18428 static const char* GetVMString() { return "1"; }
18429 };
18430 template <> struct TagToType<0x0062,0x0008> {
18431 static const char* GetVRString() { return "CS"; }
18432 typedef VRToType<VR::CS>::Type Type;
18433 enum : long long { VRType = VR::CS };
18434 enum { VMType = VM::VM1 };
18435 static const char* GetVMString() { return "1"; }
18436 };
18437 template <> struct TagToType<0x0062,0x0009> {
18438 static const char* GetVRString() { return "LO"; }
18439 typedef VRToType<VR::LO>::Type Type;
18440 enum : long long { VRType = VR::LO };
18441 enum { VMType = VM::VM1 };
18442 static const char* GetVMString() { return "1"; }
18443 };
18444 template <> struct TagToType<0x0062,0x000a> {
18445 static const char* GetVRString() { return "SQ"; }
18446 typedef VRToType<VR::SQ>::Type Type;
18447 enum : long long { VRType = VR::SQ };
18448 enum { VMType = VM::VM1 };
18449 static const char* GetVMString() { return "1"; }
18450 };
18451 template <> struct TagToType<0x0062,0x000b> {
18452 static const char* GetVRString() { return "US"; }
18453 typedef VRToType<VR::US>::Type Type;
18454 enum : long long { VRType = VR::US };
18455 enum { VMType = VM::VM1_n };
18456 static const char* GetVMString() { return "1-n"; }
18457 };
18458 template <> struct TagToType<0x0062,0x000c> {
18459 static const char* GetVRString() { return "US"; }
18460 typedef VRToType<VR::US>::Type Type;
18461 enum : long long { VRType = VR::US };
18462 enum { VMType = VM::VM1 };
18463 static const char* GetVMString() { return "1"; }
18464 };
18465 template <> struct TagToType<0x0062,0x000d> {
18466 static const char* GetVRString() { return "US"; }
18467 typedef VRToType<VR::US>::Type Type;
18468 enum : long long { VRType = VR::US };
18469 enum { VMType = VM::VM3 };
18470 static const char* GetVMString() { return "3"; }
18471 };
18472 template <> struct TagToType<0x0062,0x000e> {
18473 static const char* GetVRString() { return "US"; }
18474 typedef VRToType<VR::US>::Type Type;
18475 enum : long long { VRType = VR::US };
18476 enum { VMType = VM::VM1 };
18477 static const char* GetVMString() { return "1"; }
18478 };
18479 template <> struct TagToType<0x0062,0x000f> {
18480 static const char* GetVRString() { return "SQ"; }
18481 typedef VRToType<VR::SQ>::Type Type;
18482 enum : long long { VRType = VR::SQ };
18483 enum { VMType = VM::VM1 };
18484 static const char* GetVMString() { return "1"; }
18485 };
18486 template <> struct TagToType<0x0062,0x0010> {
18487 static const char* GetVRString() { return "CS"; }
18488 typedef VRToType<VR::CS>::Type Type;
18489 enum : long long { VRType = VR::CS };
18490 enum { VMType = VM::VM1 };
18491 static const char* GetVMString() { return "1"; }
18492 };
18493 template <> struct TagToType<0x0062,0x0011> {
18494 static const char* GetVRString() { return "SQ"; }
18495 typedef VRToType<VR::SQ>::Type Type;
18496 enum : long long { VRType = VR::SQ };
18497 enum { VMType = VM::VM1 };
18498 static const char* GetVMString() { return "1"; }
18499 };
18500 template <> struct TagToType<0x0062,0x0012> {
18501 static const char* GetVRString() { return "SQ"; }
18502 typedef VRToType<VR::SQ>::Type Type;
18503 enum : long long { VRType = VR::SQ };
18504 enum { VMType = VM::VM1 };
18505 static const char* GetVMString() { return "1"; }
18506 };
18507 template <> struct TagToType<0x0062,0x0020> {
18508 static const char* GetVRString() { return "UT"; }
18509 typedef VRToType<VR::UT>::Type Type;
18510 enum : long long { VRType = VR::UT };
18511 enum { VMType = VM::VM1 };
18512 static const char* GetVMString() { return "1"; }
18513 };
18514 template <> struct TagToType<0x0062,0x0021> {
18515 static const char* GetVRString() { return "UI"; }
18516 typedef VRToType<VR::UI>::Type Type;
18517 enum : long long { VRType = VR::UI };
18518 enum { VMType = VM::VM1 };
18519 static const char* GetVMString() { return "1"; }
18520 };
18521 template <> struct TagToType<0x0064,0x0002> {
18522 static const char* GetVRString() { return "SQ"; }
18523 typedef VRToType<VR::SQ>::Type Type;
18524 enum : long long { VRType = VR::SQ };
18525 enum { VMType = VM::VM1 };
18526 static const char* GetVMString() { return "1"; }
18527 };
18528 template <> struct TagToType<0x0064,0x0003> {
18529 static const char* GetVRString() { return "UI"; }
18530 typedef VRToType<VR::UI>::Type Type;
18531 enum : long long { VRType = VR::UI };
18532 enum { VMType = VM::VM1 };
18533 static const char* GetVMString() { return "1"; }
18534 };
18535 template <> struct TagToType<0x0064,0x0005> {
18536 static const char* GetVRString() { return "SQ"; }
18537 typedef VRToType<VR::SQ>::Type Type;
18538 enum : long long { VRType = VR::SQ };
18539 enum { VMType = VM::VM1 };
18540 static const char* GetVMString() { return "1"; }
18541 };
18542 template <> struct TagToType<0x0064,0x0007> {
18543 static const char* GetVRString() { return "UL"; }
18544 typedef VRToType<VR::UL>::Type Type;
18545 enum : long long { VRType = VR::UL };
18546 enum { VMType = VM::VM3 };
18547 static const char* GetVMString() { return "3"; }
18548 };
18549 template <> struct TagToType<0x0064,0x0008> {
18550 static const char* GetVRString() { return "FD"; }
18551 typedef VRToType<VR::FD>::Type Type;
18552 enum : long long { VRType = VR::FD };
18553 enum { VMType = VM::VM3 };
18554 static const char* GetVMString() { return "3"; }
18555 };
18556 template <> struct TagToType<0x0064,0x0009> {
18557 static const char* GetVRString() { return "OF"; }
18558 typedef VRToType<VR::OF>::Type Type;
18559 enum : long long { VRType = VR::OF };
18560 enum { VMType = VM::VM1 };
18561 static const char* GetVMString() { return "1"; }
18562 };
18563 template <> struct TagToType<0x0064,0x000f> {
18564 static const char* GetVRString() { return "SQ"; }
18565 typedef VRToType<VR::SQ>::Type Type;
18566 enum : long long { VRType = VR::SQ };
18567 enum { VMType = VM::VM1 };
18568 static const char* GetVMString() { return "1"; }
18569 };
18570 template <> struct TagToType<0x0064,0x0010> {
18571 static const char* GetVRString() { return "SQ"; }
18572 typedef VRToType<VR::SQ>::Type Type;
18573 enum : long long { VRType = VR::SQ };
18574 enum { VMType = VM::VM1 };
18575 static const char* GetVMString() { return "1"; }
18576 };
18577 template <> struct TagToType<0x0066,0x0001> {
18578 static const char* GetVRString() { return "UL"; }
18579 typedef VRToType<VR::UL>::Type Type;
18580 enum : long long { VRType = VR::UL };
18581 enum { VMType = VM::VM1 };
18582 static const char* GetVMString() { return "1"; }
18583 };
18584 template <> struct TagToType<0x0066,0x0002> {
18585 static const char* GetVRString() { return "SQ"; }
18586 typedef VRToType<VR::SQ>::Type Type;
18587 enum : long long { VRType = VR::SQ };
18588 enum { VMType = VM::VM1 };
18589 static const char* GetVMString() { return "1"; }
18590 };
18591 template <> struct TagToType<0x0066,0x0003> {
18592 static const char* GetVRString() { return "UL"; }
18593 typedef VRToType<VR::UL>::Type Type;
18594 enum : long long { VRType = VR::UL };
18595 enum { VMType = VM::VM1 };
18596 static const char* GetVMString() { return "1"; }
18597 };
18598 template <> struct TagToType<0x0066,0x0004> {
18599 static const char* GetVRString() { return "LT"; }
18600 typedef VRToType<VR::LT>::Type Type;
18601 enum : long long { VRType = VR::LT };
18602 enum { VMType = VM::VM1 };
18603 static const char* GetVMString() { return "1"; }
18604 };
18605 template <> struct TagToType<0x0066,0x0009> {
18606 static const char* GetVRString() { return "CS"; }
18607 typedef VRToType<VR::CS>::Type Type;
18608 enum : long long { VRType = VR::CS };
18609 enum { VMType = VM::VM1 };
18610 static const char* GetVMString() { return "1"; }
18611 };
18612 template <> struct TagToType<0x0066,0x000a> {
18613 static const char* GetVRString() { return "FL"; }
18614 typedef VRToType<VR::FL>::Type Type;
18615 enum : long long { VRType = VR::FL };
18616 enum { VMType = VM::VM1 };
18617 static const char* GetVMString() { return "1"; }
18618 };
18619 template <> struct TagToType<0x0066,0x000b> {
18620 static const char* GetVRString() { return "LO"; }
18621 typedef VRToType<VR::LO>::Type Type;
18622 enum : long long { VRType = VR::LO };
18623 enum { VMType = VM::VM1 };
18624 static const char* GetVMString() { return "1"; }
18625 };
18626 template <> struct TagToType<0x0066,0x000c> {
18627 static const char* GetVRString() { return "FL"; }
18628 typedef VRToType<VR::FL>::Type Type;
18629 enum : long long { VRType = VR::FL };
18630 enum { VMType = VM::VM1 };
18631 static const char* GetVMString() { return "1"; }
18632 };
18633 template <> struct TagToType<0x0066,0x000d> {
18634 static const char* GetVRString() { return "CS"; }
18635 typedef VRToType<VR::CS>::Type Type;
18636 enum : long long { VRType = VR::CS };
18637 enum { VMType = VM::VM1 };
18638 static const char* GetVMString() { return "1"; }
18639 };
18640 template <> struct TagToType<0x0066,0x000e> {
18641 static const char* GetVRString() { return "CS"; }
18642 typedef VRToType<VR::CS>::Type Type;
18643 enum : long long { VRType = VR::CS };
18644 enum { VMType = VM::VM1 };
18645 static const char* GetVMString() { return "1"; }
18646 };
18647 template <> struct TagToType<0x0066,0x0010> {
18648 static const char* GetVRString() { return "CS"; }
18649 typedef VRToType<VR::CS>::Type Type;
18650 enum : long long { VRType = VR::CS };
18651 enum { VMType = VM::VM1 };
18652 static const char* GetVMString() { return "1"; }
18653 };
18654 template <> struct TagToType<0x0066,0x0011> {
18655 static const char* GetVRString() { return "SQ"; }
18656 typedef VRToType<VR::SQ>::Type Type;
18657 enum : long long { VRType = VR::SQ };
18658 enum { VMType = VM::VM1 };
18659 static const char* GetVMString() { return "1"; }
18660 };
18661 template <> struct TagToType<0x0066,0x0012> {
18662 static const char* GetVRString() { return "SQ"; }
18663 typedef VRToType<VR::SQ>::Type Type;
18664 enum : long long { VRType = VR::SQ };
18665 enum { VMType = VM::VM1 };
18666 static const char* GetVMString() { return "1"; }
18667 };
18668 template <> struct TagToType<0x0066,0x0013> {
18669 static const char* GetVRString() { return "SQ"; }
18670 typedef VRToType<VR::SQ>::Type Type;
18671 enum : long long { VRType = VR::SQ };
18672 enum { VMType = VM::VM1 };
18673 static const char* GetVMString() { return "1"; }
18674 };
18675 template <> struct TagToType<0x0066,0x0015> {
18676 static const char* GetVRString() { return "UL"; }
18677 typedef VRToType<VR::UL>::Type Type;
18678 enum : long long { VRType = VR::UL };
18679 enum { VMType = VM::VM1 };
18680 static const char* GetVMString() { return "1"; }
18681 };
18682 template <> struct TagToType<0x0066,0x0016> {
18683 static const char* GetVRString() { return "OF"; }
18684 typedef VRToType<VR::OF>::Type Type;
18685 enum : long long { VRType = VR::OF };
18686 enum { VMType = VM::VM1 };
18687 static const char* GetVMString() { return "1"; }
18688 };
18689 template <> struct TagToType<0x0066,0x0017> {
18690 static const char* GetVRString() { return "FL"; }
18691 typedef VRToType<VR::FL>::Type Type;
18692 enum : long long { VRType = VR::FL };
18693 enum { VMType = VM::VM3 };
18694 static const char* GetVMString() { return "3"; }
18695 };
18696 template <> struct TagToType<0x0066,0x0018> {
18697 static const char* GetVRString() { return "FL"; }
18698 typedef VRToType<VR::FL>::Type Type;
18699 enum : long long { VRType = VR::FL };
18700 enum { VMType = VM::VM1 };
18701 static const char* GetVMString() { return "1"; }
18702 };
18703 template <> struct TagToType<0x0066,0x0019> {
18704 static const char* GetVRString() { return "FL"; }
18705 typedef VRToType<VR::FL>::Type Type;
18706 enum : long long { VRType = VR::FL };
18707 enum { VMType = VM::VM1 };
18708 static const char* GetVMString() { return "1"; }
18709 };
18710 template <> struct TagToType<0x0066,0x001a> {
18711 static const char* GetVRString() { return "FL"; }
18712 typedef VRToType<VR::FL>::Type Type;
18713 enum : long long { VRType = VR::FL };
18714 enum { VMType = VM::VM6 };
18715 static const char* GetVMString() { return "6"; }
18716 };
18717 template <> struct TagToType<0x0066,0x001b> {
18718 static const char* GetVRString() { return "FL"; }
18719 typedef VRToType<VR::FL>::Type Type;
18720 enum : long long { VRType = VR::FL };
18721 enum { VMType = VM::VM3 };
18722 static const char* GetVMString() { return "3"; }
18723 };
18724 template <> struct TagToType<0x0066,0x001c> {
18725 static const char* GetVRString() { return "FL"; }
18726 typedef VRToType<VR::FL>::Type Type;
18727 enum : long long { VRType = VR::FL };
18728 enum { VMType = VM::VM3 };
18729 static const char* GetVMString() { return "3"; }
18730 };
18731 template <> struct TagToType<0x0066,0x001e> {
18732 static const char* GetVRString() { return "UL"; }
18733 typedef VRToType<VR::UL>::Type Type;
18734 enum : long long { VRType = VR::UL };
18735 enum { VMType = VM::VM1 };
18736 static const char* GetVMString() { return "1"; }
18737 };
18738 template <> struct TagToType<0x0066,0x001f> {
18739 static const char* GetVRString() { return "US"; }
18740 typedef VRToType<VR::US>::Type Type;
18741 enum : long long { VRType = VR::US };
18742 enum { VMType = VM::VM1 };
18743 static const char* GetVMString() { return "1"; }
18744 };
18745 template <> struct TagToType<0x0066,0x0020> {
18746 static const char* GetVRString() { return "FL"; }
18747 typedef VRToType<VR::FL>::Type Type;
18748 enum : long long { VRType = VR::FL };
18749 enum { VMType = VM::VM1_n };
18750 static const char* GetVMString() { return "1-n"; }
18751 };
18752 template <> struct TagToType<0x0066,0x0021> {
18753 static const char* GetVRString() { return "OF"; }
18754 typedef VRToType<VR::OF>::Type Type;
18755 enum : long long { VRType = VR::OF };
18756 enum { VMType = VM::VM1 };
18757 static const char* GetVMString() { return "1"; }
18758 };
18759 template <> struct TagToType<0x0066,0x0023> {
18760 static const char* GetVRString() { return "OW"; }
18761 typedef VRToType<VR::OW>::Type Type;
18762 enum : long long { VRType = VR::OW };
18763 enum { VMType = VM::VM1 };
18764 static const char* GetVMString() { return "1"; }
18765 };
18766 template <> struct TagToType<0x0066,0x0024> {
18767 static const char* GetVRString() { return "OW"; }
18768 typedef VRToType<VR::OW>::Type Type;
18769 enum : long long { VRType = VR::OW };
18770 enum { VMType = VM::VM1 };
18771 static const char* GetVMString() { return "1"; }
18772 };
18773 template <> struct TagToType<0x0066,0x0025> {
18774 static const char* GetVRString() { return "OW"; }
18775 typedef VRToType<VR::OW>::Type Type;
18776 enum : long long { VRType = VR::OW };
18777 enum { VMType = VM::VM1 };
18778 static const char* GetVMString() { return "1"; }
18779 };
18780 template <> struct TagToType<0x0066,0x0026> {
18781 static const char* GetVRString() { return "SQ"; }
18782 typedef VRToType<VR::SQ>::Type Type;
18783 enum : long long { VRType = VR::SQ };
18784 enum { VMType = VM::VM1 };
18785 static const char* GetVMString() { return "1"; }
18786 };
18787 template <> struct TagToType<0x0066,0x0027> {
18788 static const char* GetVRString() { return "SQ"; }
18789 typedef VRToType<VR::SQ>::Type Type;
18790 enum : long long { VRType = VR::SQ };
18791 enum { VMType = VM::VM1 };
18792 static const char* GetVMString() { return "1"; }
18793 };
18794 template <> struct TagToType<0x0066,0x0028> {
18795 static const char* GetVRString() { return "SQ"; }
18796 typedef VRToType<VR::SQ>::Type Type;
18797 enum : long long { VRType = VR::SQ };
18798 enum { VMType = VM::VM1 };
18799 static const char* GetVMString() { return "1"; }
18800 };
18801 template <> struct TagToType<0x0066,0x0029> {
18802 static const char* GetVRString() { return "OW"; }
18803 typedef VRToType<VR::OW>::Type Type;
18804 enum : long long { VRType = VR::OW };
18805 enum { VMType = VM::VM1 };
18806 static const char* GetVMString() { return "1"; }
18807 };
18808 template <> struct TagToType<0x0066,0x002a> {
18809 static const char* GetVRString() { return "UL"; }
18810 typedef VRToType<VR::UL>::Type Type;
18811 enum : long long { VRType = VR::UL };
18812 enum { VMType = VM::VM1 };
18813 static const char* GetVMString() { return "1"; }
18814 };
18815 template <> struct TagToType<0x0066,0x002b> {
18816 static const char* GetVRString() { return "SQ"; }
18817 typedef VRToType<VR::SQ>::Type Type;
18818 enum : long long { VRType = VR::SQ };
18819 enum { VMType = VM::VM1 };
18820 static const char* GetVMString() { return "1"; }
18821 };
18822 template <> struct TagToType<0x0066,0x002c> {
18823 static const char* GetVRString() { return "UL"; }
18824 typedef VRToType<VR::UL>::Type Type;
18825 enum : long long { VRType = VR::UL };
18826 enum { VMType = VM::VM1 };
18827 static const char* GetVMString() { return "1"; }
18828 };
18829 template <> struct TagToType<0x0066,0x002d> {
18830 static const char* GetVRString() { return "SQ"; }
18831 typedef VRToType<VR::SQ>::Type Type;
18832 enum : long long { VRType = VR::SQ };
18833 enum { VMType = VM::VM1 };
18834 static const char* GetVMString() { return "1"; }
18835 };
18836 template <> struct TagToType<0x0066,0x002e> {
18837 static const char* GetVRString() { return "SQ"; }
18838 typedef VRToType<VR::SQ>::Type Type;
18839 enum : long long { VRType = VR::SQ };
18840 enum { VMType = VM::VM1 };
18841 static const char* GetVMString() { return "1"; }
18842 };
18843 template <> struct TagToType<0x0066,0x002f> {
18844 static const char* GetVRString() { return "SQ"; }
18845 typedef VRToType<VR::SQ>::Type Type;
18846 enum : long long { VRType = VR::SQ };
18847 enum { VMType = VM::VM1 };
18848 static const char* GetVMString() { return "1"; }
18849 };
18850 template <> struct TagToType<0x0066,0x0030> {
18851 static const char* GetVRString() { return "SQ"; }
18852 typedef VRToType<VR::SQ>::Type Type;
18853 enum : long long { VRType = VR::SQ };
18854 enum { VMType = VM::VM1 };
18855 static const char* GetVMString() { return "1"; }
18856 };
18857 template <> struct TagToType<0x0066,0x0031> {
18858 static const char* GetVRString() { return "LO"; }
18859 typedef VRToType<VR::LO>::Type Type;
18860 enum : long long { VRType = VR::LO };
18861 enum { VMType = VM::VM1 };
18862 static const char* GetVMString() { return "1"; }
18863 };
18864 template <> struct TagToType<0x0066,0x0032> {
18865 static const char* GetVRString() { return "LT"; }
18866 typedef VRToType<VR::LT>::Type Type;
18867 enum : long long { VRType = VR::LT };
18868 enum { VMType = VM::VM1 };
18869 static const char* GetVMString() { return "1"; }
18870 };
18871 template <> struct TagToType<0x0066,0x0034> {
18872 static const char* GetVRString() { return "SQ"; }
18873 typedef VRToType<VR::SQ>::Type Type;
18874 enum : long long { VRType = VR::SQ };
18875 enum { VMType = VM::VM1 };
18876 static const char* GetVMString() { return "1"; }
18877 };
18878 template <> struct TagToType<0x0066,0x0035> {
18879 static const char* GetVRString() { return "SQ"; }
18880 typedef VRToType<VR::SQ>::Type Type;
18881 enum : long long { VRType = VR::SQ };
18882 enum { VMType = VM::VM1 };
18883 static const char* GetVMString() { return "1"; }
18884 };
18885 template <> struct TagToType<0x0066,0x0036> {
18886 static const char* GetVRString() { return "LO"; }
18887 typedef VRToType<VR::LO>::Type Type;
18888 enum : long long { VRType = VR::LO };
18889 enum { VMType = VM::VM1 };
18890 static const char* GetVMString() { return "1"; }
18891 };
18892 template <> struct TagToType<0x0066,0x0037> {
18893 static const char* GetVRString() { return "FL"; }
18894 typedef VRToType<VR::FL>::Type Type;
18895 enum : long long { VRType = VR::FL };
18896 enum { VMType = VM::VM1 };
18897 static const char* GetVMString() { return "1"; }
18898 };
18899 template <> struct TagToType<0x0066,0x0038> {
18900 static const char* GetVRString() { return "FL"; }
18901 typedef VRToType<VR::FL>::Type Type;
18902 enum : long long { VRType = VR::FL };
18903 enum { VMType = VM::VM1 };
18904 static const char* GetVMString() { return "1"; }
18905 };
18906 template <> struct TagToType<0x0066,0x0040> {
18907 static const char* GetVRString() { return "OL"; }
18908 typedef VRToType<VR::OL>::Type Type;
18909 enum : long long { VRType = VR::OL };
18910 enum { VMType = VM::VM1 };
18911 static const char* GetVMString() { return "1"; }
18912 };
18913 template <> struct TagToType<0x0066,0x0041> {
18914 static const char* GetVRString() { return "OL"; }
18915 typedef VRToType<VR::OL>::Type Type;
18916 enum : long long { VRType = VR::OL };
18917 enum { VMType = VM::VM1 };
18918 static const char* GetVMString() { return "1"; }
18919 };
18920 template <> struct TagToType<0x0066,0x0042> {
18921 static const char* GetVRString() { return "OL"; }
18922 typedef VRToType<VR::OL>::Type Type;
18923 enum : long long { VRType = VR::OL };
18924 enum { VMType = VM::VM1 };
18925 static const char* GetVMString() { return "1"; }
18926 };
18927 template <> struct TagToType<0x0066,0x0043> {
18928 static const char* GetVRString() { return "OL"; }
18929 typedef VRToType<VR::OL>::Type Type;
18930 enum : long long { VRType = VR::OL };
18931 enum { VMType = VM::VM1 };
18932 static const char* GetVMString() { return "1"; }
18933 };
18934 template <> struct TagToType<0x0066,0x0101> {
18935 static const char* GetVRString() { return "SQ"; }
18936 typedef VRToType<VR::SQ>::Type Type;
18937 enum : long long { VRType = VR::SQ };
18938 enum { VMType = VM::VM1 };
18939 static const char* GetVMString() { return "1"; }
18940 };
18941 template <> struct TagToType<0x0066,0x0102> {
18942 static const char* GetVRString() { return "SQ"; }
18943 typedef VRToType<VR::SQ>::Type Type;
18944 enum : long long { VRType = VR::SQ };
18945 enum { VMType = VM::VM1 };
18946 static const char* GetVMString() { return "1"; }
18947 };
18948 template <> struct TagToType<0x0066,0x0103> {
18949 static const char* GetVRString() { return "OW"; }
18950 typedef VRToType<VR::OW>::Type Type;
18951 enum : long long { VRType = VR::OW };
18952 enum { VMType = VM::VM1 };
18953 static const char* GetVMString() { return "1"; }
18954 };
18955 template <> struct TagToType<0x0066,0x0104> {
18956 static const char* GetVRString() { return "SQ"; }
18957 typedef VRToType<VR::SQ>::Type Type;
18958 enum : long long { VRType = VR::SQ };
18959 enum { VMType = VM::VM1 };
18960 static const char* GetVMString() { return "1"; }
18961 };
18962 template <> struct TagToType<0x0066,0x0105> {
18963 static const char* GetVRString() { return "UL"; }
18964 typedef VRToType<VR::UL>::Type Type;
18965 enum : long long { VRType = VR::UL };
18966 enum { VMType = VM::VM1 };
18967 static const char* GetVMString() { return "1"; }
18968 };
18969 template <> struct TagToType<0x0066,0x0106> {
18970 static const char* GetVRString() { return "LO"; }
18971 typedef VRToType<VR::LO>::Type Type;
18972 enum : long long { VRType = VR::LO };
18973 enum { VMType = VM::VM1 };
18974 static const char* GetVMString() { return "1"; }
18975 };
18976 template <> struct TagToType<0x0066,0x0107> {
18977 static const char* GetVRString() { return "UT"; }
18978 typedef VRToType<VR::UT>::Type Type;
18979 enum : long long { VRType = VR::UT };
18980 enum { VMType = VM::VM1 };
18981 static const char* GetVMString() { return "1"; }
18982 };
18983 template <> struct TagToType<0x0066,0x0108> {
18984 static const char* GetVRString() { return "SQ"; }
18985 typedef VRToType<VR::SQ>::Type Type;
18986 enum : long long { VRType = VR::SQ };
18987 enum { VMType = VM::VM1 };
18988 static const char* GetVMString() { return "1"; }
18989 };
18990 template <> struct TagToType<0x0066,0x0121> {
18991 static const char* GetVRString() { return "SQ"; }
18992 typedef VRToType<VR::SQ>::Type Type;
18993 enum : long long { VRType = VR::SQ };
18994 enum { VMType = VM::VM1 };
18995 static const char* GetVMString() { return "1"; }
18996 };
18997 template <> struct TagToType<0x0066,0x0124> {
18998 static const char* GetVRString() { return "SQ"; }
18999 typedef VRToType<VR::SQ>::Type Type;
19000 enum : long long { VRType = VR::SQ };
19001 enum { VMType = VM::VM1 };
19002 static const char* GetVMString() { return "1"; }
19003 };
19004 template <> struct TagToType<0x0066,0x0125> {
19005 static const char* GetVRString() { return "OF"; }
19006 typedef VRToType<VR::OF>::Type Type;
19007 enum : long long { VRType = VR::OF };
19008 enum { VMType = VM::VM1 };
19009 static const char* GetVMString() { return "1"; }
19010 };
19011 template <> struct TagToType<0x0066,0x0129> {
19012 static const char* GetVRString() { return "OL"; }
19013 typedef VRToType<VR::OL>::Type Type;
19014 enum : long long { VRType = VR::OL };
19015 enum { VMType = VM::VM1 };
19016 static const char* GetVMString() { return "1"; }
19017 };
19018 template <> struct TagToType<0x0066,0x0130> {
19019 static const char* GetVRString() { return "SQ"; }
19020 typedef VRToType<VR::SQ>::Type Type;
19021 enum : long long { VRType = VR::SQ };
19022 enum { VMType = VM::VM1 };
19023 static const char* GetVMString() { return "1"; }
19024 };
19025 template <> struct TagToType<0x0066,0x0132> {
19026 static const char* GetVRString() { return "SQ"; }
19027 typedef VRToType<VR::SQ>::Type Type;
19028 enum : long long { VRType = VR::SQ };
19029 enum { VMType = VM::VM1 };
19030 static const char* GetVMString() { return "1"; }
19031 };
19032 template <> struct TagToType<0x0066,0x0133> {
19033 static const char* GetVRString() { return "SQ"; }
19034 typedef VRToType<VR::SQ>::Type Type;
19035 enum : long long { VRType = VR::SQ };
19036 enum { VMType = VM::VM1 };
19037 static const char* GetVMString() { return "1"; }
19038 };
19039 template <> struct TagToType<0x0066,0x0134> {
19040 static const char* GetVRString() { return "SQ"; }
19041 typedef VRToType<VR::SQ>::Type Type;
19042 enum : long long { VRType = VR::SQ };
19043 enum { VMType = VM::VM1 };
19044 static const char* GetVMString() { return "1"; }
19045 };
19046 template <> struct TagToType<0x0068,0x6210> {
19047 static const char* GetVRString() { return "LO"; }
19048 typedef VRToType<VR::LO>::Type Type;
19049 enum : long long { VRType = VR::LO };
19050 enum { VMType = VM::VM1 };
19051 static const char* GetVMString() { return "1"; }
19052 };
19053 template <> struct TagToType<0x0068,0x6221> {
19054 static const char* GetVRString() { return "LO"; }
19055 typedef VRToType<VR::LO>::Type Type;
19056 enum : long long { VRType = VR::LO };
19057 enum { VMType = VM::VM1 };
19058 static const char* GetVMString() { return "1"; }
19059 };
19060 template <> struct TagToType<0x0068,0x6222> {
19061 static const char* GetVRString() { return "SQ"; }
19062 typedef VRToType<VR::SQ>::Type Type;
19063 enum : long long { VRType = VR::SQ };
19064 enum { VMType = VM::VM1 };
19065 static const char* GetVMString() { return "1"; }
19066 };
19067 template <> struct TagToType<0x0068,0x6223> {
19068 static const char* GetVRString() { return "CS"; }
19069 typedef VRToType<VR::CS>::Type Type;
19070 enum : long long { VRType = VR::CS };
19071 enum { VMType = VM::VM1 };
19072 static const char* GetVMString() { return "1"; }
19073 };
19074 template <> struct TagToType<0x0068,0x6224> {
19075 static const char* GetVRString() { return "SQ"; }
19076 typedef VRToType<VR::SQ>::Type Type;
19077 enum : long long { VRType = VR::SQ };
19078 enum { VMType = VM::VM1 };
19079 static const char* GetVMString() { return "1"; }
19080 };
19081 template <> struct TagToType<0x0068,0x6225> {
19082 static const char* GetVRString() { return "SQ"; }
19083 typedef VRToType<VR::SQ>::Type Type;
19084 enum : long long { VRType = VR::SQ };
19085 enum { VMType = VM::VM1 };
19086 static const char* GetVMString() { return "1"; }
19087 };
19088 template <> struct TagToType<0x0068,0x6226> {
19089 static const char* GetVRString() { return "DT"; }
19090 typedef VRToType<VR::DT>::Type Type;
19091 enum : long long { VRType = VR::DT };
19092 enum { VMType = VM::VM1 };
19093 static const char* GetVMString() { return "1"; }
19094 };
19095 template <> struct TagToType<0x0068,0x6230> {
19096 static const char* GetVRString() { return "SQ"; }
19097 typedef VRToType<VR::SQ>::Type Type;
19098 enum : long long { VRType = VR::SQ };
19099 enum { VMType = VM::VM1 };
19100 static const char* GetVMString() { return "1"; }
19101 };
19102 template <> struct TagToType<0x0068,0x6260> {
19103 static const char* GetVRString() { return "SQ"; }
19104 typedef VRToType<VR::SQ>::Type Type;
19105 enum : long long { VRType = VR::SQ };
19106 enum { VMType = VM::VM1 };
19107 static const char* GetVMString() { return "1"; }
19108 };
19109 template <> struct TagToType<0x0068,0x6265> {
19110 static const char* GetVRString() { return "SQ"; }
19111 typedef VRToType<VR::SQ>::Type Type;
19112 enum : long long { VRType = VR::SQ };
19113 enum { VMType = VM::VM1 };
19114 static const char* GetVMString() { return "1"; }
19115 };
19116 template <> struct TagToType<0x0068,0x6270> {
19117 static const char* GetVRString() { return "DT"; }
19118 typedef VRToType<VR::DT>::Type Type;
19119 enum : long long { VRType = VR::DT };
19120 enum { VMType = VM::VM1 };
19121 static const char* GetVMString() { return "1"; }
19122 };
19123 template <> struct TagToType<0x0068,0x6280> {
19124 static const char* GetVRString() { return "ST"; }
19125 typedef VRToType<VR::ST>::Type Type;
19126 enum : long long { VRType = VR::ST };
19127 enum { VMType = VM::VM1 };
19128 static const char* GetVMString() { return "1"; }
19129 };
19130 template <> struct TagToType<0x0068,0x62a0> {
19131 static const char* GetVRString() { return "SQ"; }
19132 typedef VRToType<VR::SQ>::Type Type;
19133 enum : long long { VRType = VR::SQ };
19134 enum { VMType = VM::VM1 };
19135 static const char* GetVMString() { return "1"; }
19136 };
19137 template <> struct TagToType<0x0068,0x62a5> {
19138 static const char* GetVRString() { return "FD"; }
19139 typedef VRToType<VR::FD>::Type Type;
19140 enum : long long { VRType = VR::FD };
19141 enum { VMType = VM::VM1 };
19142 static const char* GetVMString() { return "1"; }
19143 };
19144 template <> struct TagToType<0x0068,0x62c0> {
19145 static const char* GetVRString() { return "SQ"; }
19146 typedef VRToType<VR::SQ>::Type Type;
19147 enum : long long { VRType = VR::SQ };
19148 enum { VMType = VM::VM1 };
19149 static const char* GetVMString() { return "1"; }
19150 };
19151 template <> struct TagToType<0x0068,0x62d0> {
19152 static const char* GetVRString() { return "US"; }
19153 typedef VRToType<VR::US>::Type Type;
19154 enum : long long { VRType = VR::US };
19155 enum { VMType = VM::VM1 };
19156 static const char* GetVMString() { return "1"; }
19157 };
19158 template <> struct TagToType<0x0068,0x62d5> {
19159 static const char* GetVRString() { return "LO"; }
19160 typedef VRToType<VR::LO>::Type Type;
19161 enum : long long { VRType = VR::LO };
19162 enum { VMType = VM::VM1 };
19163 static const char* GetVMString() { return "1"; }
19164 };
19165 template <> struct TagToType<0x0068,0x62e0> {
19166 static const char* GetVRString() { return "SQ"; }
19167 typedef VRToType<VR::SQ>::Type Type;
19168 enum : long long { VRType = VR::SQ };
19169 enum { VMType = VM::VM1 };
19170 static const char* GetVMString() { return "1"; }
19171 };
19172 template <> struct TagToType<0x0068,0x62f0> {
19173 static const char* GetVRString() { return "FD"; }
19174 typedef VRToType<VR::FD>::Type Type;
19175 enum : long long { VRType = VR::FD };
19176 enum { VMType = VM::VM9 };
19177 static const char* GetVMString() { return "9"; }
19178 };
19179 template <> struct TagToType<0x0068,0x62f2> {
19180 static const char* GetVRString() { return "FD"; }
19181 typedef VRToType<VR::FD>::Type Type;
19182 enum : long long { VRType = VR::FD };
19183 enum { VMType = VM::VM1 };
19184 static const char* GetVMString() { return "1"; }
19185 };
19186 template <> struct TagToType<0x0068,0x6300> {
19187 static const char* GetVRString() { return "OB"; }
19188 typedef VRToType<VR::OB>::Type Type;
19189 enum : long long { VRType = VR::OB };
19190 enum { VMType = VM::VM1 };
19191 static const char* GetVMString() { return "1"; }
19192 };
19193 template <> struct TagToType<0x0068,0x6310> {
19194 static const char* GetVRString() { return "US"; }
19195 typedef VRToType<VR::US>::Type Type;
19196 enum : long long { VRType = VR::US };
19197 enum { VMType = VM::VM1 };
19198 static const char* GetVMString() { return "1"; }
19199 };
19200 template <> struct TagToType<0x0068,0x6320> {
19201 static const char* GetVRString() { return "SQ"; }
19202 typedef VRToType<VR::SQ>::Type Type;
19203 enum : long long { VRType = VR::SQ };
19204 enum { VMType = VM::VM1 };
19205 static const char* GetVMString() { return "1"; }
19206 };
19207 template <> struct TagToType<0x0068,0x6330> {
19208 static const char* GetVRString() { return "US"; }
19209 typedef VRToType<VR::US>::Type Type;
19210 enum : long long { VRType = VR::US };
19211 enum { VMType = VM::VM1 };
19212 static const char* GetVMString() { return "1"; }
19213 };
19214 template <> struct TagToType<0x0068,0x6340> {
19215 static const char* GetVRString() { return "LO"; }
19216 typedef VRToType<VR::LO>::Type Type;
19217 enum : long long { VRType = VR::LO };
19218 enum { VMType = VM::VM1 };
19219 static const char* GetVMString() { return "1"; }
19220 };
19221 template <> struct TagToType<0x0068,0x6345> {
19222 static const char* GetVRString() { return "ST"; }
19223 typedef VRToType<VR::ST>::Type Type;
19224 enum : long long { VRType = VR::ST };
19225 enum { VMType = VM::VM1 };
19226 static const char* GetVMString() { return "1"; }
19227 };
19228 template <> struct TagToType<0x0068,0x6346> {
19229 static const char* GetVRString() { return "FD"; }
19230 typedef VRToType<VR::FD>::Type Type;
19231 enum : long long { VRType = VR::FD };
19232 enum { VMType = VM::VM2 };
19233 static const char* GetVMString() { return "2"; }
19234 };
19235 template <> struct TagToType<0x0068,0x6347> {
19236 static const char* GetVRString() { return "FD"; }
19237 typedef VRToType<VR::FD>::Type Type;
19238 enum : long long { VRType = VR::FD };
19239 enum { VMType = VM::VM4 };
19240 static const char* GetVMString() { return "4"; }
19241 };
19242 template <> struct TagToType<0x0068,0x6350> {
19243 static const char* GetVRString() { return "US"; }
19244 typedef VRToType<VR::US>::Type Type;
19245 enum : long long { VRType = VR::US };
19246 enum { VMType = VM::VM1_n };
19247 static const char* GetVMString() { return "1-n"; }
19248 };
19249 template <> struct TagToType<0x0068,0x6360> {
19250 static const char* GetVRString() { return "SQ"; }
19251 typedef VRToType<VR::SQ>::Type Type;
19252 enum : long long { VRType = VR::SQ };
19253 enum { VMType = VM::VM1 };
19254 static const char* GetVMString() { return "1"; }
19255 };
19256 template <> struct TagToType<0x0068,0x6380> {
19257 static const char* GetVRString() { return "LO"; }
19258 typedef VRToType<VR::LO>::Type Type;
19259 enum : long long { VRType = VR::LO };
19260 enum { VMType = VM::VM1 };
19261 static const char* GetVMString() { return "1"; }
19262 };
19263 template <> struct TagToType<0x0068,0x6390> {
19264 static const char* GetVRString() { return "FD"; }
19265 typedef VRToType<VR::FD>::Type Type;
19266 enum : long long { VRType = VR::FD };
19267 enum { VMType = VM::VM1 };
19268 static const char* GetVMString() { return "1"; }
19269 };
19270 template <> struct TagToType<0x0068,0x63a0> {
19271 static const char* GetVRString() { return "SQ"; }
19272 typedef VRToType<VR::SQ>::Type Type;
19273 enum : long long { VRType = VR::SQ };
19274 enum { VMType = VM::VM1 };
19275 static const char* GetVMString() { return "1"; }
19276 };
19277 template <> struct TagToType<0x0068,0x63a4> {
19278 static const char* GetVRString() { return "SQ"; }
19279 typedef VRToType<VR::SQ>::Type Type;
19280 enum : long long { VRType = VR::SQ };
19281 enum { VMType = VM::VM1 };
19282 static const char* GetVMString() { return "1"; }
19283 };
19284 template <> struct TagToType<0x0068,0x63a8> {
19285 static const char* GetVRString() { return "SQ"; }
19286 typedef VRToType<VR::SQ>::Type Type;
19287 enum : long long { VRType = VR::SQ };
19288 enum { VMType = VM::VM1 };
19289 static const char* GetVMString() { return "1"; }
19290 };
19291 template <> struct TagToType<0x0068,0x63ac> {
19292 static const char* GetVRString() { return "SQ"; }
19293 typedef VRToType<VR::SQ>::Type Type;
19294 enum : long long { VRType = VR::SQ };
19295 enum { VMType = VM::VM1 };
19296 static const char* GetVMString() { return "1"; }
19297 };
19298 template <> struct TagToType<0x0068,0x63b0> {
19299 static const char* GetVRString() { return "SQ"; }
19300 typedef VRToType<VR::SQ>::Type Type;
19301 enum : long long { VRType = VR::SQ };
19302 enum { VMType = VM::VM1 };
19303 static const char* GetVMString() { return "1"; }
19304 };
19305 template <> struct TagToType<0x0068,0x63c0> {
19306 static const char* GetVRString() { return "US"; }
19307 typedef VRToType<VR::US>::Type Type;
19308 enum : long long { VRType = VR::US };
19309 enum { VMType = VM::VM1 };
19310 static const char* GetVMString() { return "1"; }
19311 };
19312 template <> struct TagToType<0x0068,0x63d0> {
19313 static const char* GetVRString() { return "LO"; }
19314 typedef VRToType<VR::LO>::Type Type;
19315 enum : long long { VRType = VR::LO };
19316 enum { VMType = VM::VM1 };
19317 static const char* GetVMString() { return "1"; }
19318 };
19319 template <> struct TagToType<0x0068,0x63e0> {
19320 static const char* GetVRString() { return "SQ"; }
19321 typedef VRToType<VR::SQ>::Type Type;
19322 enum : long long { VRType = VR::SQ };
19323 enum { VMType = VM::VM1 };
19324 static const char* GetVMString() { return "1"; }
19325 };
19326 template <> struct TagToType<0x0068,0x63f0> {
19327 static const char* GetVRString() { return "US"; }
19328 typedef VRToType<VR::US>::Type Type;
19329 enum : long long { VRType = VR::US };
19330 enum { VMType = VM::VM1 };
19331 static const char* GetVMString() { return "1"; }
19332 };
19333 template <> struct TagToType<0x0068,0x6400> {
19334 static const char* GetVRString() { return "SQ"; }
19335 typedef VRToType<VR::SQ>::Type Type;
19336 enum : long long { VRType = VR::SQ };
19337 enum { VMType = VM::VM1 };
19338 static const char* GetVMString() { return "1"; }
19339 };
19340 template <> struct TagToType<0x0068,0x6410> {
19341 static const char* GetVRString() { return "US"; }
19342 typedef VRToType<VR::US>::Type Type;
19343 enum : long long { VRType = VR::US };
19344 enum { VMType = VM::VM1 };
19345 static const char* GetVMString() { return "1"; }
19346 };
19347 template <> struct TagToType<0x0068,0x6420> {
19348 static const char* GetVRString() { return "CS"; }
19349 typedef VRToType<VR::CS>::Type Type;
19350 enum : long long { VRType = VR::CS };
19351 enum { VMType = VM::VM1 };
19352 static const char* GetVMString() { return "1"; }
19353 };
19354 template <> struct TagToType<0x0068,0x6430> {
19355 static const char* GetVRString() { return "SQ"; }
19356 typedef VRToType<VR::SQ>::Type Type;
19357 enum : long long { VRType = VR::SQ };
19358 enum { VMType = VM::VM1 };
19359 static const char* GetVMString() { return "1"; }
19360 };
19361 template <> struct TagToType<0x0068,0x6440> {
19362 static const char* GetVRString() { return "US"; }
19363 typedef VRToType<VR::US>::Type Type;
19364 enum : long long { VRType = VR::US };
19365 enum { VMType = VM::VM1 };
19366 static const char* GetVMString() { return "1"; }
19367 };
19368 template <> struct TagToType<0x0068,0x6450> {
19369 static const char* GetVRString() { return "FD"; }
19370 typedef VRToType<VR::FD>::Type Type;
19371 enum : long long { VRType = VR::FD };
19372 enum { VMType = VM::VM2 };
19373 static const char* GetVMString() { return "2"; }
19374 };
19375 template <> struct TagToType<0x0068,0x6460> {
19376 static const char* GetVRString() { return "FD"; }
19377 typedef VRToType<VR::FD>::Type Type;
19378 enum : long long { VRType = VR::FD };
19379 enum { VMType = VM::VM4 };
19380 static const char* GetVMString() { return "4"; }
19381 };
19382 template <> struct TagToType<0x0068,0x6470> {
19383 static const char* GetVRString() { return "SQ"; }
19384 typedef VRToType<VR::SQ>::Type Type;
19385 enum : long long { VRType = VR::SQ };
19386 enum { VMType = VM::VM1 };
19387 static const char* GetVMString() { return "1"; }
19388 };
19389 template <> struct TagToType<0x0068,0x6490> {
19390 static const char* GetVRString() { return "FD"; }
19391 typedef VRToType<VR::FD>::Type Type;
19392 enum : long long { VRType = VR::FD };
19393 enum { VMType = VM::VM3 };
19394 static const char* GetVMString() { return "3"; }
19395 };
19396 template <> struct TagToType<0x0068,0x64a0> {
19397 static const char* GetVRString() { return "FD"; }
19398 typedef VRToType<VR::FD>::Type Type;
19399 enum : long long { VRType = VR::FD };
19400 enum { VMType = VM::VM2 };
19401 static const char* GetVMString() { return "2"; }
19402 };
19403 template <> struct TagToType<0x0068,0x64c0> {
19404 static const char* GetVRString() { return "FD"; }
19405 typedef VRToType<VR::FD>::Type Type;
19406 enum : long long { VRType = VR::FD };
19407 enum { VMType = VM::VM3 };
19408 static const char* GetVMString() { return "3"; }
19409 };
19410 template <> struct TagToType<0x0068,0x64d0> {
19411 static const char* GetVRString() { return "FD"; }
19412 typedef VRToType<VR::FD>::Type Type;
19413 enum : long long { VRType = VR::FD };
19414 enum { VMType = VM::VM9 };
19415 static const char* GetVMString() { return "9"; }
19416 };
19417 template <> struct TagToType<0x0068,0x64f0> {
19418 static const char* GetVRString() { return "FD"; }
19419 typedef VRToType<VR::FD>::Type Type;
19420 enum : long long { VRType = VR::FD };
19421 enum { VMType = VM::VM3 };
19422 static const char* GetVMString() { return "3"; }
19423 };
19424 template <> struct TagToType<0x0068,0x6500> {
19425 static const char* GetVRString() { return "SQ"; }
19426 typedef VRToType<VR::SQ>::Type Type;
19427 enum : long long { VRType = VR::SQ };
19428 enum { VMType = VM::VM1 };
19429 static const char* GetVMString() { return "1"; }
19430 };
19431 template <> struct TagToType<0x0068,0x6510> {
19432 static const char* GetVRString() { return "SQ"; }
19433 typedef VRToType<VR::SQ>::Type Type;
19434 enum : long long { VRType = VR::SQ };
19435 enum { VMType = VM::VM1 };
19436 static const char* GetVMString() { return "1"; }
19437 };
19438 template <> struct TagToType<0x0068,0x6520> {
19439 static const char* GetVRString() { return "SQ"; }
19440 typedef VRToType<VR::SQ>::Type Type;
19441 enum : long long { VRType = VR::SQ };
19442 enum { VMType = VM::VM1 };
19443 static const char* GetVMString() { return "1"; }
19444 };
19445 template <> struct TagToType<0x0068,0x6530> {
19446 static const char* GetVRString() { return "US"; }
19447 typedef VRToType<VR::US>::Type Type;
19448 enum : long long { VRType = VR::US };
19449 enum { VMType = VM::VM1 };
19450 static const char* GetVMString() { return "1"; }
19451 };
19452 template <> struct TagToType<0x0068,0x6540> {
19453 static const char* GetVRString() { return "LO"; }
19454 typedef VRToType<VR::LO>::Type Type;
19455 enum : long long { VRType = VR::LO };
19456 enum { VMType = VM::VM1 };
19457 static const char* GetVMString() { return "1"; }
19458 };
19459 template <> struct TagToType<0x0068,0x6545> {
19460 static const char* GetVRString() { return "SQ"; }
19461 typedef VRToType<VR::SQ>::Type Type;
19462 enum : long long { VRType = VR::SQ };
19463 enum { VMType = VM::VM1 };
19464 static const char* GetVMString() { return "1"; }
19465 };
19466 template <> struct TagToType<0x0068,0x6550> {
19467 static const char* GetVRString() { return "SQ"; }
19468 typedef VRToType<VR::SQ>::Type Type;
19469 enum : long long { VRType = VR::SQ };
19470 enum { VMType = VM::VM1 };
19471 static const char* GetVMString() { return "1"; }
19472 };
19473 template <> struct TagToType<0x0068,0x6560> {
19474 static const char* GetVRString() { return "FD"; }
19475 typedef VRToType<VR::FD>::Type Type;
19476 enum : long long { VRType = VR::FD };
19477 enum { VMType = VM::VM2 };
19478 static const char* GetVMString() { return "2"; }
19479 };
19480 template <> struct TagToType<0x0068,0x6590> {
19481 static const char* GetVRString() { return "FD"; }
19482 typedef VRToType<VR::FD>::Type Type;
19483 enum : long long { VRType = VR::FD };
19484 enum { VMType = VM::VM3 };
19485 static const char* GetVMString() { return "3"; }
19486 };
19487 template <> struct TagToType<0x0068,0x65a0> {
19488 static const char* GetVRString() { return "SQ"; }
19489 typedef VRToType<VR::SQ>::Type Type;
19490 enum : long long { VRType = VR::SQ };
19491 enum { VMType = VM::VM1 };
19492 static const char* GetVMString() { return "1"; }
19493 };
19494 template <> struct TagToType<0x0068,0x65b0> {
19495 static const char* GetVRString() { return "FD"; }
19496 typedef VRToType<VR::FD>::Type Type;
19497 enum : long long { VRType = VR::FD };
19498 enum { VMType = VM::VM4 };
19499 static const char* GetVMString() { return "4"; }
19500 };
19501 template <> struct TagToType<0x0068,0x65d0> {
19502 static const char* GetVRString() { return "FD"; }
19503 typedef VRToType<VR::FD>::Type Type;
19504 enum : long long { VRType = VR::FD };
19505 enum { VMType = VM::VM6 };
19506 static const char* GetVMString() { return "6"; }
19507 };
19508 template <> struct TagToType<0x0068,0x65e0> {
19509 static const char* GetVRString() { return "SQ"; }
19510 typedef VRToType<VR::SQ>::Type Type;
19511 enum : long long { VRType = VR::SQ };
19512 enum { VMType = VM::VM1 };
19513 static const char* GetVMString() { return "1"; }
19514 };
19515 template <> struct TagToType<0x0068,0x65f0> {
19516 static const char* GetVRString() { return "FD"; }
19517 typedef VRToType<VR::FD>::Type Type;
19518 enum : long long { VRType = VR::FD };
19519 enum { VMType = VM::VM4 };
19520 static const char* GetVMString() { return "4"; }
19521 };
19522 template <> struct TagToType<0x0068,0x6610> {
19523 static const char* GetVRString() { return "FD"; }
19524 typedef VRToType<VR::FD>::Type Type;
19525 enum : long long { VRType = VR::FD };
19526 enum { VMType = VM::VM3 };
19527 static const char* GetVMString() { return "3"; }
19528 };
19529 template <> struct TagToType<0x0068,0x6620> {
19530 static const char* GetVRString() { return "FD"; }
19531 typedef VRToType<VR::FD>::Type Type;
19532 enum : long long { VRType = VR::FD };
19533 enum { VMType = VM::VM3 };
19534 static const char* GetVMString() { return "3"; }
19535 };
19536 template <> struct TagToType<0x0070,0x0001> {
19537 static const char* GetVRString() { return "SQ"; }
19538 typedef VRToType<VR::SQ>::Type Type;
19539 enum : long long { VRType = VR::SQ };
19540 enum { VMType = VM::VM1 };
19541 static const char* GetVMString() { return "1"; }
19542 };
19543 template <> struct TagToType<0x0070,0x0002> {
19544 static const char* GetVRString() { return "CS"; }
19545 typedef VRToType<VR::CS>::Type Type;
19546 enum : long long { VRType = VR::CS };
19547 enum { VMType = VM::VM1 };
19548 static const char* GetVMString() { return "1"; }
19549 };
19550 template <> struct TagToType<0x0070,0x0003> {
19551 static const char* GetVRString() { return "CS"; }
19552 typedef VRToType<VR::CS>::Type Type;
19553 enum : long long { VRType = VR::CS };
19554 enum { VMType = VM::VM1 };
19555 static const char* GetVMString() { return "1"; }
19556 };
19557 template <> struct TagToType<0x0070,0x0004> {
19558 static const char* GetVRString() { return "CS"; }
19559 typedef VRToType<VR::CS>::Type Type;
19560 enum : long long { VRType = VR::CS };
19561 enum { VMType = VM::VM1 };
19562 static const char* GetVMString() { return "1"; }
19563 };
19564 template <> struct TagToType<0x0070,0x0005> {
19565 static const char* GetVRString() { return "CS"; }
19566 typedef VRToType<VR::CS>::Type Type;
19567 enum : long long { VRType = VR::CS };
19568 enum { VMType = VM::VM1 };
19569 static const char* GetVMString() { return "1"; }
19570 };
19571 template <> struct TagToType<0x0070,0x0006> {
19572 static const char* GetVRString() { return "ST"; }
19573 typedef VRToType<VR::ST>::Type Type;
19574 enum : long long { VRType = VR::ST };
19575 enum { VMType = VM::VM1 };
19576 static const char* GetVMString() { return "1"; }
19577 };
19578 template <> struct TagToType<0x0070,0x0008> {
19579 static const char* GetVRString() { return "SQ"; }
19580 typedef VRToType<VR::SQ>::Type Type;
19581 enum : long long { VRType = VR::SQ };
19582 enum { VMType = VM::VM1 };
19583 static const char* GetVMString() { return "1"; }
19584 };
19585 template <> struct TagToType<0x0070,0x0009> {
19586 static const char* GetVRString() { return "SQ"; }
19587 typedef VRToType<VR::SQ>::Type Type;
19588 enum : long long { VRType = VR::SQ };
19589 enum { VMType = VM::VM1 };
19590 static const char* GetVMString() { return "1"; }
19591 };
19592 template <> struct TagToType<0x0070,0x0010> {
19593 static const char* GetVRString() { return "FL"; }
19594 typedef VRToType<VR::FL>::Type Type;
19595 enum : long long { VRType = VR::FL };
19596 enum { VMType = VM::VM2 };
19597 static const char* GetVMString() { return "2"; }
19598 };
19599 template <> struct TagToType<0x0070,0x0011> {
19600 static const char* GetVRString() { return "FL"; }
19601 typedef VRToType<VR::FL>::Type Type;
19602 enum : long long { VRType = VR::FL };
19603 enum { VMType = VM::VM2 };
19604 static const char* GetVMString() { return "2"; }
19605 };
19606 template <> struct TagToType<0x0070,0x0012> {
19607 static const char* GetVRString() { return "CS"; }
19608 typedef VRToType<VR::CS>::Type Type;
19609 enum : long long { VRType = VR::CS };
19610 enum { VMType = VM::VM1 };
19611 static const char* GetVMString() { return "1"; }
19612 };
19613 template <> struct TagToType<0x0070,0x0014> {
19614 static const char* GetVRString() { return "FL"; }
19615 typedef VRToType<VR::FL>::Type Type;
19616 enum : long long { VRType = VR::FL };
19617 enum { VMType = VM::VM2 };
19618 static const char* GetVMString() { return "2"; }
19619 };
19620 template <> struct TagToType<0x0070,0x0015> {
19621 static const char* GetVRString() { return "CS"; }
19622 typedef VRToType<VR::CS>::Type Type;
19623 enum : long long { VRType = VR::CS };
19624 enum { VMType = VM::VM1 };
19625 static const char* GetVMString() { return "1"; }
19626 };
19627 template <> struct TagToType<0x0070,0x0020> {
19628 static const char* GetVRString() { return "US"; }
19629 typedef VRToType<VR::US>::Type Type;
19630 enum : long long { VRType = VR::US };
19631 enum { VMType = VM::VM1 };
19632 static const char* GetVMString() { return "1"; }
19633 };
19634 template <> struct TagToType<0x0070,0x0021> {
19635 static const char* GetVRString() { return "US"; }
19636 typedef VRToType<VR::US>::Type Type;
19637 enum : long long { VRType = VR::US };
19638 enum { VMType = VM::VM1 };
19639 static const char* GetVMString() { return "1"; }
19640 };
19641 template <> struct TagToType<0x0070,0x0022> {
19642 static const char* GetVRString() { return "FL"; }
19643 typedef VRToType<VR::FL>::Type Type;
19644 enum : long long { VRType = VR::FL };
19645 enum { VMType = VM::VM2_n };
19646 static const char* GetVMString() { return "2-n"; }
19647 };
19648 template <> struct TagToType<0x0070,0x0023> {
19649 static const char* GetVRString() { return "CS"; }
19650 typedef VRToType<VR::CS>::Type Type;
19651 enum : long long { VRType = VR::CS };
19652 enum { VMType = VM::VM1 };
19653 static const char* GetVMString() { return "1"; }
19654 };
19655 template <> struct TagToType<0x0070,0x0024> {
19656 static const char* GetVRString() { return "CS"; }
19657 typedef VRToType<VR::CS>::Type Type;
19658 enum : long long { VRType = VR::CS };
19659 enum { VMType = VM::VM1 };
19660 static const char* GetVMString() { return "1"; }
19661 };
19662 template <> struct TagToType<0x0070,0x0040> {
19663 static const char* GetVRString() { return "IS"; }
19664 typedef VRToType<VR::IS>::Type Type;
19665 enum : long long { VRType = VR::IS };
19666 enum { VMType = VM::VM1 };
19667 static const char* GetVMString() { return "1"; }
19668 };
19669 template <> struct TagToType<0x0070,0x0041> {
19670 static const char* GetVRString() { return "CS"; }
19671 typedef VRToType<VR::CS>::Type Type;
19672 enum : long long { VRType = VR::CS };
19673 enum { VMType = VM::VM1 };
19674 static const char* GetVMString() { return "1"; }
19675 };
19676 template <> struct TagToType<0x0070,0x0042> {
19677 static const char* GetVRString() { return "US"; }
19678 typedef VRToType<VR::US>::Type Type;
19679 enum : long long { VRType = VR::US };
19680 enum { VMType = VM::VM1 };
19681 static const char* GetVMString() { return "1"; }
19682 };
19683 template <> struct TagToType<0x0070,0x0050> {
19684 static const char* GetVRString() { return "US"; }
19685 typedef VRToType<VR::US>::Type Type;
19686 enum : long long { VRType = VR::US };
19687 enum { VMType = VM::VM2 };
19688 static const char* GetVMString() { return "2"; }
19689 };
19690 template <> struct TagToType<0x0070,0x0051> {
19691 static const char* GetVRString() { return "US"; }
19692 typedef VRToType<VR::US>::Type Type;
19693 enum : long long { VRType = VR::US };
19694 enum { VMType = VM::VM2 };
19695 static const char* GetVMString() { return "2"; }
19696 };
19697 template <> struct TagToType<0x0070,0x0052> {
19698 static const char* GetVRString() { return "SL"; }
19699 typedef VRToType<VR::SL>::Type Type;
19700 enum : long long { VRType = VR::SL };
19701 enum { VMType = VM::VM2 };
19702 static const char* GetVMString() { return "2"; }
19703 };
19704 template <> struct TagToType<0x0070,0x0053> {
19705 static const char* GetVRString() { return "SL"; }
19706 typedef VRToType<VR::SL>::Type Type;
19707 enum : long long { VRType = VR::SL };
19708 enum { VMType = VM::VM2 };
19709 static const char* GetVMString() { return "2"; }
19710 };
19711 template <> struct TagToType<0x0070,0x005a> {
19712 static const char* GetVRString() { return "SQ"; }
19713 typedef VRToType<VR::SQ>::Type Type;
19714 enum : long long { VRType = VR::SQ };
19715 enum { VMType = VM::VM1 };
19716 static const char* GetVMString() { return "1"; }
19717 };
19718 template <> struct TagToType<0x0070,0x0060> {
19719 static const char* GetVRString() { return "SQ"; }
19720 typedef VRToType<VR::SQ>::Type Type;
19721 enum : long long { VRType = VR::SQ };
19722 enum { VMType = VM::VM1 };
19723 static const char* GetVMString() { return "1"; }
19724 };
19725 template <> struct TagToType<0x0070,0x0062> {
19726 static const char* GetVRString() { return "IS"; }
19727 typedef VRToType<VR::IS>::Type Type;
19728 enum : long long { VRType = VR::IS };
19729 enum { VMType = VM::VM1 };
19730 static const char* GetVMString() { return "1"; }
19731 };
19732 template <> struct TagToType<0x0070,0x0066> {
19733 static const char* GetVRString() { return "US"; }
19734 typedef VRToType<VR::US>::Type Type;
19735 enum : long long { VRType = VR::US };
19736 enum { VMType = VM::VM1 };
19737 static const char* GetVMString() { return "1"; }
19738 };
19739 template <> struct TagToType<0x0070,0x0067> {
19740 static const char* GetVRString() { return "US"; }
19741 typedef VRToType<VR::US>::Type Type;
19742 enum : long long { VRType = VR::US };
19743 enum { VMType = VM::VM3 };
19744 static const char* GetVMString() { return "3"; }
19745 };
19746 template <> struct TagToType<0x0070,0x0068> {
19747 static const char* GetVRString() { return "LO"; }
19748 typedef VRToType<VR::LO>::Type Type;
19749 enum : long long { VRType = VR::LO };
19750 enum { VMType = VM::VM1 };
19751 static const char* GetVMString() { return "1"; }
19752 };
19753 template <> struct TagToType<0x0070,0x0080> {
19754 static const char* GetVRString() { return "CS"; }
19755 typedef VRToType<VR::CS>::Type Type;
19756 enum : long long { VRType = VR::CS };
19757 enum { VMType = VM::VM1 };
19758 static const char* GetVMString() { return "1"; }
19759 };
19760 template <> struct TagToType<0x0070,0x0081> {
19761 static const char* GetVRString() { return "LO"; }
19762 typedef VRToType<VR::LO>::Type Type;
19763 enum : long long { VRType = VR::LO };
19764 enum { VMType = VM::VM1 };
19765 static const char* GetVMString() { return "1"; }
19766 };
19767 template <> struct TagToType<0x0070,0x0082> {
19768 static const char* GetVRString() { return "DA"; }
19769 typedef VRToType<VR::DA>::Type Type;
19770 enum : long long { VRType = VR::DA };
19771 enum { VMType = VM::VM1 };
19772 static const char* GetVMString() { return "1"; }
19773 };
19774 template <> struct TagToType<0x0070,0x0083> {
19775 static const char* GetVRString() { return "TM"; }
19776 typedef VRToType<VR::TM>::Type Type;
19777 enum : long long { VRType = VR::TM };
19778 enum { VMType = VM::VM1 };
19779 static const char* GetVMString() { return "1"; }
19780 };
19781 template <> struct TagToType<0x0070,0x0084> {
19782 static const char* GetVRString() { return "PN"; }
19783 typedef VRToType<VR::PN>::Type Type;
19784 enum : long long { VRType = VR::PN };
19785 enum { VMType = VM::VM1 };
19786 static const char* GetVMString() { return "1"; }
19787 };
19788 template <> struct TagToType<0x0070,0x0086> {
19789 static const char* GetVRString() { return "SQ"; }
19790 typedef VRToType<VR::SQ>::Type Type;
19791 enum : long long { VRType = VR::SQ };
19792 enum { VMType = VM::VM1 };
19793 static const char* GetVMString() { return "1"; }
19794 };
19795 template <> struct TagToType<0x0070,0x0087> {
19796 static const char* GetVRString() { return "SQ"; }
19797 typedef VRToType<VR::SQ>::Type Type;
19798 enum : long long { VRType = VR::SQ };
19799 enum { VMType = VM::VM1 };
19800 static const char* GetVMString() { return "1"; }
19801 };
19802 template <> struct TagToType<0x0070,0x0100> {
19803 static const char* GetVRString() { return "CS"; }
19804 typedef VRToType<VR::CS>::Type Type;
19805 enum : long long { VRType = VR::CS };
19806 enum { VMType = VM::VM1 };
19807 static const char* GetVMString() { return "1"; }
19808 };
19809 template <> struct TagToType<0x0070,0x0101> {
19810 static const char* GetVRString() { return "DS"; }
19811 typedef VRToType<VR::DS>::Type Type;
19812 enum : long long { VRType = VR::DS };
19813 enum { VMType = VM::VM2 };
19814 static const char* GetVMString() { return "2"; }
19815 };
19816 template <> struct TagToType<0x0070,0x0102> {
19817 static const char* GetVRString() { return "IS"; }
19818 typedef VRToType<VR::IS>::Type Type;
19819 enum : long long { VRType = VR::IS };
19820 enum { VMType = VM::VM2 };
19821 static const char* GetVMString() { return "2"; }
19822 };
19823 template <> struct TagToType<0x0070,0x0103> {
19824 static const char* GetVRString() { return "FL"; }
19825 typedef VRToType<VR::FL>::Type Type;
19826 enum : long long { VRType = VR::FL };
19827 enum { VMType = VM::VM1 };
19828 static const char* GetVMString() { return "1"; }
19829 };
19830 template <> struct TagToType<0x0070,0x0207> {
19831 static const char* GetVRString() { return "LO"; }
19832 typedef VRToType<VR::LO>::Type Type;
19833 enum : long long { VRType = VR::LO };
19834 enum { VMType = VM::VM1 };
19835 static const char* GetVMString() { return "1"; }
19836 };
19837 template <> struct TagToType<0x0070,0x0208> {
19838 static const char* GetVRString() { return "ST"; }
19839 typedef VRToType<VR::ST>::Type Type;
19840 enum : long long { VRType = VR::ST };
19841 enum { VMType = VM::VM1 };
19842 static const char* GetVMString() { return "1"; }
19843 };
19844 template <> struct TagToType<0x0070,0x0209> {
19845 static const char* GetVRString() { return "SQ"; }
19846 typedef VRToType<VR::SQ>::Type Type;
19847 enum : long long { VRType = VR::SQ };
19848 enum { VMType = VM::VM1 };
19849 static const char* GetVMString() { return "1"; }
19850 };
19851 template <> struct TagToType<0x0070,0x0226> {
19852 static const char* GetVRString() { return "UL"; }
19853 typedef VRToType<VR::UL>::Type Type;
19854 enum : long long { VRType = VR::UL };
19855 enum { VMType = VM::VM1 };
19856 static const char* GetVMString() { return "1"; }
19857 };
19858 template <> struct TagToType<0x0070,0x0227> {
19859 static const char* GetVRString() { return "LO"; }
19860 typedef VRToType<VR::LO>::Type Type;
19861 enum : long long { VRType = VR::LO };
19862 enum { VMType = VM::VM1 };
19863 static const char* GetVMString() { return "1"; }
19864 };
19865 template <> struct TagToType<0x0070,0x0228> {
19866 static const char* GetVRString() { return "CS"; }
19867 typedef VRToType<VR::CS>::Type Type;
19868 enum : long long { VRType = VR::CS };
19869 enum { VMType = VM::VM1 };
19870 static const char* GetVMString() { return "1"; }
19871 };
19872 template <> struct TagToType<0x0070,0x0229> {
19873 static const char* GetVRString() { return "LO"; }
19874 typedef VRToType<VR::LO>::Type Type;
19875 enum : long long { VRType = VR::LO };
19876 enum { VMType = VM::VM1 };
19877 static const char* GetVMString() { return "1"; }
19878 };
19879 template <> struct TagToType<0x0070,0x0230> {
19880 static const char* GetVRString() { return "FD"; }
19881 typedef VRToType<VR::FD>::Type Type;
19882 enum : long long { VRType = VR::FD };
19883 enum { VMType = VM::VM1 };
19884 static const char* GetVMString() { return "1"; }
19885 };
19886 template <> struct TagToType<0x0070,0x0231> {
19887 static const char* GetVRString() { return "SQ"; }
19888 typedef VRToType<VR::SQ>::Type Type;
19889 enum : long long { VRType = VR::SQ };
19890 enum { VMType = VM::VM1 };
19891 static const char* GetVMString() { return "1"; }
19892 };
19893 template <> struct TagToType<0x0070,0x0232> {
19894 static const char* GetVRString() { return "SQ"; }
19895 typedef VRToType<VR::SQ>::Type Type;
19896 enum : long long { VRType = VR::SQ };
19897 enum { VMType = VM::VM1 };
19898 static const char* GetVMString() { return "1"; }
19899 };
19900 template <> struct TagToType<0x0070,0x0233> {
19901 static const char* GetVRString() { return "SQ"; }
19902 typedef VRToType<VR::SQ>::Type Type;
19903 enum : long long { VRType = VR::SQ };
19904 enum { VMType = VM::VM1 };
19905 static const char* GetVMString() { return "1"; }
19906 };
19907 template <> struct TagToType<0x0070,0x0234> {
19908 static const char* GetVRString() { return "SQ"; }
19909 typedef VRToType<VR::SQ>::Type Type;
19910 enum : long long { VRType = VR::SQ };
19911 enum { VMType = VM::VM1 };
19912 static const char* GetVMString() { return "1"; }
19913 };
19914 template <> struct TagToType<0x0070,0x0241> {
19915 static const char* GetVRString() { return "US"; }
19916 typedef VRToType<VR::US>::Type Type;
19917 enum : long long { VRType = VR::US };
19918 enum { VMType = VM::VM3 };
19919 static const char* GetVMString() { return "3"; }
19920 };
19921 template <> struct TagToType<0x0070,0x0242> {
19922 static const char* GetVRString() { return "CS"; }
19923 typedef VRToType<VR::CS>::Type Type;
19924 enum : long long { VRType = VR::CS };
19925 enum { VMType = VM::VM1 };
19926 static const char* GetVMString() { return "1"; }
19927 };
19928 template <> struct TagToType<0x0070,0x0243> {
19929 static const char* GetVRString() { return "CS"; }
19930 typedef VRToType<VR::CS>::Type Type;
19931 enum : long long { VRType = VR::CS };
19932 enum { VMType = VM::VM1 };
19933 static const char* GetVMString() { return "1"; }
19934 };
19935 template <> struct TagToType<0x0070,0x0244> {
19936 static const char* GetVRString() { return "CS"; }
19937 typedef VRToType<VR::CS>::Type Type;
19938 enum : long long { VRType = VR::CS };
19939 enum { VMType = VM::VM1 };
19940 static const char* GetVMString() { return "1"; }
19941 };
19942 template <> struct TagToType<0x0070,0x0245> {
19943 static const char* GetVRString() { return "FL"; }
19944 typedef VRToType<VR::FL>::Type Type;
19945 enum : long long { VRType = VR::FL };
19946 enum { VMType = VM::VM1 };
19947 static const char* GetVMString() { return "1"; }
19948 };
19949 template <> struct TagToType<0x0070,0x0246> {
19950 static const char* GetVRString() { return "FL"; }
19951 typedef VRToType<VR::FL>::Type Type;
19952 enum : long long { VRType = VR::FL };
19953 enum { VMType = VM::VM1 };
19954 static const char* GetVMString() { return "1"; }
19955 };
19956 template <> struct TagToType<0x0070,0x0247> {
19957 static const char* GetVRString() { return "US"; }
19958 typedef VRToType<VR::US>::Type Type;
19959 enum : long long { VRType = VR::US };
19960 enum { VMType = VM::VM3 };
19961 static const char* GetVMString() { return "3"; }
19962 };
19963 template <> struct TagToType<0x0070,0x0248> {
19964 static const char* GetVRString() { return "CS"; }
19965 typedef VRToType<VR::CS>::Type Type;
19966 enum : long long { VRType = VR::CS };
19967 enum { VMType = VM::VM1 };
19968 static const char* GetVMString() { return "1"; }
19969 };
19970 template <> struct TagToType<0x0070,0x0249> {
19971 static const char* GetVRString() { return "CS"; }
19972 typedef VRToType<VR::CS>::Type Type;
19973 enum : long long { VRType = VR::CS };
19974 enum { VMType = VM::VM1 };
19975 static const char* GetVMString() { return "1"; }
19976 };
19977 template <> struct TagToType<0x0070,0x0250> {
19978 static const char* GetVRString() { return "CS"; }
19979 typedef VRToType<VR::CS>::Type Type;
19980 enum : long long { VRType = VR::CS };
19981 enum { VMType = VM::VM1 };
19982 static const char* GetVMString() { return "1"; }
19983 };
19984 template <> struct TagToType<0x0070,0x0251> {
19985 static const char* GetVRString() { return "US"; }
19986 typedef VRToType<VR::US>::Type Type;
19987 enum : long long { VRType = VR::US };
19988 enum { VMType = VM::VM3 };
19989 static const char* GetVMString() { return "3"; }
19990 };
19991 template <> struct TagToType<0x0070,0x0252> {
19992 static const char* GetVRString() { return "US"; }
19993 typedef VRToType<VR::US>::Type Type;
19994 enum : long long { VRType = VR::US };
19995 enum { VMType = VM::VM3 };
19996 static const char* GetVMString() { return "3"; }
19997 };
19998 template <> struct TagToType<0x0070,0x0253> {
19999 static const char* GetVRString() { return "FL"; }
20000 typedef VRToType<VR::FL>::Type Type;
20001 enum : long long { VRType = VR::FL };
20002 enum { VMType = VM::VM1 };
20003 static const char* GetVMString() { return "1"; }
20004 };
20005 template <> struct TagToType<0x0070,0x0254> {
20006 static const char* GetVRString() { return "CS"; }
20007 typedef VRToType<VR::CS>::Type Type;
20008 enum : long long { VRType = VR::CS };
20009 enum { VMType = VM::VM1 };
20010 static const char* GetVMString() { return "1"; }
20011 };
20012 template <> struct TagToType<0x0070,0x0255> {
20013 static const char* GetVRString() { return "UL"; }
20014 typedef VRToType<VR::UL>::Type Type;
20015 enum : long long { VRType = VR::UL };
20016 enum { VMType = VM::VM1 };
20017 static const char* GetVMString() { return "1"; }
20018 };
20019 template <> struct TagToType<0x0070,0x0256> {
20020 static const char* GetVRString() { return "OB"; }
20021 typedef VRToType<VR::OB>::Type Type;
20022 enum : long long { VRType = VR::OB };
20023 enum { VMType = VM::VM1 };
20024 static const char* GetVMString() { return "1"; }
20025 };
20026 template <> struct TagToType<0x0070,0x0257> {
20027 static const char* GetVRString() { return "CS"; }
20028 typedef VRToType<VR::CS>::Type Type;
20029 enum : long long { VRType = VR::CS };
20030 enum { VMType = VM::VM1 };
20031 static const char* GetVMString() { return "1"; }
20032 };
20033 template <> struct TagToType<0x0070,0x0258> {
20034 static const char* GetVRString() { return "FL"; }
20035 typedef VRToType<VR::FL>::Type Type;
20036 enum : long long { VRType = VR::FL };
20037 enum { VMType = VM::VM1 };
20038 static const char* GetVMString() { return "1"; }
20039 };
20040 template <> struct TagToType<0x0070,0x0261> {
20041 static const char* GetVRString() { return "FL"; }
20042 typedef VRToType<VR::FL>::Type Type;
20043 enum : long long { VRType = VR::FL };
20044 enum { VMType = VM::VM1 };
20045 static const char* GetVMString() { return "1"; }
20046 };
20047 template <> struct TagToType<0x0070,0x0262> {
20048 static const char* GetVRString() { return "FL"; }
20049 typedef VRToType<VR::FL>::Type Type;
20050 enum : long long { VRType = VR::FL };
20051 enum { VMType = VM::VM1 };
20052 static const char* GetVMString() { return "1"; }
20053 };
20054 template <> struct TagToType<0x0070,0x0273> {
20055 static const char* GetVRString() { return "FL"; }
20056 typedef VRToType<VR::FL>::Type Type;
20057 enum : long long { VRType = VR::FL };
20058 enum { VMType = VM::VM2 };
20059 static const char* GetVMString() { return "2"; }
20060 };
20061 template <> struct TagToType<0x0070,0x0274> {
20062 static const char* GetVRString() { return "CS"; }
20063 typedef VRToType<VR::CS>::Type Type;
20064 enum : long long { VRType = VR::CS };
20065 enum { VMType = VM::VM1 };
20066 static const char* GetVMString() { return "1"; }
20067 };
20068 template <> struct TagToType<0x0070,0x0278> {
20069 static const char* GetVRString() { return "CS"; }
20070 typedef VRToType<VR::CS>::Type Type;
20071 enum : long long { VRType = VR::CS };
20072 enum { VMType = VM::VM1 };
20073 static const char* GetVMString() { return "1"; }
20074 };
20075 template <> struct TagToType<0x0070,0x0279> {
20076 static const char* GetVRString() { return "CS"; }
20077 typedef VRToType<VR::CS>::Type Type;
20078 enum : long long { VRType = VR::CS };
20079 enum { VMType = VM::VM1 };
20080 static const char* GetVMString() { return "1"; }
20081 };
20082 template <> struct TagToType<0x0070,0x0282> {
20083 static const char* GetVRString() { return "CS"; }
20084 typedef VRToType<VR::CS>::Type Type;
20085 enum : long long { VRType = VR::CS };
20086 enum { VMType = VM::VM1 };
20087 static const char* GetVMString() { return "1"; }
20088 };
20089 template <> struct TagToType<0x0070,0x0284> {
20090 static const char* GetVRString() { return "FL"; }
20091 typedef VRToType<VR::FL>::Type Type;
20092 enum : long long { VRType = VR::FL };
20093 enum { VMType = VM::VM1 };
20094 static const char* GetVMString() { return "1"; }
20095 };
20096 template <> struct TagToType<0x0070,0x0285> {
20097 static const char* GetVRString() { return "FL"; }
20098 typedef VRToType<VR::FL>::Type Type;
20099 enum : long long { VRType = VR::FL };
20100 enum { VMType = VM::VM1 };
20101 static const char* GetVMString() { return "1"; }
20102 };
20103 template <> struct TagToType<0x0070,0x0287> {
20104 static const char* GetVRString() { return "SQ"; }
20105 typedef VRToType<VR::SQ>::Type Type;
20106 enum : long long { VRType = VR::SQ };
20107 enum { VMType = VM::VM1 };
20108 static const char* GetVMString() { return "1"; }
20109 };
20110 template <> struct TagToType<0x0070,0x0288> {
20111 static const char* GetVRString() { return "FL"; }
20112 typedef VRToType<VR::FL>::Type Type;
20113 enum : long long { VRType = VR::FL };
20114 enum { VMType = VM::VM1 };
20115 static const char* GetVMString() { return "1"; }
20116 };
20117 template <> struct TagToType<0x0070,0x0289> {
20118 static const char* GetVRString() { return "SH"; }
20119 typedef VRToType<VR::SH>::Type Type;
20120 enum : long long { VRType = VR::SH };
20121 enum { VMType = VM::VM1 };
20122 static const char* GetVMString() { return "1"; }
20123 };
20124 template <> struct TagToType<0x0070,0x0294> {
20125 static const char* GetVRString() { return "CS"; }
20126 typedef VRToType<VR::CS>::Type Type;
20127 enum : long long { VRType = VR::CS };
20128 enum { VMType = VM::VM1 };
20129 static const char* GetVMString() { return "1"; }
20130 };
20131 template <> struct TagToType<0x0070,0x0295> {
20132 static const char* GetVRString() { return "UL"; }
20133 typedef VRToType<VR::UL>::Type Type;
20134 enum : long long { VRType = VR::UL };
20135 enum { VMType = VM::VM1 };
20136 static const char* GetVMString() { return "1"; }
20137 };
20138 template <> struct TagToType<0x0070,0x0306> {
20139 static const char* GetVRString() { return "CS"; }
20140 typedef VRToType<VR::CS>::Type Type;
20141 enum : long long { VRType = VR::CS };
20142 enum { VMType = VM::VM1 };
20143 static const char* GetVMString() { return "1"; }
20144 };
20145 template <> struct TagToType<0x0070,0x0308> {
20146 static const char* GetVRString() { return "SQ"; }
20147 typedef VRToType<VR::SQ>::Type Type;
20148 enum : long long { VRType = VR::SQ };
20149 enum { VMType = VM::VM1 };
20150 static const char* GetVMString() { return "1"; }
20151 };
20152 template <> struct TagToType<0x0070,0x0309> {
20153 static const char* GetVRString() { return "SQ"; }
20154 typedef VRToType<VR::SQ>::Type Type;
20155 enum : long long { VRType = VR::SQ };
20156 enum { VMType = VM::VM1 };
20157 static const char* GetVMString() { return "1"; }
20158 };
20159 template <> struct TagToType<0x0070,0x030a> {
20160 static const char* GetVRString() { return "SQ"; }
20161 typedef VRToType<VR::SQ>::Type Type;
20162 enum : long long { VRType = VR::SQ };
20163 enum { VMType = VM::VM1 };
20164 static const char* GetVMString() { return "1"; }
20165 };
20166 template <> struct TagToType<0x0070,0x030b> {
20167 static const char* GetVRString() { return "FD"; }
20168 typedef VRToType<VR::FD>::Type Type;
20169 enum : long long { VRType = VR::FD };
20170 enum { VMType = VM::VM16 };
20171 static const char* GetVMString() { return "16"; }
20172 };
20173 template <> struct TagToType<0x0070,0x030c> {
20174 static const char* GetVRString() { return "CS"; }
20175 typedef VRToType<VR::CS>::Type Type;
20176 enum : long long { VRType = VR::CS };
20177 enum { VMType = VM::VM1 };
20178 static const char* GetVMString() { return "1"; }
20179 };
20180 template <> struct TagToType<0x0070,0x030d> {
20181 static const char* GetVRString() { return "SQ"; }
20182 typedef VRToType<VR::SQ>::Type Type;
20183 enum : long long { VRType = VR::SQ };
20184 enum { VMType = VM::VM1 };
20185 static const char* GetVMString() { return "1"; }
20186 };
20187 template <> struct TagToType<0x0070,0x030f> {
20188 static const char* GetVRString() { return "ST"; }
20189 typedef VRToType<VR::ST>::Type Type;
20190 enum : long long { VRType = VR::ST };
20191 enum { VMType = VM::VM1 };
20192 static const char* GetVMString() { return "1"; }
20193 };
20194 template <> struct TagToType<0x0070,0x0310> {
20195 static const char* GetVRString() { return "SH"; }
20196 typedef VRToType<VR::SH>::Type Type;
20197 enum : long long { VRType = VR::SH };
20198 enum { VMType = VM::VM1 };
20199 static const char* GetVMString() { return "1"; }
20200 };
20201 template <> struct TagToType<0x0070,0x0311> {
20202 static const char* GetVRString() { return "SQ"; }
20203 typedef VRToType<VR::SQ>::Type Type;
20204 enum : long long { VRType = VR::SQ };
20205 enum { VMType = VM::VM1 };
20206 static const char* GetVMString() { return "1"; }
20207 };
20208 template <> struct TagToType<0x0070,0x0312> {
20209 static const char* GetVRString() { return "FD"; }
20210 typedef VRToType<VR::FD>::Type Type;
20211 enum : long long { VRType = VR::FD };
20212 enum { VMType = VM::VM1 };
20213 static const char* GetVMString() { return "1"; }
20214 };
20215 template <> struct TagToType<0x0070,0x0314> {
20216 static const char* GetVRString() { return "SQ"; }
20217 typedef VRToType<VR::SQ>::Type Type;
20218 enum : long long { VRType = VR::SQ };
20219 enum { VMType = VM::VM1 };
20220 static const char* GetVMString() { return "1"; }
20221 };
20222 template <> struct TagToType<0x0070,0x0318> {
20223 static const char* GetVRString() { return "SQ"; }
20224 typedef VRToType<VR::SQ>::Type Type;
20225 enum : long long { VRType = VR::SQ };
20226 enum { VMType = VM::VM1 };
20227 static const char* GetVMString() { return "1"; }
20228 };
20229 template <> struct TagToType<0x0070,0x031a> {
20230 static const char* GetVRString() { return "UI"; }
20231 typedef VRToType<VR::UI>::Type Type;
20232 enum : long long { VRType = VR::UI };
20233 enum { VMType = VM::VM1 };
20234 static const char* GetVMString() { return "1"; }
20235 };
20236 template <> struct TagToType<0x0070,0x031c> {
20237 static const char* GetVRString() { return "SQ"; }
20238 typedef VRToType<VR::SQ>::Type Type;
20239 enum : long long { VRType = VR::SQ };
20240 enum { VMType = VM::VM1 };
20241 static const char* GetVMString() { return "1"; }
20242 };
20243 template <> struct TagToType<0x0070,0x031e> {
20244 static const char* GetVRString() { return "SQ"; }
20245 typedef VRToType<VR::SQ>::Type Type;
20246 enum : long long { VRType = VR::SQ };
20247 enum { VMType = VM::VM1 };
20248 static const char* GetVMString() { return "1"; }
20249 };
20250 template <> struct TagToType<0x0070,0x031f> {
20251 static const char* GetVRString() { return "SQ"; }
20252 typedef VRToType<VR::SQ>::Type Type;
20253 enum : long long { VRType = VR::SQ };
20254 enum { VMType = VM::VM1 };
20255 static const char* GetVMString() { return "1"; }
20256 };
20257 template <> struct TagToType<0x0070,0x0401> {
20258 static const char* GetVRString() { return "US"; }
20259 typedef VRToType<VR::US>::Type Type;
20260 enum : long long { VRType = VR::US };
20261 enum { VMType = VM::VM3 };
20262 static const char* GetVMString() { return "3"; }
20263 };
20264 template <> struct TagToType<0x0070,0x0402> {
20265 static const char* GetVRString() { return "SQ"; }
20266 typedef VRToType<VR::SQ>::Type Type;
20267 enum : long long { VRType = VR::SQ };
20268 enum { VMType = VM::VM1 };
20269 static const char* GetVMString() { return "1"; }
20270 };
20271 template <> struct TagToType<0x0070,0x0403> {
20272 static const char* GetVRString() { return "FL"; }
20273 typedef VRToType<VR::FL>::Type Type;
20274 enum : long long { VRType = VR::FL };
20275 enum { VMType = VM::VM1 };
20276 static const char* GetVMString() { return "1"; }
20277 };
20278 template <> struct TagToType<0x0070,0x0404> {
20279 static const char* GetVRString() { return "SQ"; }
20280 typedef VRToType<VR::SQ>::Type Type;
20281 enum : long long { VRType = VR::SQ };
20282 enum { VMType = VM::VM1 };
20283 static const char* GetVMString() { return "1"; }
20284 };
20285 template <> struct TagToType<0x0070,0x0405> {
20286 static const char* GetVRString() { return "CS"; }
20287 typedef VRToType<VR::CS>::Type Type;
20288 enum : long long { VRType = VR::CS };
20289 enum { VMType = VM::VM1 };
20290 static const char* GetVMString() { return "1"; }
20291 };
20292 template <> struct TagToType<0x0070,0x1101> {
20293 static const char* GetVRString() { return "UI"; }
20294 typedef VRToType<VR::UI>::Type Type;
20295 enum : long long { VRType = VR::UI };
20296 enum { VMType = VM::VM1 };
20297 static const char* GetVMString() { return "1"; }
20298 };
20299 template <> struct TagToType<0x0070,0x1102> {
20300 static const char* GetVRString() { return "UI"; }
20301 typedef VRToType<VR::UI>::Type Type;
20302 enum : long long { VRType = VR::UI };
20303 enum { VMType = VM::VM1 };
20304 static const char* GetVMString() { return "1"; }
20305 };
20306 template <> struct TagToType<0x0070,0x1103> {
20307 static const char* GetVRString() { return "US"; }
20308 typedef VRToType<VR::US>::Type Type;
20309 enum : long long { VRType = VR::US };
20310 enum { VMType = VM::VM1 };
20311 static const char* GetVMString() { return "1"; }
20312 };
20313 template <> struct TagToType<0x0070,0x1104> {
20314 static const char* GetVRString() { return "SQ"; }
20315 typedef VRToType<VR::SQ>::Type Type;
20316 enum : long long { VRType = VR::SQ };
20317 enum { VMType = VM::VM1 };
20318 static const char* GetVMString() { return "1"; }
20319 };
20320 template <> struct TagToType<0x0070,0x1201> {
20321 static const char* GetVRString() { return "SQ"; }
20322 typedef VRToType<VR::SQ>::Type Type;
20323 enum : long long { VRType = VR::SQ };
20324 enum { VMType = VM::VM1 };
20325 static const char* GetVMString() { return "1"; }
20326 };
20327 template <> struct TagToType<0x0070,0x1202> {
20328 static const char* GetVRString() { return "CS"; }
20329 typedef VRToType<VR::CS>::Type Type;
20330 enum : long long { VRType = VR::CS };
20331 enum { VMType = VM::VM1 };
20332 static const char* GetVMString() { return "1"; }
20333 };
20334 template <> struct TagToType<0x0070,0x1203> {
20335 static const char* GetVRString() { return "US"; }
20336 typedef VRToType<VR::US>::Type Type;
20337 enum : long long { VRType = VR::US };
20338 enum { VMType = VM::VM1 };
20339 static const char* GetVMString() { return "1"; }
20340 };
20341 template <> struct TagToType<0x0070,0x1204> {
20342 static const char* GetVRString() { return "CS"; }
20343 typedef VRToType<VR::CS>::Type Type;
20344 enum : long long { VRType = VR::CS };
20345 enum { VMType = VM::VM1 };
20346 static const char* GetVMString() { return "1"; }
20347 };
20348 template <> struct TagToType<0x0070,0x1205> {
20349 static const char* GetVRString() { return "US"; }
20350 typedef VRToType<VR::US>::Type Type;
20351 enum : long long { VRType = VR::US };
20352 enum { VMType = VM::VM1_n };
20353 static const char* GetVMString() { return "1-n"; }
20354 };
20355 template <> struct TagToType<0x0070,0x1206> {
20356 static const char* GetVRString() { return "CS"; }
20357 typedef VRToType<VR::CS>::Type Type;
20358 enum : long long { VRType = VR::CS };
20359 enum { VMType = VM::VM1 };
20360 static const char* GetVMString() { return "1"; }
20361 };
20362 template <> struct TagToType<0x0070,0x1207> {
20363 static const char* GetVRString() { return "US"; }
20364 typedef VRToType<VR::US>::Type Type;
20365 enum : long long { VRType = VR::US };
20366 enum { VMType = VM::VM1 };
20367 static const char* GetVMString() { return "1"; }
20368 };
20369 template <> struct TagToType<0x0070,0x1208> {
20370 static const char* GetVRString() { return "CS"; }
20371 typedef VRToType<VR::CS>::Type Type;
20372 enum : long long { VRType = VR::CS };
20373 enum { VMType = VM::VM1 };
20374 static const char* GetVMString() { return "1"; }
20375 };
20376 template <> struct TagToType<0x0070,0x1301> {
20377 static const char* GetVRString() { return "SQ"; }
20378 typedef VRToType<VR::SQ>::Type Type;
20379 enum : long long { VRType = VR::SQ };
20380 enum { VMType = VM::VM1 };
20381 static const char* GetVMString() { return "1"; }
20382 };
20383 template <> struct TagToType<0x0070,0x1302> {
20384 static const char* GetVRString() { return "CS"; }
20385 typedef VRToType<VR::CS>::Type Type;
20386 enum : long long { VRType = VR::CS };
20387 enum { VMType = VM::VM1 };
20388 static const char* GetVMString() { return "1"; }
20389 };
20390 template <> struct TagToType<0x0070,0x1303> {
20391 static const char* GetVRString() { return "FD"; }
20392 typedef VRToType<VR::FD>::Type Type;
20393 enum : long long { VRType = VR::FD };
20394 enum { VMType = VM::VM6 };
20395 static const char* GetVMString() { return "6"; }
20396 };
20397 template <> struct TagToType<0x0070,0x1304> {
20398 static const char* GetVRString() { return "SQ"; }
20399 typedef VRToType<VR::SQ>::Type Type;
20400 enum : long long { VRType = VR::SQ };
20401 enum { VMType = VM::VM1 };
20402 static const char* GetVMString() { return "1"; }
20403 };
20404 template <> struct TagToType<0x0070,0x1305> {
20405 static const char* GetVRString() { return "FD"; }
20406 typedef VRToType<VR::FD>::Type Type;
20407 enum : long long { VRType = VR::FD };
20408 enum { VMType = VM::VM4 };
20409 static const char* GetVMString() { return "4"; }
20410 };
20411 template <> struct TagToType<0x0070,0x1306> {
20412 static const char* GetVRString() { return "FD"; }
20413 typedef VRToType<VR::FD>::Type Type;
20414 enum : long long { VRType = VR::FD };
20415 enum { VMType = VM::VM3 };
20416 static const char* GetVMString() { return "3"; }
20417 };
20418 template <> struct TagToType<0x0070,0x1309> {
20419 static const char* GetVRString() { return "US"; }
20420 typedef VRToType<VR::US>::Type Type;
20421 enum : long long { VRType = VR::US };
20422 enum { VMType = VM::VM1 };
20423 static const char* GetVMString() { return "1"; }
20424 };
20425 template <> struct TagToType<0x0070,0x1501> {
20426 static const char* GetVRString() { return "CS"; }
20427 typedef VRToType<VR::CS>::Type Type;
20428 enum : long long { VRType = VR::CS };
20429 enum { VMType = VM::VM1 };
20430 static const char* GetVMString() { return "1"; }
20431 };
20432 template <> struct TagToType<0x0070,0x1502> {
20433 static const char* GetVRString() { return "CS"; }
20434 typedef VRToType<VR::CS>::Type Type;
20435 enum : long long { VRType = VR::CS };
20436 enum { VMType = VM::VM1 };
20437 static const char* GetVMString() { return "1"; }
20438 };
20439 template <> struct TagToType<0x0070,0x1503> {
20440 static const char* GetVRString() { return "FD"; }
20441 typedef VRToType<VR::FD>::Type Type;
20442 enum : long long { VRType = VR::FD };
20443 enum { VMType = VM::VM1 };
20444 static const char* GetVMString() { return "1"; }
20445 };
20446 template <> struct TagToType<0x0070,0x1505> {
20447 static const char* GetVRString() { return "FD"; }
20448 typedef VRToType<VR::FD>::Type Type;
20449 enum : long long { VRType = VR::FD };
20450 enum { VMType = VM::VM3 };
20451 static const char* GetVMString() { return "3"; }
20452 };
20453 template <> struct TagToType<0x0070,0x1507> {
20454 static const char* GetVRString() { return "FD"; }
20455 typedef VRToType<VR::FD>::Type Type;
20456 enum : long long { VRType = VR::FD };
20457 enum { VMType = VM::VM3 };
20458 static const char* GetVMString() { return "3"; }
20459 };
20460 template <> struct TagToType<0x0070,0x1508> {
20461 static const char* GetVRString() { return "FD"; }
20462 typedef VRToType<VR::FD>::Type Type;
20463 enum : long long { VRType = VR::FD };
20464 enum { VMType = VM::VM1 };
20465 static const char* GetVMString() { return "1"; }
20466 };
20467 template <> struct TagToType<0x0070,0x150c> {
20468 static const char* GetVRString() { return "UL"; }
20469 typedef VRToType<VR::UL>::Type Type;
20470 enum : long long { VRType = VR::UL };
20471 enum { VMType = VM::VM1 };
20472 static const char* GetVMString() { return "1"; }
20473 };
20474 template <> struct TagToType<0x0070,0x150d> {
20475 static const char* GetVRString() { return "OD"; }
20476 typedef VRToType<VR::OD>::Type Type;
20477 enum : long long { VRType = VR::OD };
20478 enum { VMType = VM::VM1 };
20479 static const char* GetVMString() { return "1"; }
20480 };
20481 template <> struct TagToType<0x0070,0x1511> {
20482 static const char* GetVRString() { return "FD"; }
20483 typedef VRToType<VR::FD>::Type Type;
20484 enum : long long { VRType = VR::FD };
20485 enum { VMType = VM::VM3 };
20486 static const char* GetVMString() { return "3"; }
20487 };
20488 template <> struct TagToType<0x0070,0x1512> {
20489 static const char* GetVRString() { return "FD"; }
20490 typedef VRToType<VR::FD>::Type Type;
20491 enum : long long { VRType = VR::FD };
20492 enum { VMType = VM::VM1 };
20493 static const char* GetVMString() { return "1"; }
20494 };
20495 template <> struct TagToType<0x0070,0x1801> {
20496 static const char* GetVRString() { return "SQ"; }
20497 typedef VRToType<VR::SQ>::Type Type;
20498 enum : long long { VRType = VR::SQ };
20499 enum { VMType = VM::VM1 };
20500 static const char* GetVMString() { return "1"; }
20501 };
20502 template <> struct TagToType<0x0070,0x1802> {
20503 static const char* GetVRString() { return "CS"; }
20504 typedef VRToType<VR::CS>::Type Type;
20505 enum : long long { VRType = VR::CS };
20506 enum { VMType = VM::VM1 };
20507 static const char* GetVMString() { return "1"; }
20508 };
20509 template <> struct TagToType<0x0070,0x1803> {
20510 static const char* GetVRString() { return "SQ"; }
20511 typedef VRToType<VR::SQ>::Type Type;
20512 enum : long long { VRType = VR::SQ };
20513 enum { VMType = VM::VM1 };
20514 static const char* GetVMString() { return "1"; }
20515 };
20516 template <> struct TagToType<0x0070,0x1804> {
20517 static const char* GetVRString() { return "US"; }
20518 typedef VRToType<VR::US>::Type Type;
20519 enum : long long { VRType = VR::US };
20520 enum { VMType = VM::VM1 };
20521 static const char* GetVMString() { return "1"; }
20522 };
20523 template <> struct TagToType<0x0070,0x1805> {
20524 static const char* GetVRString() { return "SQ"; }
20525 typedef VRToType<VR::SQ>::Type Type;
20526 enum : long long { VRType = VR::SQ };
20527 enum { VMType = VM::VM1 };
20528 static const char* GetVMString() { return "1"; }
20529 };
20530 template <> struct TagToType<0x0070,0x1806> {
20531 static const char* GetVRString() { return "SQ"; }
20532 typedef VRToType<VR::SQ>::Type Type;
20533 enum : long long { VRType = VR::SQ };
20534 enum { VMType = VM::VM1 };
20535 static const char* GetVMString() { return "1"; }
20536 };
20537 template <> struct TagToType<0x0070,0x1807> {
20538 static const char* GetVRString() { return "US"; }
20539 typedef VRToType<VR::US>::Type Type;
20540 enum : long long { VRType = VR::US };
20541 enum { VMType = VM::VM3 };
20542 static const char* GetVMString() { return "3"; }
20543 };
20544 template <> struct TagToType<0x0070,0x1808> {
20545 static const char* GetVRString() { return "OB"; }
20546 typedef VRToType<VR::OB>::Type Type;
20547 enum : long long { VRType = VR::OB };
20548 enum { VMType = VM::VM1 };
20549 static const char* GetVMString() { return "1"; }
20550 };
20551 template <> struct TagToType<0x0070,0x1901> {
20552 static const char* GetVRString() { return "SQ"; }
20553 typedef VRToType<VR::SQ>::Type Type;
20554 enum : long long { VRType = VR::SQ };
20555 enum { VMType = VM::VM1 };
20556 static const char* GetVMString() { return "1"; }
20557 };
20558 template <> struct TagToType<0x0070,0x1903> {
20559 static const char* GetVRString() { return "SQ"; }
20560 typedef VRToType<VR::SQ>::Type Type;
20561 enum : long long { VRType = VR::SQ };
20562 enum { VMType = VM::VM1 };
20563 static const char* GetVMString() { return "1"; }
20564 };
20565 template <> struct TagToType<0x0070,0x1904> {
20566 static const char* GetVRString() { return "UI"; }
20567 typedef VRToType<VR::UI>::Type Type;
20568 enum : long long { VRType = VR::UI };
20569 enum { VMType = VM::VM1 };
20570 static const char* GetVMString() { return "1"; }
20571 };
20572 template <> struct TagToType<0x0070,0x1905> {
20573 static const char* GetVRString() { return "SQ"; }
20574 typedef VRToType<VR::SQ>::Type Type;
20575 enum : long long { VRType = VR::SQ };
20576 enum { VMType = VM::VM1 };
20577 static const char* GetVMString() { return "1"; }
20578 };
20579 template <> struct TagToType<0x0070,0x1907> {
20580 static const char* GetVRString() { return "CS"; }
20581 typedef VRToType<VR::CS>::Type Type;
20582 enum : long long { VRType = VR::CS };
20583 enum { VMType = VM::VM1 };
20584 static const char* GetVMString() { return "1"; }
20585 };
20586 template <> struct TagToType<0x0070,0x1a01> {
20587 static const char* GetVRString() { return "CS"; }
20588 typedef VRToType<VR::CS>::Type Type;
20589 enum : long long { VRType = VR::CS };
20590 enum { VMType = VM::VM1 };
20591 static const char* GetVMString() { return "1"; }
20592 };
20593 template <> struct TagToType<0x0070,0x1a03> {
20594 static const char* GetVRString() { return "FD"; }
20595 typedef VRToType<VR::FD>::Type Type;
20596 enum : long long { VRType = VR::FD };
20597 enum { VMType = VM::VM1 };
20598 static const char* GetVMString() { return "1"; }
20599 };
20600 template <> struct TagToType<0x0070,0x1a04> {
20601 static const char* GetVRString() { return "SQ"; }
20602 typedef VRToType<VR::SQ>::Type Type;
20603 enum : long long { VRType = VR::SQ };
20604 enum { VMType = VM::VM1 };
20605 static const char* GetVMString() { return "1"; }
20606 };
20607 template <> struct TagToType<0x0070,0x1a05> {
20608 static const char* GetVRString() { return "FD"; }
20609 typedef VRToType<VR::FD>::Type Type;
20610 enum : long long { VRType = VR::FD };
20611 enum { VMType = VM::VM1 };
20612 static const char* GetVMString() { return "1"; }
20613 };
20614 template <> struct TagToType<0x0072,0x0002> {
20615 static const char* GetVRString() { return "SH"; }
20616 typedef VRToType<VR::SH>::Type Type;
20617 enum : long long { VRType = VR::SH };
20618 enum { VMType = VM::VM1 };
20619 static const char* GetVMString() { return "1"; }
20620 };
20621 template <> struct TagToType<0x0072,0x0004> {
20622 static const char* GetVRString() { return "LO"; }
20623 typedef VRToType<VR::LO>::Type Type;
20624 enum : long long { VRType = VR::LO };
20625 enum { VMType = VM::VM1 };
20626 static const char* GetVMString() { return "1"; }
20627 };
20628 template <> struct TagToType<0x0072,0x0006> {
20629 static const char* GetVRString() { return "CS"; }
20630 typedef VRToType<VR::CS>::Type Type;
20631 enum : long long { VRType = VR::CS };
20632 enum { VMType = VM::VM1 };
20633 static const char* GetVMString() { return "1"; }
20634 };
20635 template <> struct TagToType<0x0072,0x0008> {
20636 static const char* GetVRString() { return "LO"; }
20637 typedef VRToType<VR::LO>::Type Type;
20638 enum : long long { VRType = VR::LO };
20639 enum { VMType = VM::VM1 };
20640 static const char* GetVMString() { return "1"; }
20641 };
20642 template <> struct TagToType<0x0072,0x000a> {
20643 static const char* GetVRString() { return "DT"; }
20644 typedef VRToType<VR::DT>::Type Type;
20645 enum : long long { VRType = VR::DT };
20646 enum { VMType = VM::VM1 };
20647 static const char* GetVMString() { return "1"; }
20648 };
20649 template <> struct TagToType<0x0072,0x000c> {
20650 static const char* GetVRString() { return "SQ"; }
20651 typedef VRToType<VR::SQ>::Type Type;
20652 enum : long long { VRType = VR::SQ };
20653 enum { VMType = VM::VM1 };
20654 static const char* GetVMString() { return "1"; }
20655 };
20656 template <> struct TagToType<0x0072,0x000e> {
20657 static const char* GetVRString() { return "SQ"; }
20658 typedef VRToType<VR::SQ>::Type Type;
20659 enum : long long { VRType = VR::SQ };
20660 enum { VMType = VM::VM1 };
20661 static const char* GetVMString() { return "1"; }
20662 };
20663 template <> struct TagToType<0x0072,0x0010> {
20664 static const char* GetVRString() { return "LO"; }
20665 typedef VRToType<VR::LO>::Type Type;
20666 enum : long long { VRType = VR::LO };
20667 enum { VMType = VM::VM1 };
20668 static const char* GetVMString() { return "1"; }
20669 };
20670 template <> struct TagToType<0x0072,0x0012> {
20671 static const char* GetVRString() { return "SQ"; }
20672 typedef VRToType<VR::SQ>::Type Type;
20673 enum : long long { VRType = VR::SQ };
20674 enum { VMType = VM::VM1 };
20675 static const char* GetVMString() { return "1"; }
20676 };
20677 template <> struct TagToType<0x0072,0x0014> {
20678 static const char* GetVRString() { return "US"; }
20679 typedef VRToType<VR::US>::Type Type;
20680 enum : long long { VRType = VR::US };
20681 enum { VMType = VM::VM1 };
20682 static const char* GetVMString() { return "1"; }
20683 };
20684 template <> struct TagToType<0x0072,0x0020> {
20685 static const char* GetVRString() { return "SQ"; }
20686 typedef VRToType<VR::SQ>::Type Type;
20687 enum : long long { VRType = VR::SQ };
20688 enum { VMType = VM::VM1 };
20689 static const char* GetVMString() { return "1"; }
20690 };
20691 template <> struct TagToType<0x0072,0x0022> {
20692 static const char* GetVRString() { return "SQ"; }
20693 typedef VRToType<VR::SQ>::Type Type;
20694 enum : long long { VRType = VR::SQ };
20695 enum { VMType = VM::VM1 };
20696 static const char* GetVMString() { return "1"; }
20697 };
20698 template <> struct TagToType<0x0072,0x0024> {
20699 static const char* GetVRString() { return "CS"; }
20700 typedef VRToType<VR::CS>::Type Type;
20701 enum : long long { VRType = VR::CS };
20702 enum { VMType = VM::VM1 };
20703 static const char* GetVMString() { return "1"; }
20704 };
20705 template <> struct TagToType<0x0072,0x0026> {
20706 static const char* GetVRString() { return "AT"; }
20707 typedef VRToType<VR::AT>::Type Type;
20708 enum : long long { VRType = VR::AT };
20709 enum { VMType = VM::VM1 };
20710 static const char* GetVMString() { return "1"; }
20711 };
20712 template <> struct TagToType<0x0072,0x0028> {
20713 static const char* GetVRString() { return "US"; }
20714 typedef VRToType<VR::US>::Type Type;
20715 enum : long long { VRType = VR::US };
20716 enum { VMType = VM::VM1 };
20717 static const char* GetVMString() { return "1"; }
20718 };
20719 template <> struct TagToType<0x0072,0x0030> {
20720 static const char* GetVRString() { return "SQ"; }
20721 typedef VRToType<VR::SQ>::Type Type;
20722 enum : long long { VRType = VR::SQ };
20723 enum { VMType = VM::VM1 };
20724 static const char* GetVMString() { return "1"; }
20725 };
20726 template <> struct TagToType<0x0072,0x0032> {
20727 static const char* GetVRString() { return "US"; }
20728 typedef VRToType<VR::US>::Type Type;
20729 enum : long long { VRType = VR::US };
20730 enum { VMType = VM::VM1 };
20731 static const char* GetVMString() { return "1"; }
20732 };
20733 template <> struct TagToType<0x0072,0x0034> {
20734 static const char* GetVRString() { return "CS"; }
20735 typedef VRToType<VR::CS>::Type Type;
20736 enum : long long { VRType = VR::CS };
20737 enum { VMType = VM::VM1 };
20738 static const char* GetVMString() { return "1"; }
20739 };
20740 template <> struct TagToType<0x0072,0x0038> {
20741 static const char* GetVRString() { return "US"; }
20742 typedef VRToType<VR::US>::Type Type;
20743 enum : long long { VRType = VR::US };
20744 enum { VMType = VM::VM2 };
20745 static const char* GetVMString() { return "2"; }
20746 };
20747 template <> struct TagToType<0x0072,0x003a> {
20748 static const char* GetVRString() { return "CS"; }
20749 typedef VRToType<VR::CS>::Type Type;
20750 enum : long long { VRType = VR::CS };
20751 enum { VMType = VM::VM1 };
20752 static const char* GetVMString() { return "1"; }
20753 };
20754 template <> struct TagToType<0x0072,0x003c> {
20755 static const char* GetVRString() { return "SS"; }
20756 typedef VRToType<VR::SS>::Type Type;
20757 enum : long long { VRType = VR::SS };
20758 enum { VMType = VM::VM2 };
20759 static const char* GetVMString() { return "2"; }
20760 };
20761 template <> struct TagToType<0x0072,0x003e> {
20762 static const char* GetVRString() { return "SQ"; }
20763 typedef VRToType<VR::SQ>::Type Type;
20764 enum : long long { VRType = VR::SQ };
20765 enum { VMType = VM::VM1 };
20766 static const char* GetVMString() { return "1"; }
20767 };
20768 template <> struct TagToType<0x0072,0x0040> {
20769 static const char* GetVRString() { return "LO"; }
20770 typedef VRToType<VR::LO>::Type Type;
20771 enum : long long { VRType = VR::LO };
20772 enum { VMType = VM::VM1 };
20773 static const char* GetVMString() { return "1"; }
20774 };
20775 template <> struct TagToType<0x0072,0x0050> {
20776 static const char* GetVRString() { return "CS"; }
20777 typedef VRToType<VR::CS>::Type Type;
20778 enum : long long { VRType = VR::CS };
20779 enum { VMType = VM::VM1 };
20780 static const char* GetVMString() { return "1"; }
20781 };
20782 template <> struct TagToType<0x0072,0x0052> {
20783 static const char* GetVRString() { return "AT"; }
20784 typedef VRToType<VR::AT>::Type Type;
20785 enum : long long { VRType = VR::AT };
20786 enum { VMType = VM::VM1_n };
20787 static const char* GetVMString() { return "1-n"; }
20788 };
20789 template <> struct TagToType<0x0072,0x0054> {
20790 static const char* GetVRString() { return "LO"; }
20791 typedef VRToType<VR::LO>::Type Type;
20792 enum : long long { VRType = VR::LO };
20793 enum { VMType = VM::VM1_n };
20794 static const char* GetVMString() { return "1-n"; }
20795 };
20796 template <> struct TagToType<0x0072,0x0056> {
20797 static const char* GetVRString() { return "LO"; }
20798 typedef VRToType<VR::LO>::Type Type;
20799 enum : long long { VRType = VR::LO };
20800 enum { VMType = VM::VM1 };
20801 static const char* GetVMString() { return "1"; }
20802 };
20803 template <> struct TagToType<0x0072,0x005e> {
20804 static const char* GetVRString() { return "AE"; }
20805 typedef VRToType<VR::AE>::Type Type;
20806 enum : long long { VRType = VR::AE };
20807 enum { VMType = VM::VM1_n };
20808 static const char* GetVMString() { return "1-n"; }
20809 };
20810 template <> struct TagToType<0x0072,0x005f> {
20811 static const char* GetVRString() { return "AS"; }
20812 typedef VRToType<VR::AS>::Type Type;
20813 enum : long long { VRType = VR::AS };
20814 enum { VMType = VM::VM1_n };
20815 static const char* GetVMString() { return "1-n"; }
20816 };
20817 template <> struct TagToType<0x0072,0x0060> {
20818 static const char* GetVRString() { return "AT"; }
20819 typedef VRToType<VR::AT>::Type Type;
20820 enum : long long { VRType = VR::AT };
20821 enum { VMType = VM::VM1_n };
20822 static const char* GetVMString() { return "1-n"; }
20823 };
20824 template <> struct TagToType<0x0072,0x0061> {
20825 static const char* GetVRString() { return "DA"; }
20826 typedef VRToType<VR::DA>::Type Type;
20827 enum : long long { VRType = VR::DA };
20828 enum { VMType = VM::VM1_n };
20829 static const char* GetVMString() { return "1-n"; }
20830 };
20831 template <> struct TagToType<0x0072,0x0062> {
20832 static const char* GetVRString() { return "CS"; }
20833 typedef VRToType<VR::CS>::Type Type;
20834 enum : long long { VRType = VR::CS };
20835 enum { VMType = VM::VM1_n };
20836 static const char* GetVMString() { return "1-n"; }
20837 };
20838 template <> struct TagToType<0x0072,0x0063> {
20839 static const char* GetVRString() { return "DT"; }
20840 typedef VRToType<VR::DT>::Type Type;
20841 enum : long long { VRType = VR::DT };
20842 enum { VMType = VM::VM1_n };
20843 static const char* GetVMString() { return "1-n"; }
20844 };
20845 template <> struct TagToType<0x0072,0x0064> {
20846 static const char* GetVRString() { return "IS"; }
20847 typedef VRToType<VR::IS>::Type Type;
20848 enum : long long { VRType = VR::IS };
20849 enum { VMType = VM::VM1_n };
20850 static const char* GetVMString() { return "1-n"; }
20851 };
20852 template <> struct TagToType<0x0072,0x0065> {
20853 static const char* GetVRString() { return "OB"; }
20854 typedef VRToType<VR::OB>::Type Type;
20855 enum : long long { VRType = VR::OB };
20856 enum { VMType = VM::VM1 };
20857 static const char* GetVMString() { return "1"; }
20858 };
20859 template <> struct TagToType<0x0072,0x0066> {
20860 static const char* GetVRString() { return "LO"; }
20861 typedef VRToType<VR::LO>::Type Type;
20862 enum : long long { VRType = VR::LO };
20863 enum { VMType = VM::VM1_n };
20864 static const char* GetVMString() { return "1-n"; }
20865 };
20866 template <> struct TagToType<0x0072,0x0067> {
20867 static const char* GetVRString() { return "OF"; }
20868 typedef VRToType<VR::OF>::Type Type;
20869 enum : long long { VRType = VR::OF };
20870 enum { VMType = VM::VM1 };
20871 static const char* GetVMString() { return "1"; }
20872 };
20873 template <> struct TagToType<0x0072,0x0068> {
20874 static const char* GetVRString() { return "LT"; }
20875 typedef VRToType<VR::LT>::Type Type;
20876 enum : long long { VRType = VR::LT };
20877 enum { VMType = VM::VM1 };
20878 static const char* GetVMString() { return "1"; }
20879 };
20880 template <> struct TagToType<0x0072,0x0069> {
20881 static const char* GetVRString() { return "OW"; }
20882 typedef VRToType<VR::OW>::Type Type;
20883 enum : long long { VRType = VR::OW };
20884 enum { VMType = VM::VM1 };
20885 static const char* GetVMString() { return "1"; }
20886 };
20887 template <> struct TagToType<0x0072,0x006a> {
20888 static const char* GetVRString() { return "PN"; }
20889 typedef VRToType<VR::PN>::Type Type;
20890 enum : long long { VRType = VR::PN };
20891 enum { VMType = VM::VM1_n };
20892 static const char* GetVMString() { return "1-n"; }
20893 };
20894 template <> struct TagToType<0x0072,0x006b> {
20895 static const char* GetVRString() { return "TM"; }
20896 typedef VRToType<VR::TM>::Type Type;
20897 enum : long long { VRType = VR::TM };
20898 enum { VMType = VM::VM1_n };
20899 static const char* GetVMString() { return "1-n"; }
20900 };
20901 template <> struct TagToType<0x0072,0x006c> {
20902 static const char* GetVRString() { return "SH"; }
20903 typedef VRToType<VR::SH>::Type Type;
20904 enum : long long { VRType = VR::SH };
20905 enum { VMType = VM::VM1_n };
20906 static const char* GetVMString() { return "1-n"; }
20907 };
20908 template <> struct TagToType<0x0072,0x006d> {
20909 static const char* GetVRString() { return "UN"; }
20910 typedef VRToType<VR::UN>::Type Type;
20911 enum : long long { VRType = VR::UN };
20912 enum { VMType = VM::VM1 };
20913 static const char* GetVMString() { return "1"; }
20914 };
20915 template <> struct TagToType<0x0072,0x006e> {
20916 static const char* GetVRString() { return "ST"; }
20917 typedef VRToType<VR::ST>::Type Type;
20918 enum : long long { VRType = VR::ST };
20919 enum { VMType = VM::VM1 };
20920 static const char* GetVMString() { return "1"; }
20921 };
20922 template <> struct TagToType<0x0072,0x006f> {
20923 static const char* GetVRString() { return "UC"; }
20924 typedef VRToType<VR::UC>::Type Type;
20925 enum : long long { VRType = VR::UC };
20926 enum { VMType = VM::VM1_n };
20927 static const char* GetVMString() { return "1-n"; }
20928 };
20929 template <> struct TagToType<0x0072,0x0070> {
20930 static const char* GetVRString() { return "UT"; }
20931 typedef VRToType<VR::UT>::Type Type;
20932 enum : long long { VRType = VR::UT };
20933 enum { VMType = VM::VM1 };
20934 static const char* GetVMString() { return "1"; }
20935 };
20936 template <> struct TagToType<0x0072,0x0071> {
20937 static const char* GetVRString() { return "UR"; }
20938 typedef VRToType<VR::UR>::Type Type;
20939 enum : long long { VRType = VR::UR };
20940 enum { VMType = VM::VM1 };
20941 static const char* GetVMString() { return "1"; }
20942 };
20943 template <> struct TagToType<0x0072,0x0072> {
20944 static const char* GetVRString() { return "DS"; }
20945 typedef VRToType<VR::DS>::Type Type;
20946 enum : long long { VRType = VR::DS };
20947 enum { VMType = VM::VM1_n };
20948 static const char* GetVMString() { return "1-n"; }
20949 };
20950 template <> struct TagToType<0x0072,0x0073> {
20951 static const char* GetVRString() { return "OD"; }
20952 typedef VRToType<VR::OD>::Type Type;
20953 enum : long long { VRType = VR::OD };
20954 enum { VMType = VM::VM1 };
20955 static const char* GetVMString() { return "1"; }
20956 };
20957 template <> struct TagToType<0x0072,0x0074> {
20958 static const char* GetVRString() { return "FD"; }
20959 typedef VRToType<VR::FD>::Type Type;
20960 enum : long long { VRType = VR::FD };
20961 enum { VMType = VM::VM1_n };
20962 static const char* GetVMString() { return "1-n"; }
20963 };
20964 template <> struct TagToType<0x0072,0x0075> {
20965 static const char* GetVRString() { return "OL"; }
20966 typedef VRToType<VR::OL>::Type Type;
20967 enum : long long { VRType = VR::OL };
20968 enum { VMType = VM::VM1 };
20969 static const char* GetVMString() { return "1"; }
20970 };
20971 template <> struct TagToType<0x0072,0x0076> {
20972 static const char* GetVRString() { return "FL"; }
20973 typedef VRToType<VR::FL>::Type Type;
20974 enum : long long { VRType = VR::FL };
20975 enum { VMType = VM::VM1_n };
20976 static const char* GetVMString() { return "1-n"; }
20977 };
20978 template <> struct TagToType<0x0072,0x0078> {
20979 static const char* GetVRString() { return "UL"; }
20980 typedef VRToType<VR::UL>::Type Type;
20981 enum : long long { VRType = VR::UL };
20982 enum { VMType = VM::VM1_n };
20983 static const char* GetVMString() { return "1-n"; }
20984 };
20985 template <> struct TagToType<0x0072,0x007a> {
20986 static const char* GetVRString() { return "US"; }
20987 typedef VRToType<VR::US>::Type Type;
20988 enum : long long { VRType = VR::US };
20989 enum { VMType = VM::VM1_n };
20990 static const char* GetVMString() { return "1-n"; }
20991 };
20992 template <> struct TagToType<0x0072,0x007c> {
20993 static const char* GetVRString() { return "SL"; }
20994 typedef VRToType<VR::SL>::Type Type;
20995 enum : long long { VRType = VR::SL };
20996 enum { VMType = VM::VM1_n };
20997 static const char* GetVMString() { return "1-n"; }
20998 };
20999 template <> struct TagToType<0x0072,0x007e> {
21000 static const char* GetVRString() { return "SS"; }
21001 typedef VRToType<VR::SS>::Type Type;
21002 enum : long long { VRType = VR::SS };
21003 enum { VMType = VM::VM1_n };
21004 static const char* GetVMString() { return "1-n"; }
21005 };
21006 template <> struct TagToType<0x0072,0x007f> {
21007 static const char* GetVRString() { return "UI"; }
21008 typedef VRToType<VR::UI>::Type Type;
21009 enum : long long { VRType = VR::UI };
21010 enum { VMType = VM::VM1_n };
21011 static const char* GetVMString() { return "1-n"; }
21012 };
21013 template <> struct TagToType<0x0072,0x0080> {
21014 static const char* GetVRString() { return "SQ"; }
21015 typedef VRToType<VR::SQ>::Type Type;
21016 enum : long long { VRType = VR::SQ };
21017 enum { VMType = VM::VM1 };
21018 static const char* GetVMString() { return "1"; }
21019 };
21020 template <> struct TagToType<0x0072,0x0100> {
21021 static const char* GetVRString() { return "US"; }
21022 typedef VRToType<VR::US>::Type Type;
21023 enum : long long { VRType = VR::US };
21024 enum { VMType = VM::VM1 };
21025 static const char* GetVMString() { return "1"; }
21026 };
21027 template <> struct TagToType<0x0072,0x0102> {
21028 static const char* GetVRString() { return "SQ"; }
21029 typedef VRToType<VR::SQ>::Type Type;
21030 enum : long long { VRType = VR::SQ };
21031 enum { VMType = VM::VM1 };
21032 static const char* GetVMString() { return "1"; }
21033 };
21034 template <> struct TagToType<0x0072,0x0104> {
21035 static const char* GetVRString() { return "US"; }
21036 typedef VRToType<VR::US>::Type Type;
21037 enum : long long { VRType = VR::US };
21038 enum { VMType = VM::VM1 };
21039 static const char* GetVMString() { return "1"; }
21040 };
21041 template <> struct TagToType<0x0072,0x0106> {
21042 static const char* GetVRString() { return "US"; }
21043 typedef VRToType<VR::US>::Type Type;
21044 enum : long long { VRType = VR::US };
21045 enum { VMType = VM::VM1 };
21046 static const char* GetVMString() { return "1"; }
21047 };
21048 template <> struct TagToType<0x0072,0x0108> {
21049 static const char* GetVRString() { return "FD"; }
21050 typedef VRToType<VR::FD>::Type Type;
21051 enum : long long { VRType = VR::FD };
21052 enum { VMType = VM::VM4 };
21053 static const char* GetVMString() { return "4"; }
21054 };
21055 template <> struct TagToType<0x0072,0x010a> {
21056 static const char* GetVRString() { return "US"; }
21057 typedef VRToType<VR::US>::Type Type;
21058 enum : long long { VRType = VR::US };
21059 enum { VMType = VM::VM1 };
21060 static const char* GetVMString() { return "1"; }
21061 };
21062 template <> struct TagToType<0x0072,0x010c> {
21063 static const char* GetVRString() { return "US"; }
21064 typedef VRToType<VR::US>::Type Type;
21065 enum : long long { VRType = VR::US };
21066 enum { VMType = VM::VM1 };
21067 static const char* GetVMString() { return "1"; }
21068 };
21069 template <> struct TagToType<0x0072,0x010e> {
21070 static const char* GetVRString() { return "US"; }
21071 typedef VRToType<VR::US>::Type Type;
21072 enum : long long { VRType = VR::US };
21073 enum { VMType = VM::VM1 };
21074 static const char* GetVMString() { return "1"; }
21075 };
21076 template <> struct TagToType<0x0072,0x0200> {
21077 static const char* GetVRString() { return "SQ"; }
21078 typedef VRToType<VR::SQ>::Type Type;
21079 enum : long long { VRType = VR::SQ };
21080 enum { VMType = VM::VM1 };
21081 static const char* GetVMString() { return "1"; }
21082 };
21083 template <> struct TagToType<0x0072,0x0202> {
21084 static const char* GetVRString() { return "US"; }
21085 typedef VRToType<VR::US>::Type Type;
21086 enum : long long { VRType = VR::US };
21087 enum { VMType = VM::VM1 };
21088 static const char* GetVMString() { return "1"; }
21089 };
21090 template <> struct TagToType<0x0072,0x0203> {
21091 static const char* GetVRString() { return "LO"; }
21092 typedef VRToType<VR::LO>::Type Type;
21093 enum : long long { VRType = VR::LO };
21094 enum { VMType = VM::VM1 };
21095 static const char* GetVMString() { return "1"; }
21096 };
21097 template <> struct TagToType<0x0072,0x0204> {
21098 static const char* GetVRString() { return "US"; }
21099 typedef VRToType<VR::US>::Type Type;
21100 enum : long long { VRType = VR::US };
21101 enum { VMType = VM::VM1 };
21102 static const char* GetVMString() { return "1"; }
21103 };
21104 template <> struct TagToType<0x0072,0x0206> {
21105 static const char* GetVRString() { return "LO"; }
21106 typedef VRToType<VR::LO>::Type Type;
21107 enum : long long { VRType = VR::LO };
21108 enum { VMType = VM::VM1 };
21109 static const char* GetVMString() { return "1"; }
21110 };
21111 template <> struct TagToType<0x0072,0x0208> {
21112 static const char* GetVRString() { return "CS"; }
21113 typedef VRToType<VR::CS>::Type Type;
21114 enum : long long { VRType = VR::CS };
21115 enum { VMType = VM::VM1 };
21116 static const char* GetVMString() { return "1"; }
21117 };
21118 template <> struct TagToType<0x0072,0x0210> {
21119 static const char* GetVRString() { return "SQ"; }
21120 typedef VRToType<VR::SQ>::Type Type;
21121 enum : long long { VRType = VR::SQ };
21122 enum { VMType = VM::VM1 };
21123 static const char* GetVMString() { return "1"; }
21124 };
21125 template <> struct TagToType<0x0072,0x0212> {
21126 static const char* GetVRString() { return "US"; }
21127 typedef VRToType<VR::US>::Type Type;
21128 enum : long long { VRType = VR::US };
21129 enum { VMType = VM::VM2_n };
21130 static const char* GetVMString() { return "2-n"; }
21131 };
21132 template <> struct TagToType<0x0072,0x0214> {
21133 static const char* GetVRString() { return "SQ"; }
21134 typedef VRToType<VR::SQ>::Type Type;
21135 enum : long long { VRType = VR::SQ };
21136 enum { VMType = VM::VM1 };
21137 static const char* GetVMString() { return "1"; }
21138 };
21139 template <> struct TagToType<0x0072,0x0216> {
21140 static const char* GetVRString() { return "US"; }
21141 typedef VRToType<VR::US>::Type Type;
21142 enum : long long { VRType = VR::US };
21143 enum { VMType = VM::VM1 };
21144 static const char* GetVMString() { return "1"; }
21145 };
21146 template <> struct TagToType<0x0072,0x0218> {
21147 static const char* GetVRString() { return "US"; }
21148 typedef VRToType<VR::US>::Type Type;
21149 enum : long long { VRType = VR::US };
21150 enum { VMType = VM::VM1_n };
21151 static const char* GetVMString() { return "1-n"; }
21152 };
21153 template <> struct TagToType<0x0072,0x0300> {
21154 static const char* GetVRString() { return "SQ"; }
21155 typedef VRToType<VR::SQ>::Type Type;
21156 enum : long long { VRType = VR::SQ };
21157 enum { VMType = VM::VM1 };
21158 static const char* GetVMString() { return "1"; }
21159 };
21160 template <> struct TagToType<0x0072,0x0302> {
21161 static const char* GetVRString() { return "US"; }
21162 typedef VRToType<VR::US>::Type Type;
21163 enum : long long { VRType = VR::US };
21164 enum { VMType = VM::VM1 };
21165 static const char* GetVMString() { return "1"; }
21166 };
21167 template <> struct TagToType<0x0072,0x0304> {
21168 static const char* GetVRString() { return "CS"; }
21169 typedef VRToType<VR::CS>::Type Type;
21170 enum : long long { VRType = VR::CS };
21171 enum { VMType = VM::VM1 };
21172 static const char* GetVMString() { return "1"; }
21173 };
21174 template <> struct TagToType<0x0072,0x0306> {
21175 static const char* GetVRString() { return "US"; }
21176 typedef VRToType<VR::US>::Type Type;
21177 enum : long long { VRType = VR::US };
21178 enum { VMType = VM::VM1 };
21179 static const char* GetVMString() { return "1"; }
21180 };
21181 template <> struct TagToType<0x0072,0x0308> {
21182 static const char* GetVRString() { return "US"; }
21183 typedef VRToType<VR::US>::Type Type;
21184 enum : long long { VRType = VR::US };
21185 enum { VMType = VM::VM1 };
21186 static const char* GetVMString() { return "1"; }
21187 };
21188 template <> struct TagToType<0x0072,0x0310> {
21189 static const char* GetVRString() { return "CS"; }
21190 typedef VRToType<VR::CS>::Type Type;
21191 enum : long long { VRType = VR::CS };
21192 enum { VMType = VM::VM1 };
21193 static const char* GetVMString() { return "1"; }
21194 };
21195 template <> struct TagToType<0x0072,0x0312> {
21196 static const char* GetVRString() { return "CS"; }
21197 typedef VRToType<VR::CS>::Type Type;
21198 enum : long long { VRType = VR::CS };
21199 enum { VMType = VM::VM1 };
21200 static const char* GetVMString() { return "1"; }
21201 };
21202 template <> struct TagToType<0x0072,0x0314> {
21203 static const char* GetVRString() { return "US"; }
21204 typedef VRToType<VR::US>::Type Type;
21205 enum : long long { VRType = VR::US };
21206 enum { VMType = VM::VM1 };
21207 static const char* GetVMString() { return "1"; }
21208 };
21209 template <> struct TagToType<0x0072,0x0316> {
21210 static const char* GetVRString() { return "CS"; }
21211 typedef VRToType<VR::CS>::Type Type;
21212 enum : long long { VRType = VR::CS };
21213 enum { VMType = VM::VM1 };
21214 static const char* GetVMString() { return "1"; }
21215 };
21216 template <> struct TagToType<0x0072,0x0318> {
21217 static const char* GetVRString() { return "US"; }
21218 typedef VRToType<VR::US>::Type Type;
21219 enum : long long { VRType = VR::US };
21220 enum { VMType = VM::VM1 };
21221 static const char* GetVMString() { return "1"; }
21222 };
21223 template <> struct TagToType<0x0072,0x0320> {
21224 static const char* GetVRString() { return "US"; }
21225 typedef VRToType<VR::US>::Type Type;
21226 enum : long long { VRType = VR::US };
21227 enum { VMType = VM::VM1 };
21228 static const char* GetVMString() { return "1"; }
21229 };
21230 template <> struct TagToType<0x0072,0x0330> {
21231 static const char* GetVRString() { return "FD"; }
21232 typedef VRToType<VR::FD>::Type Type;
21233 enum : long long { VRType = VR::FD };
21234 enum { VMType = VM::VM1 };
21235 static const char* GetVMString() { return "1"; }
21236 };
21237 template <> struct TagToType<0x0072,0x0400> {
21238 static const char* GetVRString() { return "SQ"; }
21239 typedef VRToType<VR::SQ>::Type Type;
21240 enum : long long { VRType = VR::SQ };
21241 enum { VMType = VM::VM1 };
21242 static const char* GetVMString() { return "1"; }
21243 };
21244 template <> struct TagToType<0x0072,0x0402> {
21245 static const char* GetVRString() { return "CS"; }
21246 typedef VRToType<VR::CS>::Type Type;
21247 enum : long long { VRType = VR::CS };
21248 enum { VMType = VM::VM1 };
21249 static const char* GetVMString() { return "1"; }
21250 };
21251 template <> struct TagToType<0x0072,0x0404> {
21252 static const char* GetVRString() { return "CS"; }
21253 typedef VRToType<VR::CS>::Type Type;
21254 enum : long long { VRType = VR::CS };
21255 enum { VMType = VM::VM1 };
21256 static const char* GetVMString() { return "1"; }
21257 };
21258 template <> struct TagToType<0x0072,0x0406> {
21259 static const char* GetVRString() { return "CS"; }
21260 typedef VRToType<VR::CS>::Type Type;
21261 enum : long long { VRType = VR::CS };
21262 enum { VMType = VM::VM1 };
21263 static const char* GetVMString() { return "1"; }
21264 };
21265 template <> struct TagToType<0x0072,0x0420> {
21266 static const char* GetVRString() { return "US"; }
21267 typedef VRToType<VR::US>::Type Type;
21268 enum : long long { VRType = VR::US };
21269 enum { VMType = VM::VM3 };
21270 static const char* GetVMString() { return "3"; }
21271 };
21272 template <> struct TagToType<0x0072,0x0421> {
21273 static const char* GetVRString() { return "US"; }
21274 typedef VRToType<VR::US>::Type Type;
21275 enum : long long { VRType = VR::US };
21276 enum { VMType = VM::VM3 };
21277 static const char* GetVMString() { return "3"; }
21278 };
21279 template <> struct TagToType<0x0072,0x0422> {
21280 static const char* GetVRString() { return "SQ"; }
21281 typedef VRToType<VR::SQ>::Type Type;
21282 enum : long long { VRType = VR::SQ };
21283 enum { VMType = VM::VM1 };
21284 static const char* GetVMString() { return "1"; }
21285 };
21286 template <> struct TagToType<0x0072,0x0424> {
21287 static const char* GetVRString() { return "SQ"; }
21288 typedef VRToType<VR::SQ>::Type Type;
21289 enum : long long { VRType = VR::SQ };
21290 enum { VMType = VM::VM1 };
21291 static const char* GetVMString() { return "1"; }
21292 };
21293 template <> struct TagToType<0x0072,0x0427> {
21294 static const char* GetVRString() { return "SQ"; }
21295 typedef VRToType<VR::SQ>::Type Type;
21296 enum : long long { VRType = VR::SQ };
21297 enum { VMType = VM::VM1 };
21298 static const char* GetVMString() { return "1"; }
21299 };
21300 template <> struct TagToType<0x0072,0x0430> {
21301 static const char* GetVRString() { return "SQ"; }
21302 typedef VRToType<VR::SQ>::Type Type;
21303 enum : long long { VRType = VR::SQ };
21304 enum { VMType = VM::VM1 };
21305 static const char* GetVMString() { return "1"; }
21306 };
21307 template <> struct TagToType<0x0072,0x0432> {
21308 static const char* GetVRString() { return "US"; }
21309 typedef VRToType<VR::US>::Type Type;
21310 enum : long long { VRType = VR::US };
21311 enum { VMType = VM::VM2_n };
21312 static const char* GetVMString() { return "2-n"; }
21313 };
21314 template <> struct TagToType<0x0072,0x0434> {
21315 static const char* GetVRString() { return "CS"; }
21316 typedef VRToType<VR::CS>::Type Type;
21317 enum : long long { VRType = VR::CS };
21318 enum { VMType = VM::VM1 };
21319 static const char* GetVMString() { return "1"; }
21320 };
21321 template <> struct TagToType<0x0072,0x0500> {
21322 static const char* GetVRString() { return "CS"; }
21323 typedef VRToType<VR::CS>::Type Type;
21324 enum : long long { VRType = VR::CS };
21325 enum { VMType = VM::VM1 };
21326 static const char* GetVMString() { return "1"; }
21327 };
21328 template <> struct TagToType<0x0072,0x0510> {
21329 static const char* GetVRString() { return "CS"; }
21330 typedef VRToType<VR::CS>::Type Type;
21331 enum : long long { VRType = VR::CS };
21332 enum { VMType = VM::VM1 };
21333 static const char* GetVMString() { return "1"; }
21334 };
21335 template <> struct TagToType<0x0072,0x0512> {
21336 static const char* GetVRString() { return "FD"; }
21337 typedef VRToType<VR::FD>::Type Type;
21338 enum : long long { VRType = VR::FD };
21339 enum { VMType = VM::VM1 };
21340 static const char* GetVMString() { return "1"; }
21341 };
21342 template <> struct TagToType<0x0072,0x0514> {
21343 static const char* GetVRString() { return "FD"; }
21344 typedef VRToType<VR::FD>::Type Type;
21345 enum : long long { VRType = VR::FD };
21346 enum { VMType = VM::VM1 };
21347 static const char* GetVMString() { return "1"; }
21348 };
21349 template <> struct TagToType<0x0072,0x0516> {
21350 static const char* GetVRString() { return "CS"; }
21351 typedef VRToType<VR::CS>::Type Type;
21352 enum : long long { VRType = VR::CS };
21353 enum { VMType = VM::VM1 };
21354 static const char* GetVMString() { return "1"; }
21355 };
21356 template <> struct TagToType<0x0072,0x0520> {
21357 static const char* GetVRString() { return "CS"; }
21358 typedef VRToType<VR::CS>::Type Type;
21359 enum : long long { VRType = VR::CS };
21360 enum { VMType = VM::VM1_n };
21361 static const char* GetVMString() { return "1-n"; }
21362 };
21363 template <> struct TagToType<0x0072,0x0600> {
21364 static const char* GetVRString() { return "SQ"; }
21365 typedef VRToType<VR::SQ>::Type Type;
21366 enum : long long { VRType = VR::SQ };
21367 enum { VMType = VM::VM1 };
21368 static const char* GetVMString() { return "1"; }
21369 };
21370 template <> struct TagToType<0x0072,0x0602> {
21371 static const char* GetVRString() { return "CS"; }
21372 typedef VRToType<VR::CS>::Type Type;
21373 enum : long long { VRType = VR::CS };
21374 enum { VMType = VM::VM1 };
21375 static const char* GetVMString() { return "1"; }
21376 };
21377 template <> struct TagToType<0x0072,0x0604> {
21378 static const char* GetVRString() { return "CS"; }
21379 typedef VRToType<VR::CS>::Type Type;
21380 enum : long long { VRType = VR::CS };
21381 enum { VMType = VM::VM1 };
21382 static const char* GetVMString() { return "1"; }
21383 };
21384 template <> struct TagToType<0x0072,0x0700> {
21385 static const char* GetVRString() { return "CS"; }
21386 typedef VRToType<VR::CS>::Type Type;
21387 enum : long long { VRType = VR::CS };
21388 enum { VMType = VM::VM2 };
21389 static const char* GetVMString() { return "2"; }
21390 };
21391 template <> struct TagToType<0x0072,0x0702> {
21392 static const char* GetVRString() { return "CS"; }
21393 typedef VRToType<VR::CS>::Type Type;
21394 enum : long long { VRType = VR::CS };
21395 enum { VMType = VM::VM1 };
21396 static const char* GetVMString() { return "1"; }
21397 };
21398 template <> struct TagToType<0x0072,0x0704> {
21399 static const char* GetVRString() { return "CS"; }
21400 typedef VRToType<VR::CS>::Type Type;
21401 enum : long long { VRType = VR::CS };
21402 enum { VMType = VM::VM1 };
21403 static const char* GetVMString() { return "1"; }
21404 };
21405 template <> struct TagToType<0x0072,0x0705> {
21406 static const char* GetVRString() { return "SQ"; }
21407 typedef VRToType<VR::SQ>::Type Type;
21408 enum : long long { VRType = VR::SQ };
21409 enum { VMType = VM::VM1 };
21410 static const char* GetVMString() { return "1"; }
21411 };
21412 template <> struct TagToType<0x0072,0x0706> {
21413 static const char* GetVRString() { return "CS"; }
21414 typedef VRToType<VR::CS>::Type Type;
21415 enum : long long { VRType = VR::CS };
21416 enum { VMType = VM::VM1 };
21417 static const char* GetVMString() { return "1"; }
21418 };
21419 template <> struct TagToType<0x0072,0x0710> {
21420 static const char* GetVRString() { return "CS"; }
21421 typedef VRToType<VR::CS>::Type Type;
21422 enum : long long { VRType = VR::CS };
21423 enum { VMType = VM::VM1 };
21424 static const char* GetVMString() { return "1"; }
21425 };
21426 template <> struct TagToType<0x0072,0x0712> {
21427 static const char* GetVRString() { return "CS"; }
21428 typedef VRToType<VR::CS>::Type Type;
21429 enum : long long { VRType = VR::CS };
21430 enum { VMType = VM::VM1 };
21431 static const char* GetVMString() { return "1"; }
21432 };
21433 template <> struct TagToType<0x0072,0x0714> {
21434 static const char* GetVRString() { return "CS"; }
21435 typedef VRToType<VR::CS>::Type Type;
21436 enum : long long { VRType = VR::CS };
21437 enum { VMType = VM::VM1 };
21438 static const char* GetVMString() { return "1"; }
21439 };
21440 template <> struct TagToType<0x0072,0x0716> {
21441 static const char* GetVRString() { return "CS"; }
21442 typedef VRToType<VR::CS>::Type Type;
21443 enum : long long { VRType = VR::CS };
21444 enum { VMType = VM::VM1 };
21445 static const char* GetVMString() { return "1"; }
21446 };
21447 template <> struct TagToType<0x0072,0x0717> {
21448 static const char* GetVRString() { return "CS"; }
21449 typedef VRToType<VR::CS>::Type Type;
21450 enum : long long { VRType = VR::CS };
21451 enum { VMType = VM::VM1 };
21452 static const char* GetVMString() { return "1"; }
21453 };
21454 template <> struct TagToType<0x0072,0x0718> {
21455 static const char* GetVRString() { return "CS"; }
21456 typedef VRToType<VR::CS>::Type Type;
21457 enum : long long { VRType = VR::CS };
21458 enum { VMType = VM::VM1 };
21459 static const char* GetVMString() { return "1"; }
21460 };
21461 template <> struct TagToType<0x0074,0x0120> {
21462 static const char* GetVRString() { return "FD"; }
21463 typedef VRToType<VR::FD>::Type Type;
21464 enum : long long { VRType = VR::FD };
21465 enum { VMType = VM::VM1 };
21466 static const char* GetVMString() { return "1"; }
21467 };
21468 template <> struct TagToType<0x0074,0x0121> {
21469 static const char* GetVRString() { return "FD"; }
21470 typedef VRToType<VR::FD>::Type Type;
21471 enum : long long { VRType = VR::FD };
21472 enum { VMType = VM::VM1 };
21473 static const char* GetVMString() { return "1"; }
21474 };
21475 template <> struct TagToType<0x0074,0x1000> {
21476 static const char* GetVRString() { return "CS"; }
21477 typedef VRToType<VR::CS>::Type Type;
21478 enum : long long { VRType = VR::CS };
21479 enum { VMType = VM::VM1 };
21480 static const char* GetVMString() { return "1"; }
21481 };
21482 template <> struct TagToType<0x0074,0x1002> {
21483 static const char* GetVRString() { return "SQ"; }
21484 typedef VRToType<VR::SQ>::Type Type;
21485 enum : long long { VRType = VR::SQ };
21486 enum { VMType = VM::VM1 };
21487 static const char* GetVMString() { return "1"; }
21488 };
21489 template <> struct TagToType<0x0074,0x1004> {
21490 static const char* GetVRString() { return "DS"; }
21491 typedef VRToType<VR::DS>::Type Type;
21492 enum : long long { VRType = VR::DS };
21493 enum { VMType = VM::VM1 };
21494 static const char* GetVMString() { return "1"; }
21495 };
21496 template <> struct TagToType<0x0074,0x1006> {
21497 static const char* GetVRString() { return "ST"; }
21498 typedef VRToType<VR::ST>::Type Type;
21499 enum : long long { VRType = VR::ST };
21500 enum { VMType = VM::VM1 };
21501 static const char* GetVMString() { return "1"; }
21502 };
21503 template <> struct TagToType<0x0074,0x1008> {
21504 static const char* GetVRString() { return "SQ"; }
21505 typedef VRToType<VR::SQ>::Type Type;
21506 enum : long long { VRType = VR::SQ };
21507 enum { VMType = VM::VM1 };
21508 static const char* GetVMString() { return "1"; }
21509 };
21510 template <> struct TagToType<0x0074,0x100a> {
21511 static const char* GetVRString() { return "UR"; }
21512 typedef VRToType<VR::UR>::Type Type;
21513 enum : long long { VRType = VR::UR };
21514 enum { VMType = VM::VM1 };
21515 static const char* GetVMString() { return "1"; }
21516 };
21517 template <> struct TagToType<0x0074,0x100c> {
21518 static const char* GetVRString() { return "LO"; }
21519 typedef VRToType<VR::LO>::Type Type;
21520 enum : long long { VRType = VR::LO };
21521 enum { VMType = VM::VM1 };
21522 static const char* GetVMString() { return "1"; }
21523 };
21524 template <> struct TagToType<0x0074,0x100e> {
21525 static const char* GetVRString() { return "SQ"; }
21526 typedef VRToType<VR::SQ>::Type Type;
21527 enum : long long { VRType = VR::SQ };
21528 enum { VMType = VM::VM1 };
21529 static const char* GetVMString() { return "1"; }
21530 };
21531 template <> struct TagToType<0x0074,0x1020> {
21532 static const char* GetVRString() { return "SQ"; }
21533 typedef VRToType<VR::SQ>::Type Type;
21534 enum : long long { VRType = VR::SQ };
21535 enum { VMType = VM::VM1 };
21536 static const char* GetVMString() { return "1"; }
21537 };
21538 template <> struct TagToType<0x0074,0x1022> {
21539 static const char* GetVRString() { return "CS"; }
21540 typedef VRToType<VR::CS>::Type Type;
21541 enum : long long { VRType = VR::CS };
21542 enum { VMType = VM::VM1 };
21543 static const char* GetVMString() { return "1"; }
21544 };
21545 template <> struct TagToType<0x0074,0x1024> {
21546 static const char* GetVRString() { return "IS"; }
21547 typedef VRToType<VR::IS>::Type Type;
21548 enum : long long { VRType = VR::IS };
21549 enum { VMType = VM::VM1 };
21550 static const char* GetVMString() { return "1"; }
21551 };
21552 template <> struct TagToType<0x0074,0x1025> {
21553 static const char* GetVRString() { return "CS"; }
21554 typedef VRToType<VR::CS>::Type Type;
21555 enum : long long { VRType = VR::CS };
21556 enum { VMType = VM::VM1 };
21557 static const char* GetVMString() { return "1"; }
21558 };
21559 template <> struct TagToType<0x0074,0x1026> {
21560 static const char* GetVRString() { return "FD"; }
21561 typedef VRToType<VR::FD>::Type Type;
21562 enum : long long { VRType = VR::FD };
21563 enum { VMType = VM::VM1 };
21564 static const char* GetVMString() { return "1"; }
21565 };
21566 template <> struct TagToType<0x0074,0x1027> {
21567 static const char* GetVRString() { return "FD"; }
21568 typedef VRToType<VR::FD>::Type Type;
21569 enum : long long { VRType = VR::FD };
21570 enum { VMType = VM::VM1 };
21571 static const char* GetVMString() { return "1"; }
21572 };
21573 template <> struct TagToType<0x0074,0x1028> {
21574 static const char* GetVRString() { return "FD"; }
21575 typedef VRToType<VR::FD>::Type Type;
21576 enum : long long { VRType = VR::FD };
21577 enum { VMType = VM::VM1 };
21578 static const char* GetVMString() { return "1"; }
21579 };
21580 template <> struct TagToType<0x0074,0x102a> {
21581 static const char* GetVRString() { return "FD"; }
21582 typedef VRToType<VR::FD>::Type Type;
21583 enum : long long { VRType = VR::FD };
21584 enum { VMType = VM::VM1 };
21585 static const char* GetVMString() { return "1"; }
21586 };
21587 template <> struct TagToType<0x0074,0x102b> {
21588 static const char* GetVRString() { return "FD"; }
21589 typedef VRToType<VR::FD>::Type Type;
21590 enum : long long { VRType = VR::FD };
21591 enum { VMType = VM::VM1 };
21592 static const char* GetVMString() { return "1"; }
21593 };
21594 template <> struct TagToType<0x0074,0x102c> {
21595 static const char* GetVRString() { return "FD"; }
21596 typedef VRToType<VR::FD>::Type Type;
21597 enum : long long { VRType = VR::FD };
21598 enum { VMType = VM::VM1 };
21599 static const char* GetVMString() { return "1"; }
21600 };
21601 template <> struct TagToType<0x0074,0x102d> {
21602 static const char* GetVRString() { return "FD"; }
21603 typedef VRToType<VR::FD>::Type Type;
21604 enum : long long { VRType = VR::FD };
21605 enum { VMType = VM::VM1 };
21606 static const char* GetVMString() { return "1"; }
21607 };
21608 template <> struct TagToType<0x0074,0x1030> {
21609 static const char* GetVRString() { return "SQ"; }
21610 typedef VRToType<VR::SQ>::Type Type;
21611 enum : long long { VRType = VR::SQ };
21612 enum { VMType = VM::VM1 };
21613 static const char* GetVMString() { return "1"; }
21614 };
21615 template <> struct TagToType<0x0074,0x1032> {
21616 static const char* GetVRString() { return "CS"; }
21617 typedef VRToType<VR::CS>::Type Type;
21618 enum : long long { VRType = VR::CS };
21619 enum { VMType = VM::VM1 };
21620 static const char* GetVMString() { return "1"; }
21621 };
21622 template <> struct TagToType<0x0074,0x1034> {
21623 static const char* GetVRString() { return "CS"; }
21624 typedef VRToType<VR::CS>::Type Type;
21625 enum : long long { VRType = VR::CS };
21626 enum { VMType = VM::VM1 };
21627 static const char* GetVMString() { return "1"; }
21628 };
21629 template <> struct TagToType<0x0074,0x1036> {
21630 static const char* GetVRString() { return "CS"; }
21631 typedef VRToType<VR::CS>::Type Type;
21632 enum : long long { VRType = VR::CS };
21633 enum { VMType = VM::VM1 };
21634 static const char* GetVMString() { return "1"; }
21635 };
21636 template <> struct TagToType<0x0074,0x1038> {
21637 static const char* GetVRString() { return "DS"; }
21638 typedef VRToType<VR::DS>::Type Type;
21639 enum : long long { VRType = VR::DS };
21640 enum { VMType = VM::VM1 };
21641 static const char* GetVMString() { return "1"; }
21642 };
21643 template <> struct TagToType<0x0074,0x103a> {
21644 static const char* GetVRString() { return "DS"; }
21645 typedef VRToType<VR::DS>::Type Type;
21646 enum : long long { VRType = VR::DS };
21647 enum { VMType = VM::VM4 };
21648 static const char* GetVMString() { return "4"; }
21649 };
21650 template <> struct TagToType<0x0074,0x1040> {
21651 static const char* GetVRString() { return "SQ"; }
21652 typedef VRToType<VR::SQ>::Type Type;
21653 enum : long long { VRType = VR::SQ };
21654 enum { VMType = VM::VM1 };
21655 static const char* GetVMString() { return "1"; }
21656 };
21657 template <> struct TagToType<0x0074,0x1042> {
21658 static const char* GetVRString() { return "SQ"; }
21659 typedef VRToType<VR::SQ>::Type Type;
21660 enum : long long { VRType = VR::SQ };
21661 enum { VMType = VM::VM1 };
21662 static const char* GetVMString() { return "1"; }
21663 };
21664 template <> struct TagToType<0x0074,0x1044> {
21665 static const char* GetVRString() { return "SQ"; }
21666 typedef VRToType<VR::SQ>::Type Type;
21667 enum : long long { VRType = VR::SQ };
21668 enum { VMType = VM::VM1 };
21669 static const char* GetVMString() { return "1"; }
21670 };
21671 template <> struct TagToType<0x0074,0x1046> {
21672 static const char* GetVRString() { return "SQ"; }
21673 typedef VRToType<VR::SQ>::Type Type;
21674 enum : long long { VRType = VR::SQ };
21675 enum { VMType = VM::VM1 };
21676 static const char* GetVMString() { return "1"; }
21677 };
21678 template <> struct TagToType<0x0074,0x1048> {
21679 static const char* GetVRString() { return "SQ"; }
21680 typedef VRToType<VR::SQ>::Type Type;
21681 enum : long long { VRType = VR::SQ };
21682 enum { VMType = VM::VM1 };
21683 static const char* GetVMString() { return "1"; }
21684 };
21685 template <> struct TagToType<0x0074,0x104a> {
21686 static const char* GetVRString() { return "SQ"; }
21687 typedef VRToType<VR::SQ>::Type Type;
21688 enum : long long { VRType = VR::SQ };
21689 enum { VMType = VM::VM1 };
21690 static const char* GetVMString() { return "1"; }
21691 };
21692 template <> struct TagToType<0x0074,0x104c> {
21693 static const char* GetVRString() { return "SQ"; }
21694 typedef VRToType<VR::SQ>::Type Type;
21695 enum : long long { VRType = VR::SQ };
21696 enum { VMType = VM::VM1 };
21697 static const char* GetVMString() { return "1"; }
21698 };
21699 template <> struct TagToType<0x0074,0x104e> {
21700 static const char* GetVRString() { return "SQ"; }
21701 typedef VRToType<VR::SQ>::Type Type;
21702 enum : long long { VRType = VR::SQ };
21703 enum { VMType = VM::VM1 };
21704 static const char* GetVMString() { return "1"; }
21705 };
21706 template <> struct TagToType<0x0074,0x1050> {
21707 static const char* GetVRString() { return "SQ"; }
21708 typedef VRToType<VR::SQ>::Type Type;
21709 enum : long long { VRType = VR::SQ };
21710 enum { VMType = VM::VM1 };
21711 static const char* GetVMString() { return "1"; }
21712 };
21713 template <> struct TagToType<0x0074,0x1052> {
21714 static const char* GetVRString() { return "AT"; }
21715 typedef VRToType<VR::AT>::Type Type;
21716 enum : long long { VRType = VR::AT };
21717 enum { VMType = VM::VM1 };
21718 static const char* GetVMString() { return "1"; }
21719 };
21720 template <> struct TagToType<0x0074,0x1054> {
21721 static const char* GetVRString() { return "UL"; }
21722 typedef VRToType<VR::UL>::Type Type;
21723 enum : long long { VRType = VR::UL };
21724 enum { VMType = VM::VM1 };
21725 static const char* GetVMString() { return "1"; }
21726 };
21727 template <> struct TagToType<0x0074,0x1056> {
21728 static const char* GetVRString() { return "LO"; }
21729 typedef VRToType<VR::LO>::Type Type;
21730 enum : long long { VRType = VR::LO };
21731 enum { VMType = VM::VM1 };
21732 static const char* GetVMString() { return "1"; }
21733 };
21734 template <> struct TagToType<0x0074,0x1057> {
21735 static const char* GetVRString() { return "IS"; }
21736 typedef VRToType<VR::IS>::Type Type;
21737 enum : long long { VRType = VR::IS };
21738 enum { VMType = VM::VM1_n };
21739 static const char* GetVMString() { return "1-n"; }
21740 };
21741 template <> struct TagToType<0x0074,0x1200> {
21742 static const char* GetVRString() { return "CS"; }
21743 typedef VRToType<VR::CS>::Type Type;
21744 enum : long long { VRType = VR::CS };
21745 enum { VMType = VM::VM1 };
21746 static const char* GetVMString() { return "1"; }
21747 };
21748 template <> struct TagToType<0x0074,0x1202> {
21749 static const char* GetVRString() { return "LO"; }
21750 typedef VRToType<VR::LO>::Type Type;
21751 enum : long long { VRType = VR::LO };
21752 enum { VMType = VM::VM1 };
21753 static const char* GetVMString() { return "1"; }
21754 };
21755 template <> struct TagToType<0x0074,0x1204> {
21756 static const char* GetVRString() { return "LO"; }
21757 typedef VRToType<VR::LO>::Type Type;
21758 enum : long long { VRType = VR::LO };
21759 enum { VMType = VM::VM1 };
21760 static const char* GetVMString() { return "1"; }
21761 };
21762 template <> struct TagToType<0x0074,0x1210> {
21763 static const char* GetVRString() { return "SQ"; }
21764 typedef VRToType<VR::SQ>::Type Type;
21765 enum : long long { VRType = VR::SQ };
21766 enum { VMType = VM::VM1 };
21767 static const char* GetVMString() { return "1"; }
21768 };
21769 template <> struct TagToType<0x0074,0x1212> {
21770 static const char* GetVRString() { return "SQ"; }
21771 typedef VRToType<VR::SQ>::Type Type;
21772 enum : long long { VRType = VR::SQ };
21773 enum { VMType = VM::VM1 };
21774 static const char* GetVMString() { return "1"; }
21775 };
21776 template <> struct TagToType<0x0074,0x1216> {
21777 static const char* GetVRString() { return "SQ"; }
21778 typedef VRToType<VR::SQ>::Type Type;
21779 enum : long long { VRType = VR::SQ };
21780 enum { VMType = VM::VM1 };
21781 static const char* GetVMString() { return "1"; }
21782 };
21783 template <> struct TagToType<0x0074,0x1220> {
21784 static const char* GetVRString() { return "SQ"; }
21785 typedef VRToType<VR::SQ>::Type Type;
21786 enum : long long { VRType = VR::SQ };
21787 enum { VMType = VM::VM1 };
21788 static const char* GetVMString() { return "1"; }
21789 };
21790 template <> struct TagToType<0x0074,0x1222> {
21791 static const char* GetVRString() { return "LO"; }
21792 typedef VRToType<VR::LO>::Type Type;
21793 enum : long long { VRType = VR::LO };
21794 enum { VMType = VM::VM1 };
21795 static const char* GetVMString() { return "1"; }
21796 };
21797 template <> struct TagToType<0x0074,0x1224> {
21798 static const char* GetVRString() { return "SQ"; }
21799 typedef VRToType<VR::SQ>::Type Type;
21800 enum : long long { VRType = VR::SQ };
21801 enum { VMType = VM::VM1 };
21802 static const char* GetVMString() { return "1"; }
21803 };
21804 template <> struct TagToType<0x0074,0x1230> {
21805 static const char* GetVRString() { return "LO"; }
21806 typedef VRToType<VR::LO>::Type Type;
21807 enum : long long { VRType = VR::LO };
21808 enum { VMType = VM::VM1 };
21809 static const char* GetVMString() { return "1"; }
21810 };
21811 template <> struct TagToType<0x0074,0x1234> {
21812 static const char* GetVRString() { return "AE"; }
21813 typedef VRToType<VR::AE>::Type Type;
21814 enum : long long { VRType = VR::AE };
21815 enum { VMType = VM::VM1 };
21816 static const char* GetVMString() { return "1"; }
21817 };
21818 template <> struct TagToType<0x0074,0x1236> {
21819 static const char* GetVRString() { return "AE"; }
21820 typedef VRToType<VR::AE>::Type Type;
21821 enum : long long { VRType = VR::AE };
21822 enum { VMType = VM::VM1 };
21823 static const char* GetVMString() { return "1"; }
21824 };
21825 template <> struct TagToType<0x0074,0x1238> {
21826 static const char* GetVRString() { return "LT"; }
21827 typedef VRToType<VR::LT>::Type Type;
21828 enum : long long { VRType = VR::LT };
21829 enum { VMType = VM::VM1 };
21830 static const char* GetVMString() { return "1"; }
21831 };
21832 template <> struct TagToType<0x0074,0x1242> {
21833 static const char* GetVRString() { return "CS"; }
21834 typedef VRToType<VR::CS>::Type Type;
21835 enum : long long { VRType = VR::CS };
21836 enum { VMType = VM::VM1 };
21837 static const char* GetVMString() { return "1"; }
21838 };
21839 template <> struct TagToType<0x0074,0x1244> {
21840 static const char* GetVRString() { return "CS"; }
21841 typedef VRToType<VR::CS>::Type Type;
21842 enum : long long { VRType = VR::CS };
21843 enum { VMType = VM::VM1 };
21844 static const char* GetVMString() { return "1"; }
21845 };
21846 template <> struct TagToType<0x0074,0x1246> {
21847 static const char* GetVRString() { return "CS"; }
21848 typedef VRToType<VR::CS>::Type Type;
21849 enum : long long { VRType = VR::CS };
21850 enum { VMType = VM::VM1 };
21851 static const char* GetVMString() { return "1"; }
21852 };
21853 template <> struct TagToType<0x0074,0x1324> {
21854 static const char* GetVRString() { return "UL"; }
21855 typedef VRToType<VR::UL>::Type Type;
21856 enum : long long { VRType = VR::UL };
21857 enum { VMType = VM::VM1 };
21858 static const char* GetVMString() { return "1"; }
21859 };
21860 template <> struct TagToType<0x0074,0x1338> {
21861 static const char* GetVRString() { return "FD"; }
21862 typedef VRToType<VR::FD>::Type Type;
21863 enum : long long { VRType = VR::FD };
21864 enum { VMType = VM::VM1 };
21865 static const char* GetVMString() { return "1"; }
21866 };
21867 template <> struct TagToType<0x0074,0x133a> {
21868 static const char* GetVRString() { return "FD"; }
21869 typedef VRToType<VR::FD>::Type Type;
21870 enum : long long { VRType = VR::FD };
21871 enum { VMType = VM::VM4 };
21872 static const char* GetVMString() { return "4"; }
21873 };
21874 template <> struct TagToType<0x0074,0x1401> {
21875 static const char* GetVRString() { return "SQ"; }
21876 typedef VRToType<VR::SQ>::Type Type;
21877 enum : long long { VRType = VR::SQ };
21878 enum { VMType = VM::VM1 };
21879 static const char* GetVMString() { return "1"; }
21880 };
21881 template <> struct TagToType<0x0074,0x1402> {
21882 static const char* GetVRString() { return "DS"; }
21883 typedef VRToType<VR::DS>::Type Type;
21884 enum : long long { VRType = VR::DS };
21885 enum { VMType = VM::VM1 };
21886 static const char* GetVMString() { return "1"; }
21887 };
21888 template <> struct TagToType<0x0074,0x1403> {
21889 static const char* GetVRString() { return "DS"; }
21890 typedef VRToType<VR::DS>::Type Type;
21891 enum : long long { VRType = VR::DS };
21892 enum { VMType = VM::VM1 };
21893 static const char* GetVMString() { return "1"; }
21894 };
21895 template <> struct TagToType<0x0074,0x1404> {
21896 static const char* GetVRString() { return "IS"; }
21897 typedef VRToType<VR::IS>::Type Type;
21898 enum : long long { VRType = VR::IS };
21899 enum { VMType = VM::VM1 };
21900 static const char* GetVMString() { return "1"; }
21901 };
21902 template <> struct TagToType<0x0074,0x1405> {
21903 static const char* GetVRString() { return "SQ"; }
21904 typedef VRToType<VR::SQ>::Type Type;
21905 enum : long long { VRType = VR::SQ };
21906 enum { VMType = VM::VM1 };
21907 static const char* GetVMString() { return "1"; }
21908 };
21909 template <> struct TagToType<0x0074,0x1406> {
21910 static const char* GetVRString() { return "IS"; }
21911 typedef VRToType<VR::IS>::Type Type;
21912 enum : long long { VRType = VR::IS };
21913 enum { VMType = VM::VM1 };
21914 static const char* GetVMString() { return "1"; }
21915 };
21916 template <> struct TagToType<0x0074,0x1407> {
21917 static const char* GetVRString() { return "DS"; }
21918 typedef VRToType<VR::DS>::Type Type;
21919 enum : long long { VRType = VR::DS };
21920 enum { VMType = VM::VM1 };
21921 static const char* GetVMString() { return "1"; }
21922 };
21923 template <> struct TagToType<0x0074,0x1408> {
21924 static const char* GetVRString() { return "DS"; }
21925 typedef VRToType<VR::DS>::Type Type;
21926 enum : long long { VRType = VR::DS };
21927 enum { VMType = VM::VM1 };
21928 static const char* GetVMString() { return "1"; }
21929 };
21930 template <> struct TagToType<0x0074,0x1409> {
21931 static const char* GetVRString() { return "SQ"; }
21932 typedef VRToType<VR::SQ>::Type Type;
21933 enum : long long { VRType = VR::SQ };
21934 enum { VMType = VM::VM1 };
21935 static const char* GetVMString() { return "1"; }
21936 };
21937 template <> struct TagToType<0x0074,0x140a> {
21938 static const char* GetVRString() { return "CS"; }
21939 typedef VRToType<VR::CS>::Type Type;
21940 enum : long long { VRType = VR::CS };
21941 enum { VMType = VM::VM1 };
21942 static const char* GetVMString() { return "1"; }
21943 };
21944 template <> struct TagToType<0x0074,0x140b> {
21945 static const char* GetVRString() { return "LO"; }
21946 typedef VRToType<VR::LO>::Type Type;
21947 enum : long long { VRType = VR::LO };
21948 enum { VMType = VM::VM1 };
21949 static const char* GetVMString() { return "1"; }
21950 };
21951 template <> struct TagToType<0x0074,0x140c> {
21952 static const char* GetVRString() { return "IS"; }
21953 typedef VRToType<VR::IS>::Type Type;
21954 enum : long long { VRType = VR::IS };
21955 enum { VMType = VM::VM1 };
21956 static const char* GetVMString() { return "1"; }
21957 };
21958 template <> struct TagToType<0x0074,0x140d> {
21959 static const char* GetVRString() { return "SQ"; }
21960 typedef VRToType<VR::SQ>::Type Type;
21961 enum : long long { VRType = VR::SQ };
21962 enum { VMType = VM::VM1 };
21963 static const char* GetVMString() { return "1"; }
21964 };
21965 template <> struct TagToType<0x0074,0x140e> {
21966 static const char* GetVRString() { return "SQ"; }
21967 typedef VRToType<VR::SQ>::Type Type;
21968 enum : long long { VRType = VR::SQ };
21969 enum { VMType = VM::VM1 };
21970 static const char* GetVMString() { return "1"; }
21971 };
21972 template <> struct TagToType<0x0076,0x0001> {
21973 static const char* GetVRString() { return "LO"; }
21974 typedef VRToType<VR::LO>::Type Type;
21975 enum : long long { VRType = VR::LO };
21976 enum { VMType = VM::VM1 };
21977 static const char* GetVMString() { return "1"; }
21978 };
21979 template <> struct TagToType<0x0076,0x0003> {
21980 static const char* GetVRString() { return "LO"; }
21981 typedef VRToType<VR::LO>::Type Type;
21982 enum : long long { VRType = VR::LO };
21983 enum { VMType = VM::VM1 };
21984 static const char* GetVMString() { return "1"; }
21985 };
21986 template <> struct TagToType<0x0076,0x0006> {
21987 static const char* GetVRString() { return "LO"; }
21988 typedef VRToType<VR::LO>::Type Type;
21989 enum : long long { VRType = VR::LO };
21990 enum { VMType = VM::VM1 };
21991 static const char* GetVMString() { return "1"; }
21992 };
21993 template <> struct TagToType<0x0076,0x0008> {
21994 static const char* GetVRString() { return "SQ"; }
21995 typedef VRToType<VR::SQ>::Type Type;
21996 enum : long long { VRType = VR::SQ };
21997 enum { VMType = VM::VM1 };
21998 static const char* GetVMString() { return "1"; }
21999 };
22000 template <> struct TagToType<0x0076,0x000a> {
22001 static const char* GetVRString() { return "CS"; }
22002 typedef VRToType<VR::CS>::Type Type;
22003 enum : long long { VRType = VR::CS };
22004 enum { VMType = VM::VM1 };
22005 static const char* GetVMString() { return "1"; }
22006 };
22007 template <> struct TagToType<0x0076,0x000c> {
22008 static const char* GetVRString() { return "SQ"; }
22009 typedef VRToType<VR::SQ>::Type Type;
22010 enum : long long { VRType = VR::SQ };
22011 enum { VMType = VM::VM1 };
22012 static const char* GetVMString() { return "1"; }
22013 };
22014 template <> struct TagToType<0x0076,0x000e> {
22015 static const char* GetVRString() { return "SQ"; }
22016 typedef VRToType<VR::SQ>::Type Type;
22017 enum : long long { VRType = VR::SQ };
22018 enum { VMType = VM::VM1 };
22019 static const char* GetVMString() { return "1"; }
22020 };
22021 template <> struct TagToType<0x0076,0x0010> {
22022 static const char* GetVRString() { return "SQ"; }
22023 typedef VRToType<VR::SQ>::Type Type;
22024 enum : long long { VRType = VR::SQ };
22025 enum { VMType = VM::VM1 };
22026 static const char* GetVMString() { return "1"; }
22027 };
22028 template <> struct TagToType<0x0076,0x0020> {
22029 static const char* GetVRString() { return "SQ"; }
22030 typedef VRToType<VR::SQ>::Type Type;
22031 enum : long long { VRType = VR::SQ };
22032 enum { VMType = VM::VM1 };
22033 static const char* GetVMString() { return "1"; }
22034 };
22035 template <> struct TagToType<0x0076,0x0030> {
22036 static const char* GetVRString() { return "LO"; }
22037 typedef VRToType<VR::LO>::Type Type;
22038 enum : long long { VRType = VR::LO };
22039 enum { VMType = VM::VM1 };
22040 static const char* GetVMString() { return "1"; }
22041 };
22042 template <> struct TagToType<0x0076,0x0032> {
22043 static const char* GetVRString() { return "SQ"; }
22044 typedef VRToType<VR::SQ>::Type Type;
22045 enum : long long { VRType = VR::SQ };
22046 enum { VMType = VM::VM1 };
22047 static const char* GetVMString() { return "1"; }
22048 };
22049 template <> struct TagToType<0x0076,0x0034> {
22050 static const char* GetVRString() { return "CS"; }
22051 typedef VRToType<VR::CS>::Type Type;
22052 enum : long long { VRType = VR::CS };
22053 enum { VMType = VM::VM1 };
22054 static const char* GetVMString() { return "1"; }
22055 };
22056 template <> struct TagToType<0x0076,0x0036> {
22057 static const char* GetVRString() { return "CS"; }
22058 typedef VRToType<VR::CS>::Type Type;
22059 enum : long long { VRType = VR::CS };
22060 enum { VMType = VM::VM1 };
22061 static const char* GetVMString() { return "1"; }
22062 };
22063 template <> struct TagToType<0x0076,0x0038> {
22064 static const char* GetVRString() { return "CS"; }
22065 typedef VRToType<VR::CS>::Type Type;
22066 enum : long long { VRType = VR::CS };
22067 enum { VMType = VM::VM1 };
22068 static const char* GetVMString() { return "1"; }
22069 };
22070 template <> struct TagToType<0x0076,0x0040> {
22071 static const char* GetVRString() { return "SQ"; }
22072 typedef VRToType<VR::SQ>::Type Type;
22073 enum : long long { VRType = VR::SQ };
22074 enum { VMType = VM::VM1 };
22075 static const char* GetVMString() { return "1"; }
22076 };
22077 template <> struct TagToType<0x0076,0x0055> {
22078 static const char* GetVRString() { return "US"; }
22079 typedef VRToType<VR::US>::Type Type;
22080 enum : long long { VRType = VR::US };
22081 enum { VMType = VM::VM1 };
22082 static const char* GetVMString() { return "1"; }
22083 };
22084 template <> struct TagToType<0x0076,0x0060> {
22085 static const char* GetVRString() { return "SQ"; }
22086 typedef VRToType<VR::SQ>::Type Type;
22087 enum : long long { VRType = VR::SQ };
22088 enum { VMType = VM::VM1 };
22089 static const char* GetVMString() { return "1"; }
22090 };
22091 template <> struct TagToType<0x0076,0x0070> {
22092 static const char* GetVRString() { return "US"; }
22093 typedef VRToType<VR::US>::Type Type;
22094 enum : long long { VRType = VR::US };
22095 enum { VMType = VM::VM1 };
22096 static const char* GetVMString() { return "1"; }
22097 };
22098 template <> struct TagToType<0x0076,0x0080> {
22099 static const char* GetVRString() { return "US"; }
22100 typedef VRToType<VR::US>::Type Type;
22101 enum : long long { VRType = VR::US };
22102 enum { VMType = VM::VM1 };
22103 static const char* GetVMString() { return "1"; }
22104 };
22105 template <> struct TagToType<0x0076,0x0090> {
22106 static const char* GetVRString() { return "US"; }
22107 typedef VRToType<VR::US>::Type Type;
22108 enum : long long { VRType = VR::US };
22109 enum { VMType = VM::VM1 };
22110 static const char* GetVMString() { return "1"; }
22111 };
22112 template <> struct TagToType<0x0076,0x00a0> {
22113 static const char* GetVRString() { return "US"; }
22114 typedef VRToType<VR::US>::Type Type;
22115 enum : long long { VRType = VR::US };
22116 enum { VMType = VM::VM1 };
22117 static const char* GetVMString() { return "1"; }
22118 };
22119 template <> struct TagToType<0x0076,0x00b0> {
22120 static const char* GetVRString() { return "US"; }
22121 typedef VRToType<VR::US>::Type Type;
22122 enum : long long { VRType = VR::US };
22123 enum { VMType = VM::VM1 };
22124 static const char* GetVMString() { return "1"; }
22125 };
22126 template <> struct TagToType<0x0076,0x00c0> {
22127 static const char* GetVRString() { return "US"; }
22128 typedef VRToType<VR::US>::Type Type;
22129 enum : long long { VRType = VR::US };
22130 enum { VMType = VM::VM1 };
22131 static const char* GetVMString() { return "1"; }
22132 };
22133 template <> struct TagToType<0x0078,0x0001> {
22134 static const char* GetVRString() { return "LO"; }
22135 typedef VRToType<VR::LO>::Type Type;
22136 enum : long long { VRType = VR::LO };
22137 enum { VMType = VM::VM1 };
22138 static const char* GetVMString() { return "1"; }
22139 };
22140 template <> struct TagToType<0x0078,0x0010> {
22141 static const char* GetVRString() { return "ST"; }
22142 typedef VRToType<VR::ST>::Type Type;
22143 enum : long long { VRType = VR::ST };
22144 enum { VMType = VM::VM1 };
22145 static const char* GetVMString() { return "1"; }
22146 };
22147 template <> struct TagToType<0x0078,0x0020> {
22148 static const char* GetVRString() { return "LO"; }
22149 typedef VRToType<VR::LO>::Type Type;
22150 enum : long long { VRType = VR::LO };
22151 enum { VMType = VM::VM1 };
22152 static const char* GetVMString() { return "1"; }
22153 };
22154 template <> struct TagToType<0x0078,0x0024> {
22155 static const char* GetVRString() { return "LO"; }
22156 typedef VRToType<VR::LO>::Type Type;
22157 enum : long long { VRType = VR::LO };
22158 enum { VMType = VM::VM1 };
22159 static const char* GetVMString() { return "1"; }
22160 };
22161 template <> struct TagToType<0x0078,0x0026> {
22162 static const char* GetVRString() { return "SQ"; }
22163 typedef VRToType<VR::SQ>::Type Type;
22164 enum : long long { VRType = VR::SQ };
22165 enum { VMType = VM::VM1 };
22166 static const char* GetVMString() { return "1"; }
22167 };
22168 template <> struct TagToType<0x0078,0x0028> {
22169 static const char* GetVRString() { return "SQ"; }
22170 typedef VRToType<VR::SQ>::Type Type;
22171 enum : long long { VRType = VR::SQ };
22172 enum { VMType = VM::VM1 };
22173 static const char* GetVMString() { return "1"; }
22174 };
22175 template <> struct TagToType<0x0078,0x002a> {
22176 static const char* GetVRString() { return "SQ"; }
22177 typedef VRToType<VR::SQ>::Type Type;
22178 enum : long long { VRType = VR::SQ };
22179 enum { VMType = VM::VM1 };
22180 static const char* GetVMString() { return "1"; }
22181 };
22182 template <> struct TagToType<0x0078,0x002e> {
22183 static const char* GetVRString() { return "US"; }
22184 typedef VRToType<VR::US>::Type Type;
22185 enum : long long { VRType = VR::US };
22186 enum { VMType = VM::VM1 };
22187 static const char* GetVMString() { return "1"; }
22188 };
22189 template <> struct TagToType<0x0078,0x0050> {
22190 static const char* GetVRString() { return "FD"; }
22191 typedef VRToType<VR::FD>::Type Type;
22192 enum : long long { VRType = VR::FD };
22193 enum { VMType = VM::VM3 };
22194 static const char* GetVMString() { return "3"; }
22195 };
22196 template <> struct TagToType<0x0078,0x0060> {
22197 static const char* GetVRString() { return "FD"; }
22198 typedef VRToType<VR::FD>::Type Type;
22199 enum : long long { VRType = VR::FD };
22200 enum { VMType = VM::VM9 };
22201 static const char* GetVMString() { return "9"; }
22202 };
22203 template <> struct TagToType<0x0078,0x0070> {
22204 static const char* GetVRString() { return "SQ"; }
22205 typedef VRToType<VR::SQ>::Type Type;
22206 enum : long long { VRType = VR::SQ };
22207 enum { VMType = VM::VM1 };
22208 static const char* GetVMString() { return "1"; }
22209 };
22210 template <> struct TagToType<0x0078,0x0090> {
22211 static const char* GetVRString() { return "FD"; }
22212 typedef VRToType<VR::FD>::Type Type;
22213 enum : long long { VRType = VR::FD };
22214 enum { VMType = VM::VM2 };
22215 static const char* GetVMString() { return "2"; }
22216 };
22217 template <> struct TagToType<0x0078,0x00a0> {
22218 static const char* GetVRString() { return "FD"; }
22219 typedef VRToType<VR::FD>::Type Type;
22220 enum : long long { VRType = VR::FD };
22221 enum { VMType = VM::VM4 };
22222 static const char* GetVMString() { return "4"; }
22223 };
22224 template <> struct TagToType<0x0078,0x00b0> {
22225 static const char* GetVRString() { return "SQ"; }
22226 typedef VRToType<VR::SQ>::Type Type;
22227 enum : long long { VRType = VR::SQ };
22228 enum { VMType = VM::VM1 };
22229 static const char* GetVMString() { return "1"; }
22230 };
22231 template <> struct TagToType<0x0078,0x00b2> {
22232 static const char* GetVRString() { return "LO"; }
22233 typedef VRToType<VR::LO>::Type Type;
22234 enum : long long { VRType = VR::LO };
22235 enum { VMType = VM::VM1 };
22236 static const char* GetVMString() { return "1"; }
22237 };
22238 template <> struct TagToType<0x0078,0x00b4> {
22239 static const char* GetVRString() { return "SQ"; }
22240 typedef VRToType<VR::SQ>::Type Type;
22241 enum : long long { VRType = VR::SQ };
22242 enum { VMType = VM::VM1 };
22243 static const char* GetVMString() { return "1"; }
22244 };
22245 template <> struct TagToType<0x0078,0x00b6> {
22246 static const char* GetVRString() { return "US"; }
22247 typedef VRToType<VR::US>::Type Type;
22248 enum : long long { VRType = VR::US };
22249 enum { VMType = VM::VM1 };
22250 static const char* GetVMString() { return "1"; }
22251 };
22252 template <> struct TagToType<0x0078,0x00b8> {
22253 static const char* GetVRString() { return "US"; }
22254 typedef VRToType<VR::US>::Type Type;
22255 enum : long long { VRType = VR::US };
22256 enum { VMType = VM::VM1 };
22257 static const char* GetVMString() { return "1"; }
22258 };
22259 template <> struct TagToType<0x0080,0x0001> {
22260 static const char* GetVRString() { return "SQ"; }
22261 typedef VRToType<VR::SQ>::Type Type;
22262 enum : long long { VRType = VR::SQ };
22263 enum { VMType = VM::VM1 };
22264 static const char* GetVMString() { return "1"; }
22265 };
22266 template <> struct TagToType<0x0080,0x0002> {
22267 static const char* GetVRString() { return "SQ"; }
22268 typedef VRToType<VR::SQ>::Type Type;
22269 enum : long long { VRType = VR::SQ };
22270 enum { VMType = VM::VM1 };
22271 static const char* GetVMString() { return "1"; }
22272 };
22273 template <> struct TagToType<0x0080,0x0003> {
22274 static const char* GetVRString() { return "SQ"; }
22275 typedef VRToType<VR::SQ>::Type Type;
22276 enum : long long { VRType = VR::SQ };
22277 enum { VMType = VM::VM1 };
22278 static const char* GetVMString() { return "1"; }
22279 };
22280 template <> struct TagToType<0x0080,0x0004> {
22281 static const char* GetVRString() { return "FD"; }
22282 typedef VRToType<VR::FD>::Type Type;
22283 enum : long long { VRType = VR::FD };
22284 enum { VMType = VM::VM1 };
22285 static const char* GetVMString() { return "1"; }
22286 };
22287 template <> struct TagToType<0x0080,0x0005> {
22288 static const char* GetVRString() { return "FD"; }
22289 typedef VRToType<VR::FD>::Type Type;
22290 enum : long long { VRType = VR::FD };
22291 enum { VMType = VM::VM1 };
22292 static const char* GetVMString() { return "1"; }
22293 };
22294 template <> struct TagToType<0x0080,0x0006> {
22295 static const char* GetVRString() { return "US"; }
22296 typedef VRToType<VR::US>::Type Type;
22297 enum : long long { VRType = VR::US };
22298 enum { VMType = VM::VM1_n };
22299 static const char* GetVMString() { return "1-n"; }
22300 };
22301 template <> struct TagToType<0x0080,0x0007> {
22302 static const char* GetVRString() { return "US"; }
22303 typedef VRToType<VR::US>::Type Type;
22304 enum : long long { VRType = VR::US };
22305 enum { VMType = VM::VM3_3n };
22306 static const char* GetVMString() { return "3-3n"; }
22307 };
22308 template <> struct TagToType<0x0080,0x0008> {
22309 static const char* GetVRString() { return "SQ"; }
22310 typedef VRToType<VR::SQ>::Type Type;
22311 enum : long long { VRType = VR::SQ };
22312 enum { VMType = VM::VM1 };
22313 static const char* GetVMString() { return "1"; }
22314 };
22315 template <> struct TagToType<0x0080,0x0009> {
22316 static const char* GetVRString() { return "SH"; }
22317 typedef VRToType<VR::SH>::Type Type;
22318 enum : long long { VRType = VR::SH };
22319 enum { VMType = VM::VM1 };
22320 static const char* GetVMString() { return "1"; }
22321 };
22322 template <> struct TagToType<0x0080,0x0010> {
22323 static const char* GetVRString() { return "OF"; }
22324 typedef VRToType<VR::OF>::Type Type;
22325 enum : long long { VRType = VR::OF };
22326 enum { VMType = VM::VM1_n };
22327 static const char* GetVMString() { return "1-n"; }
22328 };
22329 template <> struct TagToType<0x0080,0x0011> {
22330 static const char* GetVRString() { return "OF"; }
22331 typedef VRToType<VR::OF>::Type Type;
22332 enum : long long { VRType = VR::OF };
22333 enum { VMType = VM::VM1_n };
22334 static const char* GetVMString() { return "1-n"; }
22335 };
22336 template <> struct TagToType<0x0080,0x0012> {
22337 static const char* GetVRString() { return "SQ"; }
22338 typedef VRToType<VR::SQ>::Type Type;
22339 enum : long long { VRType = VR::SQ };
22340 enum { VMType = VM::VM1 };
22341 static const char* GetVMString() { return "1"; }
22342 };
22343 template <> struct TagToType<0x0080,0x0013> {
22344 static const char* GetVRString() { return "SQ"; }
22345 typedef VRToType<VR::SQ>::Type Type;
22346 enum : long long { VRType = VR::SQ };
22347 enum { VMType = VM::VM1 };
22348 static const char* GetVMString() { return "1"; }
22349 };
22350 template <> struct TagToType<0x0082,0x0001> {
22351 static const char* GetVRString() { return "CS"; }
22352 typedef VRToType<VR::CS>::Type Type;
22353 enum : long long { VRType = VR::CS };
22354 enum { VMType = VM::VM1 };
22355 static const char* GetVMString() { return "1"; }
22356 };
22357 template <> struct TagToType<0x0082,0x0003> {
22358 static const char* GetVRString() { return "UT"; }
22359 typedef VRToType<VR::UT>::Type Type;
22360 enum : long long { VRType = VR::UT };
22361 enum { VMType = VM::VM1 };
22362 static const char* GetVMString() { return "1"; }
22363 };
22364 template <> struct TagToType<0x0082,0x0004> {
22365 static const char* GetVRString() { return "SQ"; }
22366 typedef VRToType<VR::SQ>::Type Type;
22367 enum : long long { VRType = VR::SQ };
22368 enum { VMType = VM::VM1 };
22369 static const char* GetVMString() { return "1"; }
22370 };
22371 template <> struct TagToType<0x0082,0x0005> {
22372 static const char* GetVRString() { return "SQ"; }
22373 typedef VRToType<VR::SQ>::Type Type;
22374 enum : long long { VRType = VR::SQ };
22375 enum { VMType = VM::VM1 };
22376 static const char* GetVMString() { return "1"; }
22377 };
22378 template <> struct TagToType<0x0082,0x0006> {
22379 static const char* GetVRString() { return "UL"; }
22380 typedef VRToType<VR::UL>::Type Type;
22381 enum : long long { VRType = VR::UL };
22382 enum { VMType = VM::VM1 };
22383 static const char* GetVMString() { return "1"; }
22384 };
22385 template <> struct TagToType<0x0082,0x0007> {
22386 static const char* GetVRString() { return "SQ"; }
22387 typedef VRToType<VR::SQ>::Type Type;
22388 enum : long long { VRType = VR::SQ };
22389 enum { VMType = VM::VM1 };
22390 static const char* GetVMString() { return "1"; }
22391 };
22392 template <> struct TagToType<0x0082,0x0008> {
22393 static const char* GetVRString() { return "CS"; }
22394 typedef VRToType<VR::CS>::Type Type;
22395 enum : long long { VRType = VR::CS };
22396 enum { VMType = VM::VM1 };
22397 static const char* GetVMString() { return "1"; }
22398 };
22399 template <> struct TagToType<0x0082,0x000a> {
22400 static const char* GetVRString() { return "UT"; }
22401 typedef VRToType<VR::UT>::Type Type;
22402 enum : long long { VRType = VR::UT };
22403 enum { VMType = VM::VM1 };
22404 static const char* GetVMString() { return "1"; }
22405 };
22406 template <> struct TagToType<0x0082,0x000c> {
22407 static const char* GetVRString() { return "SQ"; }
22408 typedef VRToType<VR::SQ>::Type Type;
22409 enum : long long { VRType = VR::SQ };
22410 enum { VMType = VM::VM1 };
22411 static const char* GetVMString() { return "1"; }
22412 };
22413 template <> struct TagToType<0x0082,0x0010> {
22414 static const char* GetVRString() { return "SQ"; }
22415 typedef VRToType<VR::SQ>::Type Type;
22416 enum : long long { VRType = VR::SQ };
22417 enum { VMType = VM::VM1 };
22418 static const char* GetVMString() { return "1"; }
22419 };
22420 template <> struct TagToType<0x0082,0x0016> {
22421 static const char* GetVRString() { return "LO"; }
22422 typedef VRToType<VR::LO>::Type Type;
22423 enum : long long { VRType = VR::LO };
22424 enum { VMType = VM::VM1 };
22425 static const char* GetVMString() { return "1"; }
22426 };
22427 template <> struct TagToType<0x0082,0x0017> {
22428 static const char* GetVRString() { return "SQ"; }
22429 typedef VRToType<VR::SQ>::Type Type;
22430 enum : long long { VRType = VR::SQ };
22431 enum { VMType = VM::VM1 };
22432 static const char* GetVMString() { return "1"; }
22433 };
22434 template <> struct TagToType<0x0082,0x0018> {
22435 static const char* GetVRString() { return "LO"; }
22436 typedef VRToType<VR::LO>::Type Type;
22437 enum : long long { VRType = VR::LO };
22438 enum { VMType = VM::VM1 };
22439 static const char* GetVMString() { return "1"; }
22440 };
22441 template <> struct TagToType<0x0082,0x0019> {
22442 static const char* GetVRString() { return "LO"; }
22443 typedef VRToType<VR::LO>::Type Type;
22444 enum : long long { VRType = VR::LO };
22445 enum { VMType = VM::VM1 };
22446 static const char* GetVMString() { return "1"; }
22447 };
22448 template <> struct TagToType<0x0082,0x0021> {
22449 static const char* GetVRString() { return "SQ"; }
22450 typedef VRToType<VR::SQ>::Type Type;
22451 enum : long long { VRType = VR::SQ };
22452 enum { VMType = VM::VM1 };
22453 static const char* GetVMString() { return "1"; }
22454 };
22455 template <> struct TagToType<0x0082,0x0022> {
22456 static const char* GetVRString() { return "SQ"; }
22457 typedef VRToType<VR::SQ>::Type Type;
22458 enum : long long { VRType = VR::SQ };
22459 enum { VMType = VM::VM1 };
22460 static const char* GetVMString() { return "1"; }
22461 };
22462 template <> struct TagToType<0x0082,0x0023> {
22463 static const char* GetVRString() { return "LO"; }
22464 typedef VRToType<VR::LO>::Type Type;
22465 enum : long long { VRType = VR::LO };
22466 enum { VMType = VM::VM1 };
22467 static const char* GetVMString() { return "1"; }
22468 };
22469 template <> struct TagToType<0x0082,0x0032> {
22470 static const char* GetVRString() { return "CS"; }
22471 typedef VRToType<VR::CS>::Type Type;
22472 enum : long long { VRType = VR::CS };
22473 enum { VMType = VM::VM1 };
22474 static const char* GetVMString() { return "1"; }
22475 };
22476 template <> struct TagToType<0x0082,0x0033> {
22477 static const char* GetVRString() { return "UT"; }
22478 typedef VRToType<VR::UT>::Type Type;
22479 enum : long long { VRType = VR::UT };
22480 enum { VMType = VM::VM1 };
22481 static const char* GetVMString() { return "1"; }
22482 };
22483 template <> struct TagToType<0x0082,0x0034> {
22484 static const char* GetVRString() { return "SQ"; }
22485 typedef VRToType<VR::SQ>::Type Type;
22486 enum : long long { VRType = VR::SQ };
22487 enum { VMType = VM::VM1 };
22488 static const char* GetVMString() { return "1"; }
22489 };
22490 template <> struct TagToType<0x0082,0x0035> {
22491 static const char* GetVRString() { return "SQ"; }
22492 typedef VRToType<VR::SQ>::Type Type;
22493 enum : long long { VRType = VR::SQ };
22494 enum { VMType = VM::VM1 };
22495 static const char* GetVMString() { return "1"; }
22496 };
22497 template <> struct TagToType<0x0082,0x0036> {
22498 static const char* GetVRString() { return "CS"; }
22499 typedef VRToType<VR::CS>::Type Type;
22500 enum : long long { VRType = VR::CS };
22501 enum { VMType = VM::VM1 };
22502 static const char* GetVMString() { return "1"; }
22503 };
22504 template <> struct TagToType<0x0082,0x0037> {
22505 static const char* GetVRString() { return "UT"; }
22506 typedef VRToType<VR::UT>::Type Type;
22507 enum : long long { VRType = VR::UT };
22508 enum { VMType = VM::VM1 };
22509 static const char* GetVMString() { return "1"; }
22510 };
22511 template <> struct TagToType<0x0082,0x0038> {
22512 static const char* GetVRString() { return "CS"; }
22513 typedef VRToType<VR::CS>::Type Type;
22514 enum : long long { VRType = VR::CS };
22515 enum { VMType = VM::VM1 };
22516 static const char* GetVMString() { return "1"; }
22517 };
22518 template <> struct TagToType<0x0088,0x0130> {
22519 static const char* GetVRString() { return "SH"; }
22520 typedef VRToType<VR::SH>::Type Type;
22521 enum : long long { VRType = VR::SH };
22522 enum { VMType = VM::VM1 };
22523 static const char* GetVMString() { return "1"; }
22524 };
22525 template <> struct TagToType<0x0088,0x0140> {
22526 static const char* GetVRString() { return "UI"; }
22527 typedef VRToType<VR::UI>::Type Type;
22528 enum : long long { VRType = VR::UI };
22529 enum { VMType = VM::VM1 };
22530 static const char* GetVMString() { return "1"; }
22531 };
22532 template <> struct TagToType<0x0088,0x0200> {
22533 static const char* GetVRString() { return "SQ"; }
22534 typedef VRToType<VR::SQ>::Type Type;
22535 enum : long long { VRType = VR::SQ };
22536 enum { VMType = VM::VM1 };
22537 static const char* GetVMString() { return "1"; }
22538 };
22539 template <> struct TagToType<0x0088,0x0904> {
22540 static const char* GetVRString() { return "LO"; }
22541 typedef VRToType<VR::LO>::Type Type;
22542 enum : long long { VRType = VR::LO };
22543 enum { VMType = VM::VM1 };
22544 static const char* GetVMString() { return "1"; }
22545 };
22546 template <> struct TagToType<0x0088,0x0906> {
22547 static const char* GetVRString() { return "ST"; }
22548 typedef VRToType<VR::ST>::Type Type;
22549 enum : long long { VRType = VR::ST };
22550 enum { VMType = VM::VM1 };
22551 static const char* GetVMString() { return "1"; }
22552 };
22553 template <> struct TagToType<0x0088,0x0910> {
22554 static const char* GetVRString() { return "LO"; }
22555 typedef VRToType<VR::LO>::Type Type;
22556 enum : long long { VRType = VR::LO };
22557 enum { VMType = VM::VM1 };
22558 static const char* GetVMString() { return "1"; }
22559 };
22560 template <> struct TagToType<0x0088,0x0912> {
22561 static const char* GetVRString() { return "LO"; }
22562 typedef VRToType<VR::LO>::Type Type;
22563 enum : long long { VRType = VR::LO };
22564 enum { VMType = VM::VM1_32 };
22565 static const char* GetVMString() { return "1-32"; }
22566 };
22567 template <> struct TagToType<0x0100,0x0410> {
22568 static const char* GetVRString() { return "CS"; }
22569 typedef VRToType<VR::CS>::Type Type;
22570 enum : long long { VRType = VR::CS };
22571 enum { VMType = VM::VM1 };
22572 static const char* GetVMString() { return "1"; }
22573 };
22574 template <> struct TagToType<0x0100,0x0420> {
22575 static const char* GetVRString() { return "DT"; }
22576 typedef VRToType<VR::DT>::Type Type;
22577 enum : long long { VRType = VR::DT };
22578 enum { VMType = VM::VM1 };
22579 static const char* GetVMString() { return "1"; }
22580 };
22581 template <> struct TagToType<0x0100,0x0424> {
22582 static const char* GetVRString() { return "LT"; }
22583 typedef VRToType<VR::LT>::Type Type;
22584 enum : long long { VRType = VR::LT };
22585 enum { VMType = VM::VM1 };
22586 static const char* GetVMString() { return "1"; }
22587 };
22588 template <> struct TagToType<0x0100,0x0426> {
22589 static const char* GetVRString() { return "LO"; }
22590 typedef VRToType<VR::LO>::Type Type;
22591 enum : long long { VRType = VR::LO };
22592 enum { VMType = VM::VM1 };
22593 static const char* GetVMString() { return "1"; }
22594 };
22595 template <> struct TagToType<0x0400,0x0005> {
22596 static const char* GetVRString() { return "US"; }
22597 typedef VRToType<VR::US>::Type Type;
22598 enum : long long { VRType = VR::US };
22599 enum { VMType = VM::VM1 };
22600 static const char* GetVMString() { return "1"; }
22601 };
22602 template <> struct TagToType<0x0400,0x0010> {
22603 static const char* GetVRString() { return "UI"; }
22604 typedef VRToType<VR::UI>::Type Type;
22605 enum : long long { VRType = VR::UI };
22606 enum { VMType = VM::VM1 };
22607 static const char* GetVMString() { return "1"; }
22608 };
22609 template <> struct TagToType<0x0400,0x0015> {
22610 static const char* GetVRString() { return "CS"; }
22611 typedef VRToType<VR::CS>::Type Type;
22612 enum : long long { VRType = VR::CS };
22613 enum { VMType = VM::VM1 };
22614 static const char* GetVMString() { return "1"; }
22615 };
22616 template <> struct TagToType<0x0400,0x0020> {
22617 static const char* GetVRString() { return "AT"; }
22618 typedef VRToType<VR::AT>::Type Type;
22619 enum : long long { VRType = VR::AT };
22620 enum { VMType = VM::VM1_n };
22621 static const char* GetVMString() { return "1-n"; }
22622 };
22623 template <> struct TagToType<0x0400,0x0100> {
22624 static const char* GetVRString() { return "UI"; }
22625 typedef VRToType<VR::UI>::Type Type;
22626 enum : long long { VRType = VR::UI };
22627 enum { VMType = VM::VM1 };
22628 static const char* GetVMString() { return "1"; }
22629 };
22630 template <> struct TagToType<0x0400,0x0105> {
22631 static const char* GetVRString() { return "DT"; }
22632 typedef VRToType<VR::DT>::Type Type;
22633 enum : long long { VRType = VR::DT };
22634 enum { VMType = VM::VM1 };
22635 static const char* GetVMString() { return "1"; }
22636 };
22637 template <> struct TagToType<0x0400,0x0110> {
22638 static const char* GetVRString() { return "CS"; }
22639 typedef VRToType<VR::CS>::Type Type;
22640 enum : long long { VRType = VR::CS };
22641 enum { VMType = VM::VM1 };
22642 static const char* GetVMString() { return "1"; }
22643 };
22644 template <> struct TagToType<0x0400,0x0115> {
22645 static const char* GetVRString() { return "OB"; }
22646 typedef VRToType<VR::OB>::Type Type;
22647 enum : long long { VRType = VR::OB };
22648 enum { VMType = VM::VM1 };
22649 static const char* GetVMString() { return "1"; }
22650 };
22651 template <> struct TagToType<0x0400,0x0120> {
22652 static const char* GetVRString() { return "OB"; }
22653 typedef VRToType<VR::OB>::Type Type;
22654 enum : long long { VRType = VR::OB };
22655 enum { VMType = VM::VM1 };
22656 static const char* GetVMString() { return "1"; }
22657 };
22658 template <> struct TagToType<0x0400,0x0305> {
22659 static const char* GetVRString() { return "CS"; }
22660 typedef VRToType<VR::CS>::Type Type;
22661 enum : long long { VRType = VR::CS };
22662 enum { VMType = VM::VM1 };
22663 static const char* GetVMString() { return "1"; }
22664 };
22665 template <> struct TagToType<0x0400,0x0310> {
22666 static const char* GetVRString() { return "OB"; }
22667 typedef VRToType<VR::OB>::Type Type;
22668 enum : long long { VRType = VR::OB };
22669 enum { VMType = VM::VM1 };
22670 static const char* GetVMString() { return "1"; }
22671 };
22672 template <> struct TagToType<0x0400,0x0315> {
22673 static const char* GetVRString() { return "FL"; }
22674 typedef VRToType<VR::FL>::Type Type;
22675 enum : long long { VRType = VR::FL };
22676 enum { VMType = VM::VM1 };
22677 static const char* GetVMString() { return "1"; }
22678 };
22679 template <> struct TagToType<0x0400,0x0401> {
22680 static const char* GetVRString() { return "SQ"; }
22681 typedef VRToType<VR::SQ>::Type Type;
22682 enum : long long { VRType = VR::SQ };
22683 enum { VMType = VM::VM1 };
22684 static const char* GetVMString() { return "1"; }
22685 };
22686 template <> struct TagToType<0x0400,0x0402> {
22687 static const char* GetVRString() { return "SQ"; }
22688 typedef VRToType<VR::SQ>::Type Type;
22689 enum : long long { VRType = VR::SQ };
22690 enum { VMType = VM::VM1 };
22691 static const char* GetVMString() { return "1"; }
22692 };
22693 template <> struct TagToType<0x0400,0x0403> {
22694 static const char* GetVRString() { return "SQ"; }
22695 typedef VRToType<VR::SQ>::Type Type;
22696 enum : long long { VRType = VR::SQ };
22697 enum { VMType = VM::VM1 };
22698 static const char* GetVMString() { return "1"; }
22699 };
22700 template <> struct TagToType<0x0400,0x0404> {
22701 static const char* GetVRString() { return "OB"; }
22702 typedef VRToType<VR::OB>::Type Type;
22703 enum : long long { VRType = VR::OB };
22704 enum { VMType = VM::VM1 };
22705 static const char* GetVMString() { return "1"; }
22706 };
22707 template <> struct TagToType<0x0400,0x0500> {
22708 static const char* GetVRString() { return "SQ"; }
22709 typedef VRToType<VR::SQ>::Type Type;
22710 enum : long long { VRType = VR::SQ };
22711 enum { VMType = VM::VM1 };
22712 static const char* GetVMString() { return "1"; }
22713 };
22714 template <> struct TagToType<0x0400,0x0510> {
22715 static const char* GetVRString() { return "UI"; }
22716 typedef VRToType<VR::UI>::Type Type;
22717 enum : long long { VRType = VR::UI };
22718 enum { VMType = VM::VM1 };
22719 static const char* GetVMString() { return "1"; }
22720 };
22721 template <> struct TagToType<0x0400,0x0520> {
22722 static const char* GetVRString() { return "OB"; }
22723 typedef VRToType<VR::OB>::Type Type;
22724 enum : long long { VRType = VR::OB };
22725 enum { VMType = VM::VM1 };
22726 static const char* GetVMString() { return "1"; }
22727 };
22728 template <> struct TagToType<0x0400,0x0550> {
22729 static const char* GetVRString() { return "SQ"; }
22730 typedef VRToType<VR::SQ>::Type Type;
22731 enum : long long { VRType = VR::SQ };
22732 enum { VMType = VM::VM1 };
22733 static const char* GetVMString() { return "1"; }
22734 };
22735 template <> struct TagToType<0x0400,0x0561> {
22736 static const char* GetVRString() { return "SQ"; }
22737 typedef VRToType<VR::SQ>::Type Type;
22738 enum : long long { VRType = VR::SQ };
22739 enum { VMType = VM::VM1 };
22740 static const char* GetVMString() { return "1"; }
22741 };
22742 template <> struct TagToType<0x0400,0x0562> {
22743 static const char* GetVRString() { return "DT"; }
22744 typedef VRToType<VR::DT>::Type Type;
22745 enum : long long { VRType = VR::DT };
22746 enum { VMType = VM::VM1 };
22747 static const char* GetVMString() { return "1"; }
22748 };
22749 template <> struct TagToType<0x0400,0x0563> {
22750 static const char* GetVRString() { return "LO"; }
22751 typedef VRToType<VR::LO>::Type Type;
22752 enum : long long { VRType = VR::LO };
22753 enum { VMType = VM::VM1 };
22754 static const char* GetVMString() { return "1"; }
22755 };
22756 template <> struct TagToType<0x0400,0x0564> {
22757 static const char* GetVRString() { return "LO"; }
22758 typedef VRToType<VR::LO>::Type Type;
22759 enum : long long { VRType = VR::LO };
22760 enum { VMType = VM::VM1 };
22761 static const char* GetVMString() { return "1"; }
22762 };
22763 template <> struct TagToType<0x0400,0x0565> {
22764 static const char* GetVRString() { return "CS"; }
22765 typedef VRToType<VR::CS>::Type Type;
22766 enum : long long { VRType = VR::CS };
22767 enum { VMType = VM::VM1 };
22768 static const char* GetVMString() { return "1"; }
22769 };
22770 template <> struct TagToType<0x2000,0x0010> {
22771 static const char* GetVRString() { return "IS"; }
22772 typedef VRToType<VR::IS>::Type Type;
22773 enum : long long { VRType = VR::IS };
22774 enum { VMType = VM::VM1 };
22775 static const char* GetVMString() { return "1"; }
22776 };
22777 template <> struct TagToType<0x2000,0x001e> {
22778 static const char* GetVRString() { return "SQ"; }
22779 typedef VRToType<VR::SQ>::Type Type;
22780 enum : long long { VRType = VR::SQ };
22781 enum { VMType = VM::VM1 };
22782 static const char* GetVMString() { return "1"; }
22783 };
22784 template <> struct TagToType<0x2000,0x0020> {
22785 static const char* GetVRString() { return "CS"; }
22786 typedef VRToType<VR::CS>::Type Type;
22787 enum : long long { VRType = VR::CS };
22788 enum { VMType = VM::VM1 };
22789 static const char* GetVMString() { return "1"; }
22790 };
22791 template <> struct TagToType<0x2000,0x0030> {
22792 static const char* GetVRString() { return "CS"; }
22793 typedef VRToType<VR::CS>::Type Type;
22794 enum : long long { VRType = VR::CS };
22795 enum { VMType = VM::VM1 };
22796 static const char* GetVMString() { return "1"; }
22797 };
22798 template <> struct TagToType<0x2000,0x0040> {
22799 static const char* GetVRString() { return "CS"; }
22800 typedef VRToType<VR::CS>::Type Type;
22801 enum : long long { VRType = VR::CS };
22802 enum { VMType = VM::VM1 };
22803 static const char* GetVMString() { return "1"; }
22804 };
22805 template <> struct TagToType<0x2000,0x0050> {
22806 static const char* GetVRString() { return "LO"; }
22807 typedef VRToType<VR::LO>::Type Type;
22808 enum : long long { VRType = VR::LO };
22809 enum { VMType = VM::VM1 };
22810 static const char* GetVMString() { return "1"; }
22811 };
22812 template <> struct TagToType<0x2000,0x0060> {
22813 static const char* GetVRString() { return "IS"; }
22814 typedef VRToType<VR::IS>::Type Type;
22815 enum : long long { VRType = VR::IS };
22816 enum { VMType = VM::VM1 };
22817 static const char* GetVMString() { return "1"; }
22818 };
22819 template <> struct TagToType<0x2000,0x0061> {
22820 static const char* GetVRString() { return "IS"; }
22821 typedef VRToType<VR::IS>::Type Type;
22822 enum : long long { VRType = VR::IS };
22823 enum { VMType = VM::VM1 };
22824 static const char* GetVMString() { return "1"; }
22825 };
22826 template <> struct TagToType<0x2000,0x0062> {
22827 static const char* GetVRString() { return "CS"; }
22828 typedef VRToType<VR::CS>::Type Type;
22829 enum : long long { VRType = VR::CS };
22830 enum { VMType = VM::VM1 };
22831 static const char* GetVMString() { return "1"; }
22832 };
22833 template <> struct TagToType<0x2000,0x0063> {
22834 static const char* GetVRString() { return "CS"; }
22835 typedef VRToType<VR::CS>::Type Type;
22836 enum : long long { VRType = VR::CS };
22837 enum { VMType = VM::VM1 };
22838 static const char* GetVMString() { return "1"; }
22839 };
22840 template <> struct TagToType<0x2000,0x0065> {
22841 static const char* GetVRString() { return "CS"; }
22842 typedef VRToType<VR::CS>::Type Type;
22843 enum : long long { VRType = VR::CS };
22844 enum { VMType = VM::VM1 };
22845 static const char* GetVMString() { return "1"; }
22846 };
22847 template <> struct TagToType<0x2000,0x0067> {
22848 static const char* GetVRString() { return "CS"; }
22849 typedef VRToType<VR::CS>::Type Type;
22850 enum : long long { VRType = VR::CS };
22851 enum { VMType = VM::VM1 };
22852 static const char* GetVMString() { return "1"; }
22853 };
22854 template <> struct TagToType<0x2000,0x0069> {
22855 static const char* GetVRString() { return "CS"; }
22856 typedef VRToType<VR::CS>::Type Type;
22857 enum : long long { VRType = VR::CS };
22858 enum { VMType = VM::VM1 };
22859 static const char* GetVMString() { return "1"; }
22860 };
22861 template <> struct TagToType<0x2000,0x006a> {
22862 static const char* GetVRString() { return "CS"; }
22863 typedef VRToType<VR::CS>::Type Type;
22864 enum : long long { VRType = VR::CS };
22865 enum { VMType = VM::VM1 };
22866 static const char* GetVMString() { return "1"; }
22867 };
22868 template <> struct TagToType<0x2000,0x00a0> {
22869 static const char* GetVRString() { return "US"; }
22870 typedef VRToType<VR::US>::Type Type;
22871 enum : long long { VRType = VR::US };
22872 enum { VMType = VM::VM1 };
22873 static const char* GetVMString() { return "1"; }
22874 };
22875 template <> struct TagToType<0x2000,0x00a1> {
22876 static const char* GetVRString() { return "US"; }
22877 typedef VRToType<VR::US>::Type Type;
22878 enum : long long { VRType = VR::US };
22879 enum { VMType = VM::VM1 };
22880 static const char* GetVMString() { return "1"; }
22881 };
22882 template <> struct TagToType<0x2000,0x00a2> {
22883 static const char* GetVRString() { return "SQ"; }
22884 typedef VRToType<VR::SQ>::Type Type;
22885 enum : long long { VRType = VR::SQ };
22886 enum { VMType = VM::VM1 };
22887 static const char* GetVMString() { return "1"; }
22888 };
22889 template <> struct TagToType<0x2000,0x00a4> {
22890 static const char* GetVRString() { return "SQ"; }
22891 typedef VRToType<VR::SQ>::Type Type;
22892 enum : long long { VRType = VR::SQ };
22893 enum { VMType = VM::VM1 };
22894 static const char* GetVMString() { return "1"; }
22895 };
22896 template <> struct TagToType<0x2000,0x00a8> {
22897 static const char* GetVRString() { return "SQ"; }
22898 typedef VRToType<VR::SQ>::Type Type;
22899 enum : long long { VRType = VR::SQ };
22900 enum { VMType = VM::VM1 };
22901 static const char* GetVMString() { return "1"; }
22902 };
22903 template <> struct TagToType<0x2000,0x0500> {
22904 static const char* GetVRString() { return "SQ"; }
22905 typedef VRToType<VR::SQ>::Type Type;
22906 enum : long long { VRType = VR::SQ };
22907 enum { VMType = VM::VM1 };
22908 static const char* GetVMString() { return "1"; }
22909 };
22910 template <> struct TagToType<0x2000,0x0510> {
22911 static const char* GetVRString() { return "SQ"; }
22912 typedef VRToType<VR::SQ>::Type Type;
22913 enum : long long { VRType = VR::SQ };
22914 enum { VMType = VM::VM1 };
22915 static const char* GetVMString() { return "1"; }
22916 };
22917 template <> struct TagToType<0x2010,0x0010> {
22918 static const char* GetVRString() { return "ST"; }
22919 typedef VRToType<VR::ST>::Type Type;
22920 enum : long long { VRType = VR::ST };
22921 enum { VMType = VM::VM1 };
22922 static const char* GetVMString() { return "1"; }
22923 };
22924 template <> struct TagToType<0x2010,0x0030> {
22925 static const char* GetVRString() { return "CS"; }
22926 typedef VRToType<VR::CS>::Type Type;
22927 enum : long long { VRType = VR::CS };
22928 enum { VMType = VM::VM1 };
22929 static const char* GetVMString() { return "1"; }
22930 };
22931 template <> struct TagToType<0x2010,0x0040> {
22932 static const char* GetVRString() { return "CS"; }
22933 typedef VRToType<VR::CS>::Type Type;
22934 enum : long long { VRType = VR::CS };
22935 enum { VMType = VM::VM1 };
22936 static const char* GetVMString() { return "1"; }
22937 };
22938 template <> struct TagToType<0x2010,0x0050> {
22939 static const char* GetVRString() { return "CS"; }
22940 typedef VRToType<VR::CS>::Type Type;
22941 enum : long long { VRType = VR::CS };
22942 enum { VMType = VM::VM1 };
22943 static const char* GetVMString() { return "1"; }
22944 };
22945 template <> struct TagToType<0x2010,0x0052> {
22946 static const char* GetVRString() { return "CS"; }
22947 typedef VRToType<VR::CS>::Type Type;
22948 enum : long long { VRType = VR::CS };
22949 enum { VMType = VM::VM1 };
22950 static const char* GetVMString() { return "1"; }
22951 };
22952 template <> struct TagToType<0x2010,0x0054> {
22953 static const char* GetVRString() { return "CS"; }
22954 typedef VRToType<VR::CS>::Type Type;
22955 enum : long long { VRType = VR::CS };
22956 enum { VMType = VM::VM1 };
22957 static const char* GetVMString() { return "1"; }
22958 };
22959 template <> struct TagToType<0x2010,0x0060> {
22960 static const char* GetVRString() { return "CS"; }
22961 typedef VRToType<VR::CS>::Type Type;
22962 enum : long long { VRType = VR::CS };
22963 enum { VMType = VM::VM1 };
22964 static const char* GetVMString() { return "1"; }
22965 };
22966 template <> struct TagToType<0x2010,0x0080> {
22967 static const char* GetVRString() { return "CS"; }
22968 typedef VRToType<VR::CS>::Type Type;
22969 enum : long long { VRType = VR::CS };
22970 enum { VMType = VM::VM1 };
22971 static const char* GetVMString() { return "1"; }
22972 };
22973 template <> struct TagToType<0x2010,0x00a6> {
22974 static const char* GetVRString() { return "CS"; }
22975 typedef VRToType<VR::CS>::Type Type;
22976 enum : long long { VRType = VR::CS };
22977 enum { VMType = VM::VM1 };
22978 static const char* GetVMString() { return "1"; }
22979 };
22980 template <> struct TagToType<0x2010,0x00a7> {
22981 static const char* GetVRString() { return "CS"; }
22982 typedef VRToType<VR::CS>::Type Type;
22983 enum : long long { VRType = VR::CS };
22984 enum { VMType = VM::VM1_n };
22985 static const char* GetVMString() { return "1-n"; }
22986 };
22987 template <> struct TagToType<0x2010,0x00a8> {
22988 static const char* GetVRString() { return "CS"; }
22989 typedef VRToType<VR::CS>::Type Type;
22990 enum : long long { VRType = VR::CS };
22991 enum { VMType = VM::VM1 };
22992 static const char* GetVMString() { return "1"; }
22993 };
22994 template <> struct TagToType<0x2010,0x00a9> {
22995 static const char* GetVRString() { return "CS"; }
22996 typedef VRToType<VR::CS>::Type Type;
22997 enum : long long { VRType = VR::CS };
22998 enum { VMType = VM::VM1_n };
22999 static const char* GetVMString() { return "1-n"; }
23000 };
23001 template <> struct TagToType<0x2010,0x0100> {
23002 static const char* GetVRString() { return "CS"; }
23003 typedef VRToType<VR::CS>::Type Type;
23004 enum : long long { VRType = VR::CS };
23005 enum { VMType = VM::VM1 };
23006 static const char* GetVMString() { return "1"; }
23007 };
23008 template <> struct TagToType<0x2010,0x0110> {
23009 static const char* GetVRString() { return "CS"; }
23010 typedef VRToType<VR::CS>::Type Type;
23011 enum : long long { VRType = VR::CS };
23012 enum { VMType = VM::VM1 };
23013 static const char* GetVMString() { return "1"; }
23014 };
23015 template <> struct TagToType<0x2010,0x0120> {
23016 static const char* GetVRString() { return "US"; }
23017 typedef VRToType<VR::US>::Type Type;
23018 enum : long long { VRType = VR::US };
23019 enum { VMType = VM::VM1 };
23020 static const char* GetVMString() { return "1"; }
23021 };
23022 template <> struct TagToType<0x2010,0x0130> {
23023 static const char* GetVRString() { return "US"; }
23024 typedef VRToType<VR::US>::Type Type;
23025 enum : long long { VRType = VR::US };
23026 enum { VMType = VM::VM1 };
23027 static const char* GetVMString() { return "1"; }
23028 };
23029 template <> struct TagToType<0x2010,0x0140> {
23030 static const char* GetVRString() { return "CS"; }
23031 typedef VRToType<VR::CS>::Type Type;
23032 enum : long long { VRType = VR::CS };
23033 enum { VMType = VM::VM1 };
23034 static const char* GetVMString() { return "1"; }
23035 };
23036 template <> struct TagToType<0x2010,0x0150> {
23037 static const char* GetVRString() { return "ST"; }
23038 typedef VRToType<VR::ST>::Type Type;
23039 enum : long long { VRType = VR::ST };
23040 enum { VMType = VM::VM1 };
23041 static const char* GetVMString() { return "1"; }
23042 };
23043 template <> struct TagToType<0x2010,0x0152> {
23044 static const char* GetVRString() { return "LT"; }
23045 typedef VRToType<VR::LT>::Type Type;
23046 enum : long long { VRType = VR::LT };
23047 enum { VMType = VM::VM1 };
23048 static const char* GetVMString() { return "1"; }
23049 };
23050 template <> struct TagToType<0x2010,0x0154> {
23051 static const char* GetVRString() { return "IS"; }
23052 typedef VRToType<VR::IS>::Type Type;
23053 enum : long long { VRType = VR::IS };
23054 enum { VMType = VM::VM1 };
23055 static const char* GetVMString() { return "1"; }
23056 };
23057 template <> struct TagToType<0x2010,0x015e> {
23058 static const char* GetVRString() { return "US"; }
23059 typedef VRToType<VR::US>::Type Type;
23060 enum : long long { VRType = VR::US };
23061 enum { VMType = VM::VM1 };
23062 static const char* GetVMString() { return "1"; }
23063 };
23064 template <> struct TagToType<0x2010,0x0160> {
23065 static const char* GetVRString() { return "US"; }
23066 typedef VRToType<VR::US>::Type Type;
23067 enum : long long { VRType = VR::US };
23068 enum { VMType = VM::VM1 };
23069 static const char* GetVMString() { return "1"; }
23070 };
23071 template <> struct TagToType<0x2010,0x0376> {
23072 static const char* GetVRString() { return "DS"; }
23073 typedef VRToType<VR::DS>::Type Type;
23074 enum : long long { VRType = VR::DS };
23075 enum { VMType = VM::VM2 };
23076 static const char* GetVMString() { return "2"; }
23077 };
23078 template <> struct TagToType<0x2010,0x0500> {
23079 static const char* GetVRString() { return "SQ"; }
23080 typedef VRToType<VR::SQ>::Type Type;
23081 enum : long long { VRType = VR::SQ };
23082 enum { VMType = VM::VM1 };
23083 static const char* GetVMString() { return "1"; }
23084 };
23085 template <> struct TagToType<0x2010,0x0510> {
23086 static const char* GetVRString() { return "SQ"; }
23087 typedef VRToType<VR::SQ>::Type Type;
23088 enum : long long { VRType = VR::SQ };
23089 enum { VMType = VM::VM1 };
23090 static const char* GetVMString() { return "1"; }
23091 };
23092 template <> struct TagToType<0x2010,0x0520> {
23093 static const char* GetVRString() { return "SQ"; }
23094 typedef VRToType<VR::SQ>::Type Type;
23095 enum : long long { VRType = VR::SQ };
23096 enum { VMType = VM::VM1 };
23097 static const char* GetVMString() { return "1"; }
23098 };
23099 template <> struct TagToType<0x2020,0x0010> {
23100 static const char* GetVRString() { return "US"; }
23101 typedef VRToType<VR::US>::Type Type;
23102 enum : long long { VRType = VR::US };
23103 enum { VMType = VM::VM1 };
23104 static const char* GetVMString() { return "1"; }
23105 };
23106 template <> struct TagToType<0x2020,0x0020> {
23107 static const char* GetVRString() { return "CS"; }
23108 typedef VRToType<VR::CS>::Type Type;
23109 enum : long long { VRType = VR::CS };
23110 enum { VMType = VM::VM1 };
23111 static const char* GetVMString() { return "1"; }
23112 };
23113 template <> struct TagToType<0x2020,0x0030> {
23114 static const char* GetVRString() { return "DS"; }
23115 typedef VRToType<VR::DS>::Type Type;
23116 enum : long long { VRType = VR::DS };
23117 enum { VMType = VM::VM1 };
23118 static const char* GetVMString() { return "1"; }
23119 };
23120 template <> struct TagToType<0x2020,0x0040> {
23121 static const char* GetVRString() { return "CS"; }
23122 typedef VRToType<VR::CS>::Type Type;
23123 enum : long long { VRType = VR::CS };
23124 enum { VMType = VM::VM1 };
23125 static const char* GetVMString() { return "1"; }
23126 };
23127 template <> struct TagToType<0x2020,0x0050> {
23128 static const char* GetVRString() { return "CS"; }
23129 typedef VRToType<VR::CS>::Type Type;
23130 enum : long long { VRType = VR::CS };
23131 enum { VMType = VM::VM1 };
23132 static const char* GetVMString() { return "1"; }
23133 };
23134 template <> struct TagToType<0x2020,0x00a0> {
23135 static const char* GetVRString() { return "CS"; }
23136 typedef VRToType<VR::CS>::Type Type;
23137 enum : long long { VRType = VR::CS };
23138 enum { VMType = VM::VM1 };
23139 static const char* GetVMString() { return "1"; }
23140 };
23141 template <> struct TagToType<0x2020,0x00a2> {
23142 static const char* GetVRString() { return "CS"; }
23143 typedef VRToType<VR::CS>::Type Type;
23144 enum : long long { VRType = VR::CS };
23145 enum { VMType = VM::VM1 };
23146 static const char* GetVMString() { return "1"; }
23147 };
23148 template <> struct TagToType<0x2020,0x0110> {
23149 static const char* GetVRString() { return "SQ"; }
23150 typedef VRToType<VR::SQ>::Type Type;
23151 enum : long long { VRType = VR::SQ };
23152 enum { VMType = VM::VM1 };
23153 static const char* GetVMString() { return "1"; }
23154 };
23155 template <> struct TagToType<0x2020,0x0111> {
23156 static const char* GetVRString() { return "SQ"; }
23157 typedef VRToType<VR::SQ>::Type Type;
23158 enum : long long { VRType = VR::SQ };
23159 enum { VMType = VM::VM1 };
23160 static const char* GetVMString() { return "1"; }
23161 };
23162 template <> struct TagToType<0x2020,0x0130> {
23163 static const char* GetVRString() { return "SQ"; }
23164 typedef VRToType<VR::SQ>::Type Type;
23165 enum : long long { VRType = VR::SQ };
23166 enum { VMType = VM::VM1 };
23167 static const char* GetVMString() { return "1"; }
23168 };
23169 template <> struct TagToType<0x2020,0x0140> {
23170 static const char* GetVRString() { return "SQ"; }
23171 typedef VRToType<VR::SQ>::Type Type;
23172 enum : long long { VRType = VR::SQ };
23173 enum { VMType = VM::VM1 };
23174 static const char* GetVMString() { return "1"; }
23175 };
23176 template <> struct TagToType<0x2030,0x0010> {
23177 static const char* GetVRString() { return "US"; }
23178 typedef VRToType<VR::US>::Type Type;
23179 enum : long long { VRType = VR::US };
23180 enum { VMType = VM::VM1 };
23181 static const char* GetVMString() { return "1"; }
23182 };
23183 template <> struct TagToType<0x2030,0x0020> {
23184 static const char* GetVRString() { return "LO"; }
23185 typedef VRToType<VR::LO>::Type Type;
23186 enum : long long { VRType = VR::LO };
23187 enum { VMType = VM::VM1 };
23188 static const char* GetVMString() { return "1"; }
23189 };
23190 template <> struct TagToType<0x2040,0x0010> {
23191 static const char* GetVRString() { return "SQ"; }
23192 typedef VRToType<VR::SQ>::Type Type;
23193 enum : long long { VRType = VR::SQ };
23194 enum { VMType = VM::VM1 };
23195 static const char* GetVMString() { return "1"; }
23196 };
23197 template <> struct TagToType<0x2040,0x0011> {
23198 static const char* GetVRString() { return "US"; }
23199 typedef VRToType<VR::US>::Type Type;
23200 enum : long long { VRType = VR::US };
23201 enum { VMType = VM::VM1_99 };
23202 static const char* GetVMString() { return "1-99"; }
23203 };
23204 template <> struct TagToType<0x2040,0x0020> {
23205 static const char* GetVRString() { return "SQ"; }
23206 typedef VRToType<VR::SQ>::Type Type;
23207 enum : long long { VRType = VR::SQ };
23208 enum { VMType = VM::VM1 };
23209 static const char* GetVMString() { return "1"; }
23210 };
23211 template <> struct TagToType<0x2040,0x0060> {
23212 static const char* GetVRString() { return "CS"; }
23213 typedef VRToType<VR::CS>::Type Type;
23214 enum : long long { VRType = VR::CS };
23215 enum { VMType = VM::VM1 };
23216 static const char* GetVMString() { return "1"; }
23217 };
23218 template <> struct TagToType<0x2040,0x0070> {
23219 static const char* GetVRString() { return "CS"; }
23220 typedef VRToType<VR::CS>::Type Type;
23221 enum : long long { VRType = VR::CS };
23222 enum { VMType = VM::VM1 };
23223 static const char* GetVMString() { return "1"; }
23224 };
23225 template <> struct TagToType<0x2040,0x0072> {
23226 static const char* GetVRString() { return "CS"; }
23227 typedef VRToType<VR::CS>::Type Type;
23228 enum : long long { VRType = VR::CS };
23229 enum { VMType = VM::VM1 };
23230 static const char* GetVMString() { return "1"; }
23231 };
23232 template <> struct TagToType<0x2040,0x0074> {
23233 static const char* GetVRString() { return "US"; }
23234 typedef VRToType<VR::US>::Type Type;
23235 enum : long long { VRType = VR::US };
23236 enum { VMType = VM::VM1 };
23237 static const char* GetVMString() { return "1"; }
23238 };
23239 template <> struct TagToType<0x2040,0x0080> {
23240 static const char* GetVRString() { return "CS"; }
23241 typedef VRToType<VR::CS>::Type Type;
23242 enum : long long { VRType = VR::CS };
23243 enum { VMType = VM::VM1 };
23244 static const char* GetVMString() { return "1"; }
23245 };
23246 template <> struct TagToType<0x2040,0x0082> {
23247 static const char* GetVRString() { return "CS"; }
23248 typedef VRToType<VR::CS>::Type Type;
23249 enum : long long { VRType = VR::CS };
23250 enum { VMType = VM::VM1 };
23251 static const char* GetVMString() { return "1"; }
23252 };
23253 template <> struct TagToType<0x2040,0x0090> {
23254 static const char* GetVRString() { return "CS"; }
23255 typedef VRToType<VR::CS>::Type Type;
23256 enum : long long { VRType = VR::CS };
23257 enum { VMType = VM::VM1 };
23258 static const char* GetVMString() { return "1"; }
23259 };
23260 template <> struct TagToType<0x2040,0x0100> {
23261 static const char* GetVRString() { return "CS"; }
23262 typedef VRToType<VR::CS>::Type Type;
23263 enum : long long { VRType = VR::CS };
23264 enum { VMType = VM::VM1 };
23265 static const char* GetVMString() { return "1"; }
23266 };
23267 template <> struct TagToType<0x2040,0x0500> {
23268 static const char* GetVRString() { return "SQ"; }
23269 typedef VRToType<VR::SQ>::Type Type;
23270 enum : long long { VRType = VR::SQ };
23271 enum { VMType = VM::VM1 };
23272 static const char* GetVMString() { return "1"; }
23273 };
23274 template <> struct TagToType<0x2050,0x0010> {
23275 static const char* GetVRString() { return "SQ"; }
23276 typedef VRToType<VR::SQ>::Type Type;
23277 enum : long long { VRType = VR::SQ };
23278 enum { VMType = VM::VM1 };
23279 static const char* GetVMString() { return "1"; }
23280 };
23281 template <> struct TagToType<0x2050,0x0020> {
23282 static const char* GetVRString() { return "CS"; }
23283 typedef VRToType<VR::CS>::Type Type;
23284 enum : long long { VRType = VR::CS };
23285 enum { VMType = VM::VM1 };
23286 static const char* GetVMString() { return "1"; }
23287 };
23288 template <> struct TagToType<0x2050,0x0500> {
23289 static const char* GetVRString() { return "SQ"; }
23290 typedef VRToType<VR::SQ>::Type Type;
23291 enum : long long { VRType = VR::SQ };
23292 enum { VMType = VM::VM1 };
23293 static const char* GetVMString() { return "1"; }
23294 };
23295 template <> struct TagToType<0x2100,0x0010> {
23296 static const char* GetVRString() { return "SH"; }
23297 typedef VRToType<VR::SH>::Type Type;
23298 enum : long long { VRType = VR::SH };
23299 enum { VMType = VM::VM1 };
23300 static const char* GetVMString() { return "1"; }
23301 };
23302 template <> struct TagToType<0x2100,0x0020> {
23303 static const char* GetVRString() { return "CS"; }
23304 typedef VRToType<VR::CS>::Type Type;
23305 enum : long long { VRType = VR::CS };
23306 enum { VMType = VM::VM1 };
23307 static const char* GetVMString() { return "1"; }
23308 };
23309 template <> struct TagToType<0x2100,0x0030> {
23310 static const char* GetVRString() { return "CS"; }
23311 typedef VRToType<VR::CS>::Type Type;
23312 enum : long long { VRType = VR::CS };
23313 enum { VMType = VM::VM1 };
23314 static const char* GetVMString() { return "1"; }
23315 };
23316 template <> struct TagToType<0x2100,0x0040> {
23317 static const char* GetVRString() { return "DA"; }
23318 typedef VRToType<VR::DA>::Type Type;
23319 enum : long long { VRType = VR::DA };
23320 enum { VMType = VM::VM1 };
23321 static const char* GetVMString() { return "1"; }
23322 };
23323 template <> struct TagToType<0x2100,0x0050> {
23324 static const char* GetVRString() { return "TM"; }
23325 typedef VRToType<VR::TM>::Type Type;
23326 enum : long long { VRType = VR::TM };
23327 enum { VMType = VM::VM1 };
23328 static const char* GetVMString() { return "1"; }
23329 };
23330 template <> struct TagToType<0x2100,0x0070> {
23331 static const char* GetVRString() { return "AE"; }
23332 typedef VRToType<VR::AE>::Type Type;
23333 enum : long long { VRType = VR::AE };
23334 enum { VMType = VM::VM1 };
23335 static const char* GetVMString() { return "1"; }
23336 };
23337 template <> struct TagToType<0x2100,0x0140> {
23338 static const char* GetVRString() { return "AE"; }
23339 typedef VRToType<VR::AE>::Type Type;
23340 enum : long long { VRType = VR::AE };
23341 enum { VMType = VM::VM1 };
23342 static const char* GetVMString() { return "1"; }
23343 };
23344 template <> struct TagToType<0x2100,0x0160> {
23345 static const char* GetVRString() { return "SH"; }
23346 typedef VRToType<VR::SH>::Type Type;
23347 enum : long long { VRType = VR::SH };
23348 enum { VMType = VM::VM1 };
23349 static const char* GetVMString() { return "1"; }
23350 };
23351 template <> struct TagToType<0x2100,0x0170> {
23352 static const char* GetVRString() { return "IS"; }
23353 typedef VRToType<VR::IS>::Type Type;
23354 enum : long long { VRType = VR::IS };
23355 enum { VMType = VM::VM1 };
23356 static const char* GetVMString() { return "1"; }
23357 };
23358 template <> struct TagToType<0x2100,0x0500> {
23359 static const char* GetVRString() { return "SQ"; }
23360 typedef VRToType<VR::SQ>::Type Type;
23361 enum : long long { VRType = VR::SQ };
23362 enum { VMType = VM::VM1 };
23363 static const char* GetVMString() { return "1"; }
23364 };
23365 template <> struct TagToType<0x2110,0x0010> {
23366 static const char* GetVRString() { return "CS"; }
23367 typedef VRToType<VR::CS>::Type Type;
23368 enum : long long { VRType = VR::CS };
23369 enum { VMType = VM::VM1 };
23370 static const char* GetVMString() { return "1"; }
23371 };
23372 template <> struct TagToType<0x2110,0x0020> {
23373 static const char* GetVRString() { return "CS"; }
23374 typedef VRToType<VR::CS>::Type Type;
23375 enum : long long { VRType = VR::CS };
23376 enum { VMType = VM::VM1 };
23377 static const char* GetVMString() { return "1"; }
23378 };
23379 template <> struct TagToType<0x2110,0x0030> {
23380 static const char* GetVRString() { return "LO"; }
23381 typedef VRToType<VR::LO>::Type Type;
23382 enum : long long { VRType = VR::LO };
23383 enum { VMType = VM::VM1 };
23384 static const char* GetVMString() { return "1"; }
23385 };
23386 template <> struct TagToType<0x2110,0x0099> {
23387 static const char* GetVRString() { return "SH"; }
23388 typedef VRToType<VR::SH>::Type Type;
23389 enum : long long { VRType = VR::SH };
23390 enum { VMType = VM::VM1 };
23391 static const char* GetVMString() { return "1"; }
23392 };
23393 template <> struct TagToType<0x2120,0x0010> {
23394 static const char* GetVRString() { return "CS"; }
23395 typedef VRToType<VR::CS>::Type Type;
23396 enum : long long { VRType = VR::CS };
23397 enum { VMType = VM::VM1 };
23398 static const char* GetVMString() { return "1"; }
23399 };
23400 template <> struct TagToType<0x2120,0x0050> {
23401 static const char* GetVRString() { return "SQ"; }
23402 typedef VRToType<VR::SQ>::Type Type;
23403 enum : long long { VRType = VR::SQ };
23404 enum { VMType = VM::VM1 };
23405 static const char* GetVMString() { return "1"; }
23406 };
23407 template <> struct TagToType<0x2120,0x0070> {
23408 static const char* GetVRString() { return "SQ"; }
23409 typedef VRToType<VR::SQ>::Type Type;
23410 enum : long long { VRType = VR::SQ };
23411 enum { VMType = VM::VM1 };
23412 static const char* GetVMString() { return "1"; }
23413 };
23414 template <> struct TagToType<0x2130,0x0010> {
23415 static const char* GetVRString() { return "SQ"; }
23416 typedef VRToType<VR::SQ>::Type Type;
23417 enum : long long { VRType = VR::SQ };
23418 enum { VMType = VM::VM1 };
23419 static const char* GetVMString() { return "1"; }
23420 };
23421 template <> struct TagToType<0x2130,0x0015> {
23422 static const char* GetVRString() { return "SQ"; }
23423 typedef VRToType<VR::SQ>::Type Type;
23424 enum : long long { VRType = VR::SQ };
23425 enum { VMType = VM::VM1 };
23426 static const char* GetVMString() { return "1"; }
23427 };
23428 template <> struct TagToType<0x2130,0x0030> {
23429 static const char* GetVRString() { return "SQ"; }
23430 typedef VRToType<VR::SQ>::Type Type;
23431 enum : long long { VRType = VR::SQ };
23432 enum { VMType = VM::VM1 };
23433 static const char* GetVMString() { return "1"; }
23434 };
23435 template <> struct TagToType<0x2130,0x0040> {
23436 static const char* GetVRString() { return "SQ"; }
23437 typedef VRToType<VR::SQ>::Type Type;
23438 enum : long long { VRType = VR::SQ };
23439 enum { VMType = VM::VM1 };
23440 static const char* GetVMString() { return "1"; }
23441 };
23442 template <> struct TagToType<0x2130,0x0050> {
23443 static const char* GetVRString() { return "SQ"; }
23444 typedef VRToType<VR::SQ>::Type Type;
23445 enum : long long { VRType = VR::SQ };
23446 enum { VMType = VM::VM1 };
23447 static const char* GetVMString() { return "1"; }
23448 };
23449 template <> struct TagToType<0x2130,0x0060> {
23450 static const char* GetVRString() { return "SQ"; }
23451 typedef VRToType<VR::SQ>::Type Type;
23452 enum : long long { VRType = VR::SQ };
23453 enum { VMType = VM::VM1 };
23454 static const char* GetVMString() { return "1"; }
23455 };
23456 template <> struct TagToType<0x2130,0x0080> {
23457 static const char* GetVRString() { return "SQ"; }
23458 typedef VRToType<VR::SQ>::Type Type;
23459 enum : long long { VRType = VR::SQ };
23460 enum { VMType = VM::VM1 };
23461 static const char* GetVMString() { return "1"; }
23462 };
23463 template <> struct TagToType<0x2130,0x00a0> {
23464 static const char* GetVRString() { return "SQ"; }
23465 typedef VRToType<VR::SQ>::Type Type;
23466 enum : long long { VRType = VR::SQ };
23467 enum { VMType = VM::VM1 };
23468 static const char* GetVMString() { return "1"; }
23469 };
23470 template <> struct TagToType<0x2130,0x00c0> {
23471 static const char* GetVRString() { return "SQ"; }
23472 typedef VRToType<VR::SQ>::Type Type;
23473 enum : long long { VRType = VR::SQ };
23474 enum { VMType = VM::VM1 };
23475 static const char* GetVMString() { return "1"; }
23476 };
23477 template <> struct TagToType<0x2200,0x0001> {
23478 static const char* GetVRString() { return "CS"; }
23479 typedef VRToType<VR::CS>::Type Type;
23480 enum : long long { VRType = VR::CS };
23481 enum { VMType = VM::VM1 };
23482 static const char* GetVMString() { return "1"; }
23483 };
23484 template <> struct TagToType<0x2200,0x0002> {
23485 static const char* GetVRString() { return "UT"; }
23486 typedef VRToType<VR::UT>::Type Type;
23487 enum : long long { VRType = VR::UT };
23488 enum { VMType = VM::VM1 };
23489 static const char* GetVMString() { return "1"; }
23490 };
23491 template <> struct TagToType<0x2200,0x0003> {
23492 static const char* GetVRString() { return "CS"; }
23493 typedef VRToType<VR::CS>::Type Type;
23494 enum : long long { VRType = VR::CS };
23495 enum { VMType = VM::VM1 };
23496 static const char* GetVMString() { return "1"; }
23497 };
23498 template <> struct TagToType<0x2200,0x0004> {
23499 static const char* GetVRString() { return "LT"; }
23500 typedef VRToType<VR::LT>::Type Type;
23501 enum : long long { VRType = VR::LT };
23502 enum { VMType = VM::VM1 };
23503 static const char* GetVMString() { return "1"; }
23504 };
23505 template <> struct TagToType<0x2200,0x0005> {
23506 static const char* GetVRString() { return "LT"; }
23507 typedef VRToType<VR::LT>::Type Type;
23508 enum : long long { VRType = VR::LT };
23509 enum { VMType = VM::VM1 };
23510 static const char* GetVMString() { return "1"; }
23511 };
23512 template <> struct TagToType<0x2200,0x0006> {
23513 static const char* GetVRString() { return "CS"; }
23514 typedef VRToType<VR::CS>::Type Type;
23515 enum : long long { VRType = VR::CS };
23516 enum { VMType = VM::VM1 };
23517 static const char* GetVMString() { return "1"; }
23518 };
23519 template <> struct TagToType<0x2200,0x0007> {
23520 static const char* GetVRString() { return "CS"; }
23521 typedef VRToType<VR::CS>::Type Type;
23522 enum : long long { VRType = VR::CS };
23523 enum { VMType = VM::VM1 };
23524 static const char* GetVMString() { return "1"; }
23525 };
23526 template <> struct TagToType<0x2200,0x0008> {
23527 static const char* GetVRString() { return "CS"; }
23528 typedef VRToType<VR::CS>::Type Type;
23529 enum : long long { VRType = VR::CS };
23530 enum { VMType = VM::VM1 };
23531 static const char* GetVMString() { return "1"; }
23532 };
23533 template <> struct TagToType<0x2200,0x0009> {
23534 static const char* GetVRString() { return "CS"; }
23535 typedef VRToType<VR::CS>::Type Type;
23536 enum : long long { VRType = VR::CS };
23537 enum { VMType = VM::VM1 };
23538 static const char* GetVMString() { return "1"; }
23539 };
23540 template <> struct TagToType<0x2200,0x000a> {
23541 static const char* GetVRString() { return "CS"; }
23542 typedef VRToType<VR::CS>::Type Type;
23543 enum : long long { VRType = VR::CS };
23544 enum { VMType = VM::VM1 };
23545 static const char* GetVMString() { return "1"; }
23546 };
23547 template <> struct TagToType<0x2200,0x000b> {
23548 static const char* GetVRString() { return "US"; }
23549 typedef VRToType<VR::US>::Type Type;
23550 enum : long long { VRType = VR::US };
23551 enum { VMType = VM::VM1 };
23552 static const char* GetVMString() { return "1"; }
23553 };
23554 template <> struct TagToType<0x2200,0x000c> {
23555 static const char* GetVRString() { return "LO"; }
23556 typedef VRToType<VR::LO>::Type Type;
23557 enum : long long { VRType = VR::LO };
23558 enum { VMType = VM::VM1 };
23559 static const char* GetVMString() { return "1"; }
23560 };
23561 template <> struct TagToType<0x2200,0x000d> {
23562 static const char* GetVRString() { return "SQ"; }
23563 typedef VRToType<VR::SQ>::Type Type;
23564 enum : long long { VRType = VR::SQ };
23565 enum { VMType = VM::VM1 };
23566 static const char* GetVMString() { return "1"; }
23567 };
23568 template <> struct TagToType<0x2200,0x000e> {
23569 static const char* GetVRString() { return "AT"; }
23570 typedef VRToType<VR::AT>::Type Type;
23571 enum : long long { VRType = VR::AT };
23572 enum { VMType = VM::VM1_n };
23573 static const char* GetVMString() { return "1-n"; }
23574 };
23575 template <> struct TagToType<0x2200,0x000f> {
23576 static const char* GetVRString() { return "CS"; }
23577 typedef VRToType<VR::CS>::Type Type;
23578 enum : long long { VRType = VR::CS };
23579 enum { VMType = VM::VM1 };
23580 static const char* GetVMString() { return "1"; }
23581 };
23582 template <> struct TagToType<0x2200,0x0020> {
23583 static const char* GetVRString() { return "CS"; }
23584 typedef VRToType<VR::CS>::Type Type;
23585 enum : long long { VRType = VR::CS };
23586 enum { VMType = VM::VM1 };
23587 static const char* GetVMString() { return "1"; }
23588 };
23589 template <> struct TagToType<0x3002,0x0002> {
23590 static const char* GetVRString() { return "SH"; }
23591 typedef VRToType<VR::SH>::Type Type;
23592 enum : long long { VRType = VR::SH };
23593 enum { VMType = VM::VM1 };
23594 static const char* GetVMString() { return "1"; }
23595 };
23596 template <> struct TagToType<0x3002,0x0003> {
23597 static const char* GetVRString() { return "LO"; }
23598 typedef VRToType<VR::LO>::Type Type;
23599 enum : long long { VRType = VR::LO };
23600 enum { VMType = VM::VM1 };
23601 static const char* GetVMString() { return "1"; }
23602 };
23603 template <> struct TagToType<0x3002,0x0004> {
23604 static const char* GetVRString() { return "ST"; }
23605 typedef VRToType<VR::ST>::Type Type;
23606 enum : long long { VRType = VR::ST };
23607 enum { VMType = VM::VM1 };
23608 static const char* GetVMString() { return "1"; }
23609 };
23610 template <> struct TagToType<0x3002,0x000a> {
23611 static const char* GetVRString() { return "CS"; }
23612 typedef VRToType<VR::CS>::Type Type;
23613 enum : long long { VRType = VR::CS };
23614 enum { VMType = VM::VM1 };
23615 static const char* GetVMString() { return "1"; }
23616 };
23617 template <> struct TagToType<0x3002,0x000c> {
23618 static const char* GetVRString() { return "CS"; }
23619 typedef VRToType<VR::CS>::Type Type;
23620 enum : long long { VRType = VR::CS };
23621 enum { VMType = VM::VM1 };
23622 static const char* GetVMString() { return "1"; }
23623 };
23624 template <> struct TagToType<0x3002,0x000d> {
23625 static const char* GetVRString() { return "DS"; }
23626 typedef VRToType<VR::DS>::Type Type;
23627 enum : long long { VRType = VR::DS };
23628 enum { VMType = VM::VM3 };
23629 static const char* GetVMString() { return "3"; }
23630 };
23631 template <> struct TagToType<0x3002,0x000e> {
23632 static const char* GetVRString() { return "DS"; }
23633 typedef VRToType<VR::DS>::Type Type;
23634 enum : long long { VRType = VR::DS };
23635 enum { VMType = VM::VM1 };
23636 static const char* GetVMString() { return "1"; }
23637 };
23638 template <> struct TagToType<0x3002,0x0010> {
23639 static const char* GetVRString() { return "DS"; }
23640 typedef VRToType<VR::DS>::Type Type;
23641 enum : long long { VRType = VR::DS };
23642 enum { VMType = VM::VM6 };
23643 static const char* GetVMString() { return "6"; }
23644 };
23645 template <> struct TagToType<0x3002,0x0011> {
23646 static const char* GetVRString() { return "DS"; }
23647 typedef VRToType<VR::DS>::Type Type;
23648 enum : long long { VRType = VR::DS };
23649 enum { VMType = VM::VM2 };
23650 static const char* GetVMString() { return "2"; }
23651 };
23652 template <> struct TagToType<0x3002,0x0012> {
23653 static const char* GetVRString() { return "DS"; }
23654 typedef VRToType<VR::DS>::Type Type;
23655 enum : long long { VRType = VR::DS };
23656 enum { VMType = VM::VM2 };
23657 static const char* GetVMString() { return "2"; }
23658 };
23659 template <> struct TagToType<0x3002,0x0020> {
23660 static const char* GetVRString() { return "SH"; }
23661 typedef VRToType<VR::SH>::Type Type;
23662 enum : long long { VRType = VR::SH };
23663 enum { VMType = VM::VM1 };
23664 static const char* GetVMString() { return "1"; }
23665 };
23666 template <> struct TagToType<0x3002,0x0022> {
23667 static const char* GetVRString() { return "DS"; }
23668 typedef VRToType<VR::DS>::Type Type;
23669 enum : long long { VRType = VR::DS };
23670 enum { VMType = VM::VM1 };
23671 static const char* GetVMString() { return "1"; }
23672 };
23673 template <> struct TagToType<0x3002,0x0024> {
23674 static const char* GetVRString() { return "DS"; }
23675 typedef VRToType<VR::DS>::Type Type;
23676 enum : long long { VRType = VR::DS };
23677 enum { VMType = VM::VM1 };
23678 static const char* GetVMString() { return "1"; }
23679 };
23680 template <> struct TagToType<0x3002,0x0026> {
23681 static const char* GetVRString() { return "DS"; }
23682 typedef VRToType<VR::DS>::Type Type;
23683 enum : long long { VRType = VR::DS };
23684 enum { VMType = VM::VM1 };
23685 static const char* GetVMString() { return "1"; }
23686 };
23687 template <> struct TagToType<0x3002,0x0028> {
23688 static const char* GetVRString() { return "DS"; }
23689 typedef VRToType<VR::DS>::Type Type;
23690 enum : long long { VRType = VR::DS };
23691 enum { VMType = VM::VM1 };
23692 static const char* GetVMString() { return "1"; }
23693 };
23694 template <> struct TagToType<0x3002,0x0029> {
23695 static const char* GetVRString() { return "IS"; }
23696 typedef VRToType<VR::IS>::Type Type;
23697 enum : long long { VRType = VR::IS };
23698 enum { VMType = VM::VM1 };
23699 static const char* GetVMString() { return "1"; }
23700 };
23701 template <> struct TagToType<0x3002,0x0030> {
23702 static const char* GetVRString() { return "SQ"; }
23703 typedef VRToType<VR::SQ>::Type Type;
23704 enum : long long { VRType = VR::SQ };
23705 enum { VMType = VM::VM1 };
23706 static const char* GetVMString() { return "1"; }
23707 };
23708 template <> struct TagToType<0x3002,0x0032> {
23709 static const char* GetVRString() { return "DS"; }
23710 typedef VRToType<VR::DS>::Type Type;
23711 enum : long long { VRType = VR::DS };
23712 enum { VMType = VM::VM1 };
23713 static const char* GetVMString() { return "1"; }
23714 };
23715 template <> struct TagToType<0x3002,0x0034> {
23716 static const char* GetVRString() { return "DS"; }
23717 typedef VRToType<VR::DS>::Type Type;
23718 enum : long long { VRType = VR::DS };
23719 enum { VMType = VM::VM4 };
23720 static const char* GetVMString() { return "4"; }
23721 };
23722 template <> struct TagToType<0x3002,0x0040> {
23723 static const char* GetVRString() { return "SQ"; }
23724 typedef VRToType<VR::SQ>::Type Type;
23725 enum : long long { VRType = VR::SQ };
23726 enum { VMType = VM::VM1 };
23727 static const char* GetVMString() { return "1"; }
23728 };
23729 template <> struct TagToType<0x3002,0x0041> {
23730 static const char* GetVRString() { return "CS"; }
23731 typedef VRToType<VR::CS>::Type Type;
23732 enum : long long { VRType = VR::CS };
23733 enum { VMType = VM::VM1 };
23734 static const char* GetVMString() { return "1"; }
23735 };
23736 template <> struct TagToType<0x3002,0x0042> {
23737 static const char* GetVRString() { return "DS"; }
23738 typedef VRToType<VR::DS>::Type Type;
23739 enum : long long { VRType = VR::DS };
23740 enum { VMType = VM::VM1 };
23741 static const char* GetVMString() { return "1"; }
23742 };
23743 template <> struct TagToType<0x3002,0x0050> {
23744 static const char* GetVRString() { return "SQ"; }
23745 typedef VRToType<VR::SQ>::Type Type;
23746 enum : long long { VRType = VR::SQ };
23747 enum { VMType = VM::VM1 };
23748 static const char* GetVMString() { return "1"; }
23749 };
23750 template <> struct TagToType<0x3002,0x0051> {
23751 static const char* GetVRString() { return "CS"; }
23752 typedef VRToType<VR::CS>::Type Type;
23753 enum : long long { VRType = VR::CS };
23754 enum { VMType = VM::VM1 };
23755 static const char* GetVMString() { return "1"; }
23756 };
23757 template <> struct TagToType<0x3002,0x0052> {
23758 static const char* GetVRString() { return "SH"; }
23759 typedef VRToType<VR::SH>::Type Type;
23760 enum : long long { VRType = VR::SH };
23761 enum { VMType = VM::VM1 };
23762 static const char* GetVMString() { return "1"; }
23763 };
23764 template <> struct TagToType<0x3004,0x0001> {
23765 static const char* GetVRString() { return "CS"; }
23766 typedef VRToType<VR::CS>::Type Type;
23767 enum : long long { VRType = VR::CS };
23768 enum { VMType = VM::VM1 };
23769 static const char* GetVMString() { return "1"; }
23770 };
23771 template <> struct TagToType<0x3004,0x0002> {
23772 static const char* GetVRString() { return "CS"; }
23773 typedef VRToType<VR::CS>::Type Type;
23774 enum : long long { VRType = VR::CS };
23775 enum { VMType = VM::VM1 };
23776 static const char* GetVMString() { return "1"; }
23777 };
23778 template <> struct TagToType<0x3004,0x0004> {
23779 static const char* GetVRString() { return "CS"; }
23780 typedef VRToType<VR::CS>::Type Type;
23781 enum : long long { VRType = VR::CS };
23782 enum { VMType = VM::VM1 };
23783 static const char* GetVMString() { return "1"; }
23784 };
23785 template <> struct TagToType<0x3004,0x0005> {
23786 static const char* GetVRString() { return "CS"; }
23787 typedef VRToType<VR::CS>::Type Type;
23788 enum : long long { VRType = VR::CS };
23789 enum { VMType = VM::VM1 };
23790 static const char* GetVMString() { return "1"; }
23791 };
23792 template <> struct TagToType<0x3004,0x0006> {
23793 static const char* GetVRString() { return "LO"; }
23794 typedef VRToType<VR::LO>::Type Type;
23795 enum : long long { VRType = VR::LO };
23796 enum { VMType = VM::VM1 };
23797 static const char* GetVMString() { return "1"; }
23798 };
23799 template <> struct TagToType<0x3004,0x0008> {
23800 static const char* GetVRString() { return "DS"; }
23801 typedef VRToType<VR::DS>::Type Type;
23802 enum : long long { VRType = VR::DS };
23803 enum { VMType = VM::VM3 };
23804 static const char* GetVMString() { return "3"; }
23805 };
23806 template <> struct TagToType<0x3004,0x000a> {
23807 static const char* GetVRString() { return "CS"; }
23808 typedef VRToType<VR::CS>::Type Type;
23809 enum : long long { VRType = VR::CS };
23810 enum { VMType = VM::VM1 };
23811 static const char* GetVMString() { return "1"; }
23812 };
23813 template <> struct TagToType<0x3004,0x000c> {
23814 static const char* GetVRString() { return "DS"; }
23815 typedef VRToType<VR::DS>::Type Type;
23816 enum : long long { VRType = VR::DS };
23817 enum { VMType = VM::VM2_n };
23818 static const char* GetVMString() { return "2-n"; }
23819 };
23820 template <> struct TagToType<0x3004,0x000e> {
23821 static const char* GetVRString() { return "DS"; }
23822 typedef VRToType<VR::DS>::Type Type;
23823 enum : long long { VRType = VR::DS };
23824 enum { VMType = VM::VM1 };
23825 static const char* GetVMString() { return "1"; }
23826 };
23827 template <> struct TagToType<0x3004,0x0010> {
23828 static const char* GetVRString() { return "SQ"; }
23829 typedef VRToType<VR::SQ>::Type Type;
23830 enum : long long { VRType = VR::SQ };
23831 enum { VMType = VM::VM1 };
23832 static const char* GetVMString() { return "1"; }
23833 };
23834 template <> struct TagToType<0x3004,0x0012> {
23835 static const char* GetVRString() { return "DS"; }
23836 typedef VRToType<VR::DS>::Type Type;
23837 enum : long long { VRType = VR::DS };
23838 enum { VMType = VM::VM1 };
23839 static const char* GetVMString() { return "1"; }
23840 };
23841 template <> struct TagToType<0x3004,0x0014> {
23842 static const char* GetVRString() { return "CS"; }
23843 typedef VRToType<VR::CS>::Type Type;
23844 enum : long long { VRType = VR::CS };
23845 enum { VMType = VM::VM1_3 };
23846 static const char* GetVMString() { return "1-3"; }
23847 };
23848 template <> struct TagToType<0x3004,0x0040> {
23849 static const char* GetVRString() { return "DS"; }
23850 typedef VRToType<VR::DS>::Type Type;
23851 enum : long long { VRType = VR::DS };
23852 enum { VMType = VM::VM3 };
23853 static const char* GetVMString() { return "3"; }
23854 };
23855 template <> struct TagToType<0x3004,0x0042> {
23856 static const char* GetVRString() { return "DS"; }
23857 typedef VRToType<VR::DS>::Type Type;
23858 enum : long long { VRType = VR::DS };
23859 enum { VMType = VM::VM1 };
23860 static const char* GetVMString() { return "1"; }
23861 };
23862 template <> struct TagToType<0x3004,0x0050> {
23863 static const char* GetVRString() { return "SQ"; }
23864 typedef VRToType<VR::SQ>::Type Type;
23865 enum : long long { VRType = VR::SQ };
23866 enum { VMType = VM::VM1 };
23867 static const char* GetVMString() { return "1"; }
23868 };
23869 template <> struct TagToType<0x3004,0x0052> {
23870 static const char* GetVRString() { return "DS"; }
23871 typedef VRToType<VR::DS>::Type Type;
23872 enum : long long { VRType = VR::DS };
23873 enum { VMType = VM::VM1 };
23874 static const char* GetVMString() { return "1"; }
23875 };
23876 template <> struct TagToType<0x3004,0x0054> {
23877 static const char* GetVRString() { return "CS"; }
23878 typedef VRToType<VR::CS>::Type Type;
23879 enum : long long { VRType = VR::CS };
23880 enum { VMType = VM::VM1 };
23881 static const char* GetVMString() { return "1"; }
23882 };
23883 template <> struct TagToType<0x3004,0x0056> {
23884 static const char* GetVRString() { return "IS"; }
23885 typedef VRToType<VR::IS>::Type Type;
23886 enum : long long { VRType = VR::IS };
23887 enum { VMType = VM::VM1 };
23888 static const char* GetVMString() { return "1"; }
23889 };
23890 template <> struct TagToType<0x3004,0x0058> {
23891 static const char* GetVRString() { return "DS"; }
23892 typedef VRToType<VR::DS>::Type Type;
23893 enum : long long { VRType = VR::DS };
23894 enum { VMType = VM::VM2_2n };
23895 static const char* GetVMString() { return "2-2n"; }
23896 };
23897 template <> struct TagToType<0x3004,0x0060> {
23898 static const char* GetVRString() { return "SQ"; }
23899 typedef VRToType<VR::SQ>::Type Type;
23900 enum : long long { VRType = VR::SQ };
23901 enum { VMType = VM::VM1 };
23902 static const char* GetVMString() { return "1"; }
23903 };
23904 template <> struct TagToType<0x3004,0x0062> {
23905 static const char* GetVRString() { return "CS"; }
23906 typedef VRToType<VR::CS>::Type Type;
23907 enum : long long { VRType = VR::CS };
23908 enum { VMType = VM::VM1 };
23909 static const char* GetVMString() { return "1"; }
23910 };
23911 template <> struct TagToType<0x3004,0x0070> {
23912 static const char* GetVRString() { return "DS"; }
23913 typedef VRToType<VR::DS>::Type Type;
23914 enum : long long { VRType = VR::DS };
23915 enum { VMType = VM::VM1 };
23916 static const char* GetVMString() { return "1"; }
23917 };
23918 template <> struct TagToType<0x3004,0x0072> {
23919 static const char* GetVRString() { return "DS"; }
23920 typedef VRToType<VR::DS>::Type Type;
23921 enum : long long { VRType = VR::DS };
23922 enum { VMType = VM::VM1 };
23923 static const char* GetVMString() { return "1"; }
23924 };
23925 template <> struct TagToType<0x3004,0x0074> {
23926 static const char* GetVRString() { return "DS"; }
23927 typedef VRToType<VR::DS>::Type Type;
23928 enum : long long { VRType = VR::DS };
23929 enum { VMType = VM::VM1 };
23930 static const char* GetVMString() { return "1"; }
23931 };
23932 template <> struct TagToType<0x3006,0x0002> {
23933 static const char* GetVRString() { return "SH"; }
23934 typedef VRToType<VR::SH>::Type Type;
23935 enum : long long { VRType = VR::SH };
23936 enum { VMType = VM::VM1 };
23937 static const char* GetVMString() { return "1"; }
23938 };
23939 template <> struct TagToType<0x3006,0x0004> {
23940 static const char* GetVRString() { return "LO"; }
23941 typedef VRToType<VR::LO>::Type Type;
23942 enum : long long { VRType = VR::LO };
23943 enum { VMType = VM::VM1 };
23944 static const char* GetVMString() { return "1"; }
23945 };
23946 template <> struct TagToType<0x3006,0x0006> {
23947 static const char* GetVRString() { return "ST"; }
23948 typedef VRToType<VR::ST>::Type Type;
23949 enum : long long { VRType = VR::ST };
23950 enum { VMType = VM::VM1 };
23951 static const char* GetVMString() { return "1"; }
23952 };
23953 template <> struct TagToType<0x3006,0x0008> {
23954 static const char* GetVRString() { return "DA"; }
23955 typedef VRToType<VR::DA>::Type Type;
23956 enum : long long { VRType = VR::DA };
23957 enum { VMType = VM::VM1 };
23958 static const char* GetVMString() { return "1"; }
23959 };
23960 template <> struct TagToType<0x3006,0x0009> {
23961 static const char* GetVRString() { return "TM"; }
23962 typedef VRToType<VR::TM>::Type Type;
23963 enum : long long { VRType = VR::TM };
23964 enum { VMType = VM::VM1 };
23965 static const char* GetVMString() { return "1"; }
23966 };
23967 template <> struct TagToType<0x3006,0x0010> {
23968 static const char* GetVRString() { return "SQ"; }
23969 typedef VRToType<VR::SQ>::Type Type;
23970 enum : long long { VRType = VR::SQ };
23971 enum { VMType = VM::VM1 };
23972 static const char* GetVMString() { return "1"; }
23973 };
23974 template <> struct TagToType<0x3006,0x0012> {
23975 static const char* GetVRString() { return "SQ"; }
23976 typedef VRToType<VR::SQ>::Type Type;
23977 enum : long long { VRType = VR::SQ };
23978 enum { VMType = VM::VM1 };
23979 static const char* GetVMString() { return "1"; }
23980 };
23981 template <> struct TagToType<0x3006,0x0014> {
23982 static const char* GetVRString() { return "SQ"; }
23983 typedef VRToType<VR::SQ>::Type Type;
23984 enum : long long { VRType = VR::SQ };
23985 enum { VMType = VM::VM1 };
23986 static const char* GetVMString() { return "1"; }
23987 };
23988 template <> struct TagToType<0x3006,0x0016> {
23989 static const char* GetVRString() { return "SQ"; }
23990 typedef VRToType<VR::SQ>::Type Type;
23991 enum : long long { VRType = VR::SQ };
23992 enum { VMType = VM::VM1 };
23993 static const char* GetVMString() { return "1"; }
23994 };
23995 template <> struct TagToType<0x3006,0x0018> {
23996 static const char* GetVRString() { return "SQ"; }
23997 typedef VRToType<VR::SQ>::Type Type;
23998 enum : long long { VRType = VR::SQ };
23999 enum { VMType = VM::VM1 };
24000 static const char* GetVMString() { return "1"; }
24001 };
24002 template <> struct TagToType<0x3006,0x0020> {
24003 static const char* GetVRString() { return "SQ"; }
24004 typedef VRToType<VR::SQ>::Type Type;
24005 enum : long long { VRType = VR::SQ };
24006 enum { VMType = VM::VM1 };
24007 static const char* GetVMString() { return "1"; }
24008 };
24009 template <> struct TagToType<0x3006,0x0022> {
24010 static const char* GetVRString() { return "IS"; }
24011 typedef VRToType<VR::IS>::Type Type;
24012 enum : long long { VRType = VR::IS };
24013 enum { VMType = VM::VM1 };
24014 static const char* GetVMString() { return "1"; }
24015 };
24016 template <> struct TagToType<0x3006,0x0024> {
24017 static const char* GetVRString() { return "UI"; }
24018 typedef VRToType<VR::UI>::Type Type;
24019 enum : long long { VRType = VR::UI };
24020 enum { VMType = VM::VM1 };
24021 static const char* GetVMString() { return "1"; }
24022 };
24023 template <> struct TagToType<0x3006,0x0026> {
24024 static const char* GetVRString() { return "LO"; }
24025 typedef VRToType<VR::LO>::Type Type;
24026 enum : long long { VRType = VR::LO };
24027 enum { VMType = VM::VM1 };
24028 static const char* GetVMString() { return "1"; }
24029 };
24030 template <> struct TagToType<0x3006,0x0028> {
24031 static const char* GetVRString() { return "ST"; }
24032 typedef VRToType<VR::ST>::Type Type;
24033 enum : long long { VRType = VR::ST };
24034 enum { VMType = VM::VM1 };
24035 static const char* GetVMString() { return "1"; }
24036 };
24037 template <> struct TagToType<0x3006,0x002a> {
24038 static const char* GetVRString() { return "IS"; }
24039 typedef VRToType<VR::IS>::Type Type;
24040 enum : long long { VRType = VR::IS };
24041 enum { VMType = VM::VM3 };
24042 static const char* GetVMString() { return "3"; }
24043 };
24044 template <> struct TagToType<0x3006,0x002c> {
24045 static const char* GetVRString() { return "DS"; }
24046 typedef VRToType<VR::DS>::Type Type;
24047 enum : long long { VRType = VR::DS };
24048 enum { VMType = VM::VM1 };
24049 static const char* GetVMString() { return "1"; }
24050 };
24051 template <> struct TagToType<0x3006,0x0030> {
24052 static const char* GetVRString() { return "SQ"; }
24053 typedef VRToType<VR::SQ>::Type Type;
24054 enum : long long { VRType = VR::SQ };
24055 enum { VMType = VM::VM1 };
24056 static const char* GetVMString() { return "1"; }
24057 };
24058 template <> struct TagToType<0x3006,0x0033> {
24059 static const char* GetVRString() { return "CS"; }
24060 typedef VRToType<VR::CS>::Type Type;
24061 enum : long long { VRType = VR::CS };
24062 enum { VMType = VM::VM1 };
24063 static const char* GetVMString() { return "1"; }
24064 };
24065 template <> struct TagToType<0x3006,0x0036> {
24066 static const char* GetVRString() { return "CS"; }
24067 typedef VRToType<VR::CS>::Type Type;
24068 enum : long long { VRType = VR::CS };
24069 enum { VMType = VM::VM1 };
24070 static const char* GetVMString() { return "1"; }
24071 };
24072 template <> struct TagToType<0x3006,0x0038> {
24073 static const char* GetVRString() { return "LO"; }
24074 typedef VRToType<VR::LO>::Type Type;
24075 enum : long long { VRType = VR::LO };
24076 enum { VMType = VM::VM1 };
24077 static const char* GetVMString() { return "1"; }
24078 };
24079 template <> struct TagToType<0x3006,0x0039> {
24080 static const char* GetVRString() { return "SQ"; }
24081 typedef VRToType<VR::SQ>::Type Type;
24082 enum : long long { VRType = VR::SQ };
24083 enum { VMType = VM::VM1 };
24084 static const char* GetVMString() { return "1"; }
24085 };
24086 template <> struct TagToType<0x3006,0x0040> {
24087 static const char* GetVRString() { return "SQ"; }
24088 typedef VRToType<VR::SQ>::Type Type;
24089 enum : long long { VRType = VR::SQ };
24090 enum { VMType = VM::VM1 };
24091 static const char* GetVMString() { return "1"; }
24092 };
24093 template <> struct TagToType<0x3006,0x0042> {
24094 static const char* GetVRString() { return "CS"; }
24095 typedef VRToType<VR::CS>::Type Type;
24096 enum : long long { VRType = VR::CS };
24097 enum { VMType = VM::VM1 };
24098 static const char* GetVMString() { return "1"; }
24099 };
24100 template <> struct TagToType<0x3006,0x0044> {
24101 static const char* GetVRString() { return "DS"; }
24102 typedef VRToType<VR::DS>::Type Type;
24103 enum : long long { VRType = VR::DS };
24104 enum { VMType = VM::VM1 };
24105 static const char* GetVMString() { return "1"; }
24106 };
24107 template <> struct TagToType<0x3006,0x0045> {
24108 static const char* GetVRString() { return "DS"; }
24109 typedef VRToType<VR::DS>::Type Type;
24110 enum : long long { VRType = VR::DS };
24111 enum { VMType = VM::VM3 };
24112 static const char* GetVMString() { return "3"; }
24113 };
24114 template <> struct TagToType<0x3006,0x0046> {
24115 static const char* GetVRString() { return "IS"; }
24116 typedef VRToType<VR::IS>::Type Type;
24117 enum : long long { VRType = VR::IS };
24118 enum { VMType = VM::VM1 };
24119 static const char* GetVMString() { return "1"; }
24120 };
24121 template <> struct TagToType<0x3006,0x0048> {
24122 static const char* GetVRString() { return "IS"; }
24123 typedef VRToType<VR::IS>::Type Type;
24124 enum : long long { VRType = VR::IS };
24125 enum { VMType = VM::VM1 };
24126 static const char* GetVMString() { return "1"; }
24127 };
24128 template <> struct TagToType<0x3006,0x0049> {
24129 static const char* GetVRString() { return "IS"; }
24130 typedef VRToType<VR::IS>::Type Type;
24131 enum : long long { VRType = VR::IS };
24132 enum { VMType = VM::VM1_n };
24133 static const char* GetVMString() { return "1-n"; }
24134 };
24135 template <> struct TagToType<0x3006,0x0050> {
24136 static const char* GetVRString() { return "DS"; }
24137 typedef VRToType<VR::DS>::Type Type;
24138 enum : long long { VRType = VR::DS };
24139 enum { VMType = VM::VM3_3n };
24140 static const char* GetVMString() { return "3-3n"; }
24141 };
24142 template <> struct TagToType<0x3006,0x0080> {
24143 static const char* GetVRString() { return "SQ"; }
24144 typedef VRToType<VR::SQ>::Type Type;
24145 enum : long long { VRType = VR::SQ };
24146 enum { VMType = VM::VM1 };
24147 static const char* GetVMString() { return "1"; }
24148 };
24149 template <> struct TagToType<0x3006,0x0082> {
24150 static const char* GetVRString() { return "IS"; }
24151 typedef VRToType<VR::IS>::Type Type;
24152 enum : long long { VRType = VR::IS };
24153 enum { VMType = VM::VM1 };
24154 static const char* GetVMString() { return "1"; }
24155 };
24156 template <> struct TagToType<0x3006,0x0084> {
24157 static const char* GetVRString() { return "IS"; }
24158 typedef VRToType<VR::IS>::Type Type;
24159 enum : long long { VRType = VR::IS };
24160 enum { VMType = VM::VM1 };
24161 static const char* GetVMString() { return "1"; }
24162 };
24163 template <> struct TagToType<0x3006,0x0085> {
24164 static const char* GetVRString() { return "SH"; }
24165 typedef VRToType<VR::SH>::Type Type;
24166 enum : long long { VRType = VR::SH };
24167 enum { VMType = VM::VM1 };
24168 static const char* GetVMString() { return "1"; }
24169 };
24170 template <> struct TagToType<0x3006,0x0086> {
24171 static const char* GetVRString() { return "SQ"; }
24172 typedef VRToType<VR::SQ>::Type Type;
24173 enum : long long { VRType = VR::SQ };
24174 enum { VMType = VM::VM1 };
24175 static const char* GetVMString() { return "1"; }
24176 };
24177 template <> struct TagToType<0x3006,0x0088> {
24178 static const char* GetVRString() { return "ST"; }
24179 typedef VRToType<VR::ST>::Type Type;
24180 enum : long long { VRType = VR::ST };
24181 enum { VMType = VM::VM1 };
24182 static const char* GetVMString() { return "1"; }
24183 };
24184 template <> struct TagToType<0x3006,0x00a0> {
24185 static const char* GetVRString() { return "SQ"; }
24186 typedef VRToType<VR::SQ>::Type Type;
24187 enum : long long { VRType = VR::SQ };
24188 enum { VMType = VM::VM1 };
24189 static const char* GetVMString() { return "1"; }
24190 };
24191 template <> struct TagToType<0x3006,0x00a4> {
24192 static const char* GetVRString() { return "CS"; }
24193 typedef VRToType<VR::CS>::Type Type;
24194 enum : long long { VRType = VR::CS };
24195 enum { VMType = VM::VM1 };
24196 static const char* GetVMString() { return "1"; }
24197 };
24198 template <> struct TagToType<0x3006,0x00a6> {
24199 static const char* GetVRString() { return "PN"; }
24200 typedef VRToType<VR::PN>::Type Type;
24201 enum : long long { VRType = VR::PN };
24202 enum { VMType = VM::VM1 };
24203 static const char* GetVMString() { return "1"; }
24204 };
24205 template <> struct TagToType<0x3006,0x00b0> {
24206 static const char* GetVRString() { return "SQ"; }
24207 typedef VRToType<VR::SQ>::Type Type;
24208 enum : long long { VRType = VR::SQ };
24209 enum { VMType = VM::VM1 };
24210 static const char* GetVMString() { return "1"; }
24211 };
24212 template <> struct TagToType<0x3006,0x00b2> {
24213 static const char* GetVRString() { return "CS"; }
24214 typedef VRToType<VR::CS>::Type Type;
24215 enum : long long { VRType = VR::CS };
24216 enum { VMType = VM::VM1 };
24217 static const char* GetVMString() { return "1"; }
24218 };
24219 template <> struct TagToType<0x3006,0x00b4> {
24220 static const char* GetVRString() { return "DS"; }
24221 typedef VRToType<VR::DS>::Type Type;
24222 enum : long long { VRType = VR::DS };
24223 enum { VMType = VM::VM1 };
24224 static const char* GetVMString() { return "1"; }
24225 };
24226 template <> struct TagToType<0x3006,0x00b6> {
24227 static const char* GetVRString() { return "SQ"; }
24228 typedef VRToType<VR::SQ>::Type Type;
24229 enum : long long { VRType = VR::SQ };
24230 enum { VMType = VM::VM1 };
24231 static const char* GetVMString() { return "1"; }
24232 };
24233 template <> struct TagToType<0x3006,0x00b7> {
24234 static const char* GetVRString() { return "US"; }
24235 typedef VRToType<VR::US>::Type Type;
24236 enum : long long { VRType = VR::US };
24237 enum { VMType = VM::VM1 };
24238 static const char* GetVMString() { return "1"; }
24239 };
24240 template <> struct TagToType<0x3006,0x00b8> {
24241 static const char* GetVRString() { return "FL"; }
24242 typedef VRToType<VR::FL>::Type Type;
24243 enum : long long { VRType = VR::FL };
24244 enum { VMType = VM::VM1 };
24245 static const char* GetVMString() { return "1"; }
24246 };
24247 template <> struct TagToType<0x3006,0x00b9> {
24248 static const char* GetVRString() { return "SQ"; }
24249 typedef VRToType<VR::SQ>::Type Type;
24250 enum : long long { VRType = VR::SQ };
24251 enum { VMType = VM::VM1 };
24252 static const char* GetVMString() { return "1"; }
24253 };
24254 template <> struct TagToType<0x3006,0x00c0> {
24255 static const char* GetVRString() { return "SQ"; }
24256 typedef VRToType<VR::SQ>::Type Type;
24257 enum : long long { VRType = VR::SQ };
24258 enum { VMType = VM::VM1 };
24259 static const char* GetVMString() { return "1"; }
24260 };
24261 template <> struct TagToType<0x3006,0x00c2> {
24262 static const char* GetVRString() { return "UI"; }
24263 typedef VRToType<VR::UI>::Type Type;
24264 enum : long long { VRType = VR::UI };
24265 enum { VMType = VM::VM1 };
24266 static const char* GetVMString() { return "1"; }
24267 };
24268 template <> struct TagToType<0x3006,0x00c4> {
24269 static const char* GetVRString() { return "CS"; }
24270 typedef VRToType<VR::CS>::Type Type;
24271 enum : long long { VRType = VR::CS };
24272 enum { VMType = VM::VM1 };
24273 static const char* GetVMString() { return "1"; }
24274 };
24275 template <> struct TagToType<0x3006,0x00c6> {
24276 static const char* GetVRString() { return "DS"; }
24277 typedef VRToType<VR::DS>::Type Type;
24278 enum : long long { VRType = VR::DS };
24279 enum { VMType = VM::VM16 };
24280 static const char* GetVMString() { return "16"; }
24281 };
24282 template <> struct TagToType<0x3006,0x00c8> {
24283 static const char* GetVRString() { return "LO"; }
24284 typedef VRToType<VR::LO>::Type Type;
24285 enum : long long { VRType = VR::LO };
24286 enum { VMType = VM::VM1 };
24287 static const char* GetVMString() { return "1"; }
24288 };
24289 template <> struct TagToType<0x3008,0x0010> {
24290 static const char* GetVRString() { return "SQ"; }
24291 typedef VRToType<VR::SQ>::Type Type;
24292 enum : long long { VRType = VR::SQ };
24293 enum { VMType = VM::VM1 };
24294 static const char* GetVMString() { return "1"; }
24295 };
24296 template <> struct TagToType<0x3008,0x0012> {
24297 static const char* GetVRString() { return "ST"; }
24298 typedef VRToType<VR::ST>::Type Type;
24299 enum : long long { VRType = VR::ST };
24300 enum { VMType = VM::VM1 };
24301 static const char* GetVMString() { return "1"; }
24302 };
24303 template <> struct TagToType<0x3008,0x0014> {
24304 static const char* GetVRString() { return "CS"; }
24305 typedef VRToType<VR::CS>::Type Type;
24306 enum : long long { VRType = VR::CS };
24307 enum { VMType = VM::VM1 };
24308 static const char* GetVMString() { return "1"; }
24309 };
24310 template <> struct TagToType<0x3008,0x0016> {
24311 static const char* GetVRString() { return "DS"; }
24312 typedef VRToType<VR::DS>::Type Type;
24313 enum : long long { VRType = VR::DS };
24314 enum { VMType = VM::VM1 };
24315 static const char* GetVMString() { return "1"; }
24316 };
24317 template <> struct TagToType<0x3008,0x0020> {
24318 static const char* GetVRString() { return "SQ"; }
24319 typedef VRToType<VR::SQ>::Type Type;
24320 enum : long long { VRType = VR::SQ };
24321 enum { VMType = VM::VM1 };
24322 static const char* GetVMString() { return "1"; }
24323 };
24324 template <> struct TagToType<0x3008,0x0021> {
24325 static const char* GetVRString() { return "SQ"; }
24326 typedef VRToType<VR::SQ>::Type Type;
24327 enum : long long { VRType = VR::SQ };
24328 enum { VMType = VM::VM1 };
24329 static const char* GetVMString() { return "1"; }
24330 };
24331 template <> struct TagToType<0x3008,0x0022> {
24332 static const char* GetVRString() { return "IS"; }
24333 typedef VRToType<VR::IS>::Type Type;
24334 enum : long long { VRType = VR::IS };
24335 enum { VMType = VM::VM1 };
24336 static const char* GetVMString() { return "1"; }
24337 };
24338 template <> struct TagToType<0x3008,0x0024> {
24339 static const char* GetVRString() { return "DA"; }
24340 typedef VRToType<VR::DA>::Type Type;
24341 enum : long long { VRType = VR::DA };
24342 enum { VMType = VM::VM1 };
24343 static const char* GetVMString() { return "1"; }
24344 };
24345 template <> struct TagToType<0x3008,0x0025> {
24346 static const char* GetVRString() { return "TM"; }
24347 typedef VRToType<VR::TM>::Type Type;
24348 enum : long long { VRType = VR::TM };
24349 enum { VMType = VM::VM1 };
24350 static const char* GetVMString() { return "1"; }
24351 };
24352 template <> struct TagToType<0x3008,0x002a> {
24353 static const char* GetVRString() { return "CS"; }
24354 typedef VRToType<VR::CS>::Type Type;
24355 enum : long long { VRType = VR::CS };
24356 enum { VMType = VM::VM1 };
24357 static const char* GetVMString() { return "1"; }
24358 };
24359 template <> struct TagToType<0x3008,0x002b> {
24360 static const char* GetVRString() { return "SH"; }
24361 typedef VRToType<VR::SH>::Type Type;
24362 enum : long long { VRType = VR::SH };
24363 enum { VMType = VM::VM1 };
24364 static const char* GetVMString() { return "1"; }
24365 };
24366 template <> struct TagToType<0x3008,0x002c> {
24367 static const char* GetVRString() { return "CS"; }
24368 typedef VRToType<VR::CS>::Type Type;
24369 enum : long long { VRType = VR::CS };
24370 enum { VMType = VM::VM1 };
24371 static const char* GetVMString() { return "1"; }
24372 };
24373 template <> struct TagToType<0x3008,0x0030> {
24374 static const char* GetVRString() { return "SQ"; }
24375 typedef VRToType<VR::SQ>::Type Type;
24376 enum : long long { VRType = VR::SQ };
24377 enum { VMType = VM::VM1 };
24378 static const char* GetVMString() { return "1"; }
24379 };
24380 template <> struct TagToType<0x3008,0x0032> {
24381 static const char* GetVRString() { return "DS"; }
24382 typedef VRToType<VR::DS>::Type Type;
24383 enum : long long { VRType = VR::DS };
24384 enum { VMType = VM::VM1 };
24385 static const char* GetVMString() { return "1"; }
24386 };
24387 template <> struct TagToType<0x3008,0x0033> {
24388 static const char* GetVRString() { return "DS"; }
24389 typedef VRToType<VR::DS>::Type Type;
24390 enum : long long { VRType = VR::DS };
24391 enum { VMType = VM::VM1 };
24392 static const char* GetVMString() { return "1"; }
24393 };
24394 template <> struct TagToType<0x3008,0x0036> {
24395 static const char* GetVRString() { return "DS"; }
24396 typedef VRToType<VR::DS>::Type Type;
24397 enum : long long { VRType = VR::DS };
24398 enum { VMType = VM::VM1 };
24399 static const char* GetVMString() { return "1"; }
24400 };
24401 template <> struct TagToType<0x3008,0x0037> {
24402 static const char* GetVRString() { return "DS"; }
24403 typedef VRToType<VR::DS>::Type Type;
24404 enum : long long { VRType = VR::DS };
24405 enum { VMType = VM::VM1 };
24406 static const char* GetVMString() { return "1"; }
24407 };
24408 template <> struct TagToType<0x3008,0x003a> {
24409 static const char* GetVRString() { return "DS"; }
24410 typedef VRToType<VR::DS>::Type Type;
24411 enum : long long { VRType = VR::DS };
24412 enum { VMType = VM::VM1 };
24413 static const char* GetVMString() { return "1"; }
24414 };
24415 template <> struct TagToType<0x3008,0x003b> {
24416 static const char* GetVRString() { return "DS"; }
24417 typedef VRToType<VR::DS>::Type Type;
24418 enum : long long { VRType = VR::DS };
24419 enum { VMType = VM::VM1 };
24420 static const char* GetVMString() { return "1"; }
24421 };
24422 template <> struct TagToType<0x3008,0x0040> {
24423 static const char* GetVRString() { return "SQ"; }
24424 typedef VRToType<VR::SQ>::Type Type;
24425 enum : long long { VRType = VR::SQ };
24426 enum { VMType = VM::VM1 };
24427 static const char* GetVMString() { return "1"; }
24428 };
24429 template <> struct TagToType<0x3008,0x0041> {
24430 static const char* GetVRString() { return "SQ"; }
24431 typedef VRToType<VR::SQ>::Type Type;
24432 enum : long long { VRType = VR::SQ };
24433 enum { VMType = VM::VM1 };
24434 static const char* GetVMString() { return "1"; }
24435 };
24436 template <> struct TagToType<0x3008,0x0042> {
24437 static const char* GetVRString() { return "DS"; }
24438 typedef VRToType<VR::DS>::Type Type;
24439 enum : long long { VRType = VR::DS };
24440 enum { VMType = VM::VM1 };
24441 static const char* GetVMString() { return "1"; }
24442 };
24443 template <> struct TagToType<0x3008,0x0044> {
24444 static const char* GetVRString() { return "DS"; }
24445 typedef VRToType<VR::DS>::Type Type;
24446 enum : long long { VRType = VR::DS };
24447 enum { VMType = VM::VM1 };
24448 static const char* GetVMString() { return "1"; }
24449 };
24450 template <> struct TagToType<0x3008,0x0045> {
24451 static const char* GetVRString() { return "FL"; }
24452 typedef VRToType<VR::FL>::Type Type;
24453 enum : long long { VRType = VR::FL };
24454 enum { VMType = VM::VM1 };
24455 static const char* GetVMString() { return "1"; }
24456 };
24457 template <> struct TagToType<0x3008,0x0046> {
24458 static const char* GetVRString() { return "FL"; }
24459 typedef VRToType<VR::FL>::Type Type;
24460 enum : long long { VRType = VR::FL };
24461 enum { VMType = VM::VM1 };
24462 static const char* GetVMString() { return "1"; }
24463 };
24464 template <> struct TagToType<0x3008,0x0047> {
24465 static const char* GetVRString() { return "FL"; }
24466 typedef VRToType<VR::FL>::Type Type;
24467 enum : long long { VRType = VR::FL };
24468 enum { VMType = VM::VM1_n };
24469 static const char* GetVMString() { return "1-n"; }
24470 };
24471 template <> struct TagToType<0x3008,0x0048> {
24472 static const char* GetVRString() { return "DS"; }
24473 typedef VRToType<VR::DS>::Type Type;
24474 enum : long long { VRType = VR::DS };
24475 enum { VMType = VM::VM1 };
24476 static const char* GetVMString() { return "1"; }
24477 };
24478 template <> struct TagToType<0x3008,0x0050> {
24479 static const char* GetVRString() { return "SQ"; }
24480 typedef VRToType<VR::SQ>::Type Type;
24481 enum : long long { VRType = VR::SQ };
24482 enum { VMType = VM::VM1 };
24483 static const char* GetVMString() { return "1"; }
24484 };
24485 template <> struct TagToType<0x3008,0x0052> {
24486 static const char* GetVRString() { return "DS"; }
24487 typedef VRToType<VR::DS>::Type Type;
24488 enum : long long { VRType = VR::DS };
24489 enum { VMType = VM::VM1 };
24490 static const char* GetVMString() { return "1"; }
24491 };
24492 template <> struct TagToType<0x3008,0x0054> {
24493 static const char* GetVRString() { return "DA"; }
24494 typedef VRToType<VR::DA>::Type Type;
24495 enum : long long { VRType = VR::DA };
24496 enum { VMType = VM::VM1 };
24497 static const char* GetVMString() { return "1"; }
24498 };
24499 template <> struct TagToType<0x3008,0x0056> {
24500 static const char* GetVRString() { return "DA"; }
24501 typedef VRToType<VR::DA>::Type Type;
24502 enum : long long { VRType = VR::DA };
24503 enum { VMType = VM::VM1 };
24504 static const char* GetVMString() { return "1"; }
24505 };
24506 template <> struct TagToType<0x3008,0x005a> {
24507 static const char* GetVRString() { return "IS"; }
24508 typedef VRToType<VR::IS>::Type Type;
24509 enum : long long { VRType = VR::IS };
24510 enum { VMType = VM::VM1 };
24511 static const char* GetVMString() { return "1"; }
24512 };
24513 template <> struct TagToType<0x3008,0x0060> {
24514 static const char* GetVRString() { return "SQ"; }
24515 typedef VRToType<VR::SQ>::Type Type;
24516 enum : long long { VRType = VR::SQ };
24517 enum { VMType = VM::VM1 };
24518 static const char* GetVMString() { return "1"; }
24519 };
24520 template <> struct TagToType<0x3008,0x0061> {
24521 static const char* GetVRString() { return "AT"; }
24522 typedef VRToType<VR::AT>::Type Type;
24523 enum : long long { VRType = VR::AT };
24524 enum { VMType = VM::VM1 };
24525 static const char* GetVMString() { return "1"; }
24526 };
24527 template <> struct TagToType<0x3008,0x0062> {
24528 static const char* GetVRString() { return "AT"; }
24529 typedef VRToType<VR::AT>::Type Type;
24530 enum : long long { VRType = VR::AT };
24531 enum { VMType = VM::VM1 };
24532 static const char* GetVMString() { return "1"; }
24533 };
24534 template <> struct TagToType<0x3008,0x0063> {
24535 static const char* GetVRString() { return "IS"; }
24536 typedef VRToType<VR::IS>::Type Type;
24537 enum : long long { VRType = VR::IS };
24538 enum { VMType = VM::VM1 };
24539 static const char* GetVMString() { return "1"; }
24540 };
24541 template <> struct TagToType<0x3008,0x0064> {
24542 static const char* GetVRString() { return "IS"; }
24543 typedef VRToType<VR::IS>::Type Type;
24544 enum : long long { VRType = VR::IS };
24545 enum { VMType = VM::VM1 };
24546 static const char* GetVMString() { return "1"; }
24547 };
24548 template <> struct TagToType<0x3008,0x0065> {
24549 static const char* GetVRString() { return "AT"; }
24550 typedef VRToType<VR::AT>::Type Type;
24551 enum : long long { VRType = VR::AT };
24552 enum { VMType = VM::VM1 };
24553 static const char* GetVMString() { return "1"; }
24554 };
24555 template <> struct TagToType<0x3008,0x0066> {
24556 static const char* GetVRString() { return "ST"; }
24557 typedef VRToType<VR::ST>::Type Type;
24558 enum : long long { VRType = VR::ST };
24559 enum { VMType = VM::VM1 };
24560 static const char* GetVMString() { return "1"; }
24561 };
24562 template <> struct TagToType<0x3008,0x0067> {
24563 static const char* GetVRString() { return "US"; }
24564 typedef VRToType<VR::US>::Type Type;
24565 enum : long long { VRType = VR::US };
24566 enum { VMType = VM::VM1 };
24567 static const char* GetVMString() { return "1"; }
24568 };
24569 template <> struct TagToType<0x3008,0x0068> {
24570 static const char* GetVRString() { return "SQ"; }
24571 typedef VRToType<VR::SQ>::Type Type;
24572 enum : long long { VRType = VR::SQ };
24573 enum { VMType = VM::VM1 };
24574 static const char* GetVMString() { return "1"; }
24575 };
24576 template <> struct TagToType<0x3008,0x006a> {
24577 static const char* GetVRString() { return "FL"; }
24578 typedef VRToType<VR::FL>::Type Type;
24579 enum : long long { VRType = VR::FL };
24580 enum { VMType = VM::VM1 };
24581 static const char* GetVMString() { return "1"; }
24582 };
24583 template <> struct TagToType<0x3008,0x0070> {
24584 static const char* GetVRString() { return "SQ"; }
24585 typedef VRToType<VR::SQ>::Type Type;
24586 enum : long long { VRType = VR::SQ };
24587 enum { VMType = VM::VM1 };
24588 static const char* GetVMString() { return "1"; }
24589 };
24590 template <> struct TagToType<0x3008,0x0072> {
24591 static const char* GetVRString() { return "IS"; }
24592 typedef VRToType<VR::IS>::Type Type;
24593 enum : long long { VRType = VR::IS };
24594 enum { VMType = VM::VM1 };
24595 static const char* GetVMString() { return "1"; }
24596 };
24597 template <> struct TagToType<0x3008,0x0074> {
24598 static const char* GetVRString() { return "ST"; }
24599 typedef VRToType<VR::ST>::Type Type;
24600 enum : long long { VRType = VR::ST };
24601 enum { VMType = VM::VM1 };
24602 static const char* GetVMString() { return "1"; }
24603 };
24604 template <> struct TagToType<0x3008,0x0076> {
24605 static const char* GetVRString() { return "DS"; }
24606 typedef VRToType<VR::DS>::Type Type;
24607 enum : long long { VRType = VR::DS };
24608 enum { VMType = VM::VM1 };
24609 static const char* GetVMString() { return "1"; }
24610 };
24611 template <> struct TagToType<0x3008,0x0078> {
24612 static const char* GetVRString() { return "DS"; }
24613 typedef VRToType<VR::DS>::Type Type;
24614 enum : long long { VRType = VR::DS };
24615 enum { VMType = VM::VM1 };
24616 static const char* GetVMString() { return "1"; }
24617 };
24618 template <> struct TagToType<0x3008,0x007a> {
24619 static const char* GetVRString() { return "DS"; }
24620 typedef VRToType<VR::DS>::Type Type;
24621 enum : long long { VRType = VR::DS };
24622 enum { VMType = VM::VM1 };
24623 static const char* GetVMString() { return "1"; }
24624 };
24625 template <> struct TagToType<0x3008,0x0080> {
24626 static const char* GetVRString() { return "SQ"; }
24627 typedef VRToType<VR::SQ>::Type Type;
24628 enum : long long { VRType = VR::SQ };
24629 enum { VMType = VM::VM1 };
24630 static const char* GetVMString() { return "1"; }
24631 };
24632 template <> struct TagToType<0x3008,0x0082> {
24633 static const char* GetVRString() { return "IS"; }
24634 typedef VRToType<VR::IS>::Type Type;
24635 enum : long long { VRType = VR::IS };
24636 enum { VMType = VM::VM1 };
24637 static const char* GetVMString() { return "1"; }
24638 };
24639 template <> struct TagToType<0x3008,0x0090> {
24640 static const char* GetVRString() { return "SQ"; }
24641 typedef VRToType<VR::SQ>::Type Type;
24642 enum : long long { VRType = VR::SQ };
24643 enum { VMType = VM::VM1 };
24644 static const char* GetVMString() { return "1"; }
24645 };
24646 template <> struct TagToType<0x3008,0x0092> {
24647 static const char* GetVRString() { return "IS"; }
24648 typedef VRToType<VR::IS>::Type Type;
24649 enum : long long { VRType = VR::IS };
24650 enum { VMType = VM::VM1 };
24651 static const char* GetVMString() { return "1"; }
24652 };
24653 template <> struct TagToType<0x3008,0x00a0> {
24654 static const char* GetVRString() { return "SQ"; }
24655 typedef VRToType<VR::SQ>::Type Type;
24656 enum : long long { VRType = VR::SQ };
24657 enum { VMType = VM::VM1 };
24658 static const char* GetVMString() { return "1"; }
24659 };
24660 template <> struct TagToType<0x3008,0x00b0> {
24661 static const char* GetVRString() { return "SQ"; }
24662 typedef VRToType<VR::SQ>::Type Type;
24663 enum : long long { VRType = VR::SQ };
24664 enum { VMType = VM::VM1 };
24665 static const char* GetVMString() { return "1"; }
24666 };
24667 template <> struct TagToType<0x3008,0x00c0> {
24668 static const char* GetVRString() { return "SQ"; }
24669 typedef VRToType<VR::SQ>::Type Type;
24670 enum : long long { VRType = VR::SQ };
24671 enum { VMType = VM::VM1 };
24672 static const char* GetVMString() { return "1"; }
24673 };
24674 template <> struct TagToType<0x3008,0x00d0> {
24675 static const char* GetVRString() { return "SQ"; }
24676 typedef VRToType<VR::SQ>::Type Type;
24677 enum : long long { VRType = VR::SQ };
24678 enum { VMType = VM::VM1 };
24679 static const char* GetVMString() { return "1"; }
24680 };
24681 template <> struct TagToType<0x3008,0x00e0> {
24682 static const char* GetVRString() { return "SQ"; }
24683 typedef VRToType<VR::SQ>::Type Type;
24684 enum : long long { VRType = VR::SQ };
24685 enum { VMType = VM::VM1 };
24686 static const char* GetVMString() { return "1"; }
24687 };
24688 template <> struct TagToType<0x3008,0x00f0> {
24689 static const char* GetVRString() { return "SQ"; }
24690 typedef VRToType<VR::SQ>::Type Type;
24691 enum : long long { VRType = VR::SQ };
24692 enum { VMType = VM::VM1 };
24693 static const char* GetVMString() { return "1"; }
24694 };
24695 template <> struct TagToType<0x3008,0x00f2> {
24696 static const char* GetVRString() { return "SQ"; }
24697 typedef VRToType<VR::SQ>::Type Type;
24698 enum : long long { VRType = VR::SQ };
24699 enum { VMType = VM::VM1 };
24700 static const char* GetVMString() { return "1"; }
24701 };
24702 template <> struct TagToType<0x3008,0x00f4> {
24703 static const char* GetVRString() { return "SQ"; }
24704 typedef VRToType<VR::SQ>::Type Type;
24705 enum : long long { VRType = VR::SQ };
24706 enum { VMType = VM::VM1 };
24707 static const char* GetVMString() { return "1"; }
24708 };
24709 template <> struct TagToType<0x3008,0x00f6> {
24710 static const char* GetVRString() { return "SQ"; }
24711 typedef VRToType<VR::SQ>::Type Type;
24712 enum : long long { VRType = VR::SQ };
24713 enum { VMType = VM::VM1 };
24714 static const char* GetVMString() { return "1"; }
24715 };
24716 template <> struct TagToType<0x3008,0x0100> {
24717 static const char* GetVRString() { return "SQ"; }
24718 typedef VRToType<VR::SQ>::Type Type;
24719 enum : long long { VRType = VR::SQ };
24720 enum { VMType = VM::VM1 };
24721 static const char* GetVMString() { return "1"; }
24722 };
24723 template <> struct TagToType<0x3008,0x0105> {
24724 static const char* GetVRString() { return "LO"; }
24725 typedef VRToType<VR::LO>::Type Type;
24726 enum : long long { VRType = VR::LO };
24727 enum { VMType = VM::VM1 };
24728 static const char* GetVMString() { return "1"; }
24729 };
24730 template <> struct TagToType<0x3008,0x0110> {
24731 static const char* GetVRString() { return "SQ"; }
24732 typedef VRToType<VR::SQ>::Type Type;
24733 enum : long long { VRType = VR::SQ };
24734 enum { VMType = VM::VM1 };
24735 static const char* GetVMString() { return "1"; }
24736 };
24737 template <> struct TagToType<0x3008,0x0116> {
24738 static const char* GetVRString() { return "CS"; }
24739 typedef VRToType<VR::CS>::Type Type;
24740 enum : long long { VRType = VR::CS };
24741 enum { VMType = VM::VM1 };
24742 static const char* GetVMString() { return "1"; }
24743 };
24744 template <> struct TagToType<0x3008,0x0120> {
24745 static const char* GetVRString() { return "SQ"; }
24746 typedef VRToType<VR::SQ>::Type Type;
24747 enum : long long { VRType = VR::SQ };
24748 enum { VMType = VM::VM1 };
24749 static const char* GetVMString() { return "1"; }
24750 };
24751 template <> struct TagToType<0x3008,0x0122> {
24752 static const char* GetVRString() { return "IS"; }
24753 typedef VRToType<VR::IS>::Type Type;
24754 enum : long long { VRType = VR::IS };
24755 enum { VMType = VM::VM1 };
24756 static const char* GetVMString() { return "1"; }
24757 };
24758 template <> struct TagToType<0x3008,0x0130> {
24759 static const char* GetVRString() { return "SQ"; }
24760 typedef VRToType<VR::SQ>::Type Type;
24761 enum : long long { VRType = VR::SQ };
24762 enum { VMType = VM::VM1 };
24763 static const char* GetVMString() { return "1"; }
24764 };
24765 template <> struct TagToType<0x3008,0x0132> {
24766 static const char* GetVRString() { return "DS"; }
24767 typedef VRToType<VR::DS>::Type Type;
24768 enum : long long { VRType = VR::DS };
24769 enum { VMType = VM::VM1 };
24770 static const char* GetVMString() { return "1"; }
24771 };
24772 template <> struct TagToType<0x3008,0x0134> {
24773 static const char* GetVRString() { return "DS"; }
24774 typedef VRToType<VR::DS>::Type Type;
24775 enum : long long { VRType = VR::DS };
24776 enum { VMType = VM::VM1 };
24777 static const char* GetVMString() { return "1"; }
24778 };
24779 template <> struct TagToType<0x3008,0x0136> {
24780 static const char* GetVRString() { return "IS"; }
24781 typedef VRToType<VR::IS>::Type Type;
24782 enum : long long { VRType = VR::IS };
24783 enum { VMType = VM::VM1 };
24784 static const char* GetVMString() { return "1"; }
24785 };
24786 template <> struct TagToType<0x3008,0x0138> {
24787 static const char* GetVRString() { return "IS"; }
24788 typedef VRToType<VR::IS>::Type Type;
24789 enum : long long { VRType = VR::IS };
24790 enum { VMType = VM::VM1 };
24791 static const char* GetVMString() { return "1"; }
24792 };
24793 template <> struct TagToType<0x3008,0x013a> {
24794 static const char* GetVRString() { return "DS"; }
24795 typedef VRToType<VR::DS>::Type Type;
24796 enum : long long { VRType = VR::DS };
24797 enum { VMType = VM::VM1 };
24798 static const char* GetVMString() { return "1"; }
24799 };
24800 template <> struct TagToType<0x3008,0x013c> {
24801 static const char* GetVRString() { return "DS"; }
24802 typedef VRToType<VR::DS>::Type Type;
24803 enum : long long { VRType = VR::DS };
24804 enum { VMType = VM::VM1 };
24805 static const char* GetVMString() { return "1"; }
24806 };
24807 template <> struct TagToType<0x3008,0x0140> {
24808 static const char* GetVRString() { return "SQ"; }
24809 typedef VRToType<VR::SQ>::Type Type;
24810 enum : long long { VRType = VR::SQ };
24811 enum { VMType = VM::VM1 };
24812 static const char* GetVMString() { return "1"; }
24813 };
24814 template <> struct TagToType<0x3008,0x0142> {
24815 static const char* GetVRString() { return "IS"; }
24816 typedef VRToType<VR::IS>::Type Type;
24817 enum : long long { VRType = VR::IS };
24818 enum { VMType = VM::VM1 };
24819 static const char* GetVMString() { return "1"; }
24820 };
24821 template <> struct TagToType<0x3008,0x0150> {
24822 static const char* GetVRString() { return "SQ"; }
24823 typedef VRToType<VR::SQ>::Type Type;
24824 enum : long long { VRType = VR::SQ };
24825 enum { VMType = VM::VM1 };
24826 static const char* GetVMString() { return "1"; }
24827 };
24828 template <> struct TagToType<0x3008,0x0152> {
24829 static const char* GetVRString() { return "IS"; }
24830 typedef VRToType<VR::IS>::Type Type;
24831 enum : long long { VRType = VR::IS };
24832 enum { VMType = VM::VM1 };
24833 static const char* GetVMString() { return "1"; }
24834 };
24835 template <> struct TagToType<0x3008,0x0160> {
24836 static const char* GetVRString() { return "SQ"; }
24837 typedef VRToType<VR::SQ>::Type Type;
24838 enum : long long { VRType = VR::SQ };
24839 enum { VMType = VM::VM1 };
24840 static const char* GetVMString() { return "1"; }
24841 };
24842 template <> struct TagToType<0x3008,0x0162> {
24843 static const char* GetVRString() { return "DA"; }
24844 typedef VRToType<VR::DA>::Type Type;
24845 enum : long long { VRType = VR::DA };
24846 enum { VMType = VM::VM1 };
24847 static const char* GetVMString() { return "1"; }
24848 };
24849 template <> struct TagToType<0x3008,0x0164> {
24850 static const char* GetVRString() { return "TM"; }
24851 typedef VRToType<VR::TM>::Type Type;
24852 enum : long long { VRType = VR::TM };
24853 enum { VMType = VM::VM1 };
24854 static const char* GetVMString() { return "1"; }
24855 };
24856 template <> struct TagToType<0x3008,0x0166> {
24857 static const char* GetVRString() { return "DA"; }
24858 typedef VRToType<VR::DA>::Type Type;
24859 enum : long long { VRType = VR::DA };
24860 enum { VMType = VM::VM1 };
24861 static const char* GetVMString() { return "1"; }
24862 };
24863 template <> struct TagToType<0x3008,0x0168> {
24864 static const char* GetVRString() { return "TM"; }
24865 typedef VRToType<VR::TM>::Type Type;
24866 enum : long long { VRType = VR::TM };
24867 enum { VMType = VM::VM1 };
24868 static const char* GetVMString() { return "1"; }
24869 };
24870 template <> struct TagToType<0x3008,0x0171> {
24871 static const char* GetVRString() { return "SQ"; }
24872 typedef VRToType<VR::SQ>::Type Type;
24873 enum : long long { VRType = VR::SQ };
24874 enum { VMType = VM::VM1 };
24875 static const char* GetVMString() { return "1"; }
24876 };
24877 template <> struct TagToType<0x3008,0x0172> {
24878 static const char* GetVRString() { return "US"; }
24879 typedef VRToType<VR::US>::Type Type;
24880 enum : long long { VRType = VR::US };
24881 enum { VMType = VM::VM1 };
24882 static const char* GetVMString() { return "1"; }
24883 };
24884 template <> struct TagToType<0x3008,0x0173> {
24885 static const char* GetVRString() { return "SQ"; }
24886 typedef VRToType<VR::SQ>::Type Type;
24887 enum : long long { VRType = VR::SQ };
24888 enum { VMType = VM::VM1 };
24889 static const char* GetVMString() { return "1"; }
24890 };
24891 template <> struct TagToType<0x3008,0x0200> {
24892 static const char* GetVRString() { return "CS"; }
24893 typedef VRToType<VR::CS>::Type Type;
24894 enum : long long { VRType = VR::CS };
24895 enum { VMType = VM::VM1 };
24896 static const char* GetVMString() { return "1"; }
24897 };
24898 template <> struct TagToType<0x3008,0x0202> {
24899 static const char* GetVRString() { return "ST"; }
24900 typedef VRToType<VR::ST>::Type Type;
24901 enum : long long { VRType = VR::ST };
24902 enum { VMType = VM::VM1 };
24903 static const char* GetVMString() { return "1"; }
24904 };
24905 template <> struct TagToType<0x3008,0x0220> {
24906 static const char* GetVRString() { return "SQ"; }
24907 typedef VRToType<VR::SQ>::Type Type;
24908 enum : long long { VRType = VR::SQ };
24909 enum { VMType = VM::VM1 };
24910 static const char* GetVMString() { return "1"; }
24911 };
24912 template <> struct TagToType<0x3008,0x0223> {
24913 static const char* GetVRString() { return "IS"; }
24914 typedef VRToType<VR::IS>::Type Type;
24915 enum : long long { VRType = VR::IS };
24916 enum { VMType = VM::VM1 };
24917 static const char* GetVMString() { return "1"; }
24918 };
24919 template <> struct TagToType<0x3008,0x0224> {
24920 static const char* GetVRString() { return "CS"; }
24921 typedef VRToType<VR::CS>::Type Type;
24922 enum : long long { VRType = VR::CS };
24923 enum { VMType = VM::VM1 };
24924 static const char* GetVMString() { return "1"; }
24925 };
24926 template <> struct TagToType<0x3008,0x0230> {
24927 static const char* GetVRString() { return "CS"; }
24928 typedef VRToType<VR::CS>::Type Type;
24929 enum : long long { VRType = VR::CS };
24930 enum { VMType = VM::VM1 };
24931 static const char* GetVMString() { return "1"; }
24932 };
24933 template <> struct TagToType<0x3008,0x0240> {
24934 static const char* GetVRString() { return "SQ"; }
24935 typedef VRToType<VR::SQ>::Type Type;
24936 enum : long long { VRType = VR::SQ };
24937 enum { VMType = VM::VM1 };
24938 static const char* GetVMString() { return "1"; }
24939 };
24940 template <> struct TagToType<0x3008,0x0250> {
24941 static const char* GetVRString() { return "DA"; }
24942 typedef VRToType<VR::DA>::Type Type;
24943 enum : long long { VRType = VR::DA };
24944 enum { VMType = VM::VM1 };
24945 static const char* GetVMString() { return "1"; }
24946 };
24947 template <> struct TagToType<0x3008,0x0251> {
24948 static const char* GetVRString() { return "TM"; }
24949 typedef VRToType<VR::TM>::Type Type;
24950 enum : long long { VRType = VR::TM };
24951 enum { VMType = VM::VM1 };
24952 static const char* GetVMString() { return "1"; }
24953 };
24954 template <> struct TagToType<0x300a,0x0002> {
24955 static const char* GetVRString() { return "SH"; }
24956 typedef VRToType<VR::SH>::Type Type;
24957 enum : long long { VRType = VR::SH };
24958 enum { VMType = VM::VM1 };
24959 static const char* GetVMString() { return "1"; }
24960 };
24961 template <> struct TagToType<0x300a,0x0003> {
24962 static const char* GetVRString() { return "LO"; }
24963 typedef VRToType<VR::LO>::Type Type;
24964 enum : long long { VRType = VR::LO };
24965 enum { VMType = VM::VM1 };
24966 static const char* GetVMString() { return "1"; }
24967 };
24968 template <> struct TagToType<0x300a,0x0004> {
24969 static const char* GetVRString() { return "ST"; }
24970 typedef VRToType<VR::ST>::Type Type;
24971 enum : long long { VRType = VR::ST };
24972 enum { VMType = VM::VM1 };
24973 static const char* GetVMString() { return "1"; }
24974 };
24975 template <> struct TagToType<0x300a,0x0006> {
24976 static const char* GetVRString() { return "DA"; }
24977 typedef VRToType<VR::DA>::Type Type;
24978 enum : long long { VRType = VR::DA };
24979 enum { VMType = VM::VM1 };
24980 static const char* GetVMString() { return "1"; }
24981 };
24982 template <> struct TagToType<0x300a,0x0007> {
24983 static const char* GetVRString() { return "TM"; }
24984 typedef VRToType<VR::TM>::Type Type;
24985 enum : long long { VRType = VR::TM };
24986 enum { VMType = VM::VM1 };
24987 static const char* GetVMString() { return "1"; }
24988 };
24989 template <> struct TagToType<0x300a,0x0009> {
24990 static const char* GetVRString() { return "LO"; }
24991 typedef VRToType<VR::LO>::Type Type;
24992 enum : long long { VRType = VR::LO };
24993 enum { VMType = VM::VM1_n };
24994 static const char* GetVMString() { return "1-n"; }
24995 };
24996 template <> struct TagToType<0x300a,0x000a> {
24997 static const char* GetVRString() { return "CS"; }
24998 typedef VRToType<VR::CS>::Type Type;
24999 enum : long long { VRType = VR::CS };
25000 enum { VMType = VM::VM1 };
25001 static const char* GetVMString() { return "1"; }
25002 };
25003 template <> struct TagToType<0x300a,0x000b> {
25004 static const char* GetVRString() { return "LO"; }
25005 typedef VRToType<VR::LO>::Type Type;
25006 enum : long long { VRType = VR::LO };
25007 enum { VMType = VM::VM1_n };
25008 static const char* GetVMString() { return "1-n"; }
25009 };
25010 template <> struct TagToType<0x300a,0x000c> {
25011 static const char* GetVRString() { return "CS"; }
25012 typedef VRToType<VR::CS>::Type Type;
25013 enum : long long { VRType = VR::CS };
25014 enum { VMType = VM::VM1 };
25015 static const char* GetVMString() { return "1"; }
25016 };
25017 template <> struct TagToType<0x300a,0x000e> {
25018 static const char* GetVRString() { return "ST"; }
25019 typedef VRToType<VR::ST>::Type Type;
25020 enum : long long { VRType = VR::ST };
25021 enum { VMType = VM::VM1 };
25022 static const char* GetVMString() { return "1"; }
25023 };
25024 template <> struct TagToType<0x300a,0x0010> {
25025 static const char* GetVRString() { return "SQ"; }
25026 typedef VRToType<VR::SQ>::Type Type;
25027 enum : long long { VRType = VR::SQ };
25028 enum { VMType = VM::VM1 };
25029 static const char* GetVMString() { return "1"; }
25030 };
25031 template <> struct TagToType<0x300a,0x0012> {
25032 static const char* GetVRString() { return "IS"; }
25033 typedef VRToType<VR::IS>::Type Type;
25034 enum : long long { VRType = VR::IS };
25035 enum { VMType = VM::VM1 };
25036 static const char* GetVMString() { return "1"; }
25037 };
25038 template <> struct TagToType<0x300a,0x0013> {
25039 static const char* GetVRString() { return "UI"; }
25040 typedef VRToType<VR::UI>::Type Type;
25041 enum : long long { VRType = VR::UI };
25042 enum { VMType = VM::VM1 };
25043 static const char* GetVMString() { return "1"; }
25044 };
25045 template <> struct TagToType<0x300a,0x0014> {
25046 static const char* GetVRString() { return "CS"; }
25047 typedef VRToType<VR::CS>::Type Type;
25048 enum : long long { VRType = VR::CS };
25049 enum { VMType = VM::VM1 };
25050 static const char* GetVMString() { return "1"; }
25051 };
25052 template <> struct TagToType<0x300a,0x0015> {
25053 static const char* GetVRString() { return "CS"; }
25054 typedef VRToType<VR::CS>::Type Type;
25055 enum : long long { VRType = VR::CS };
25056 enum { VMType = VM::VM1 };
25057 static const char* GetVMString() { return "1"; }
25058 };
25059 template <> struct TagToType<0x300a,0x0016> {
25060 static const char* GetVRString() { return "LO"; }
25061 typedef VRToType<VR::LO>::Type Type;
25062 enum : long long { VRType = VR::LO };
25063 enum { VMType = VM::VM1 };
25064 static const char* GetVMString() { return "1"; }
25065 };
25066 template <> struct TagToType<0x300a,0x0018> {
25067 static const char* GetVRString() { return "DS"; }
25068 typedef VRToType<VR::DS>::Type Type;
25069 enum : long long { VRType = VR::DS };
25070 enum { VMType = VM::VM3 };
25071 static const char* GetVMString() { return "3"; }
25072 };
25073 template <> struct TagToType<0x300a,0x001a> {
25074 static const char* GetVRString() { return "DS"; }
25075 typedef VRToType<VR::DS>::Type Type;
25076 enum : long long { VRType = VR::DS };
25077 enum { VMType = VM::VM1 };
25078 static const char* GetVMString() { return "1"; }
25079 };
25080 template <> struct TagToType<0x300a,0x0020> {
25081 static const char* GetVRString() { return "CS"; }
25082 typedef VRToType<VR::CS>::Type Type;
25083 enum : long long { VRType = VR::CS };
25084 enum { VMType = VM::VM1 };
25085 static const char* GetVMString() { return "1"; }
25086 };
25087 template <> struct TagToType<0x300a,0x0021> {
25088 static const char* GetVRString() { return "DS"; }
25089 typedef VRToType<VR::DS>::Type Type;
25090 enum : long long { VRType = VR::DS };
25091 enum { VMType = VM::VM1 };
25092 static const char* GetVMString() { return "1"; }
25093 };
25094 template <> struct TagToType<0x300a,0x0022> {
25095 static const char* GetVRString() { return "DS"; }
25096 typedef VRToType<VR::DS>::Type Type;
25097 enum : long long { VRType = VR::DS };
25098 enum { VMType = VM::VM1 };
25099 static const char* GetVMString() { return "1"; }
25100 };
25101 template <> struct TagToType<0x300a,0x0023> {
25102 static const char* GetVRString() { return "DS"; }
25103 typedef VRToType<VR::DS>::Type Type;
25104 enum : long long { VRType = VR::DS };
25105 enum { VMType = VM::VM1 };
25106 static const char* GetVMString() { return "1"; }
25107 };
25108 template <> struct TagToType<0x300a,0x0025> {
25109 static const char* GetVRString() { return "DS"; }
25110 typedef VRToType<VR::DS>::Type Type;
25111 enum : long long { VRType = VR::DS };
25112 enum { VMType = VM::VM1 };
25113 static const char* GetVMString() { return "1"; }
25114 };
25115 template <> struct TagToType<0x300a,0x0026> {
25116 static const char* GetVRString() { return "DS"; }
25117 typedef VRToType<VR::DS>::Type Type;
25118 enum : long long { VRType = VR::DS };
25119 enum { VMType = VM::VM1 };
25120 static const char* GetVMString() { return "1"; }
25121 };
25122 template <> struct TagToType<0x300a,0x0027> {
25123 static const char* GetVRString() { return "DS"; }
25124 typedef VRToType<VR::DS>::Type Type;
25125 enum : long long { VRType = VR::DS };
25126 enum { VMType = VM::VM1 };
25127 static const char* GetVMString() { return "1"; }
25128 };
25129 template <> struct TagToType<0x300a,0x0028> {
25130 static const char* GetVRString() { return "DS"; }
25131 typedef VRToType<VR::DS>::Type Type;
25132 enum : long long { VRType = VR::DS };
25133 enum { VMType = VM::VM1 };
25134 static const char* GetVMString() { return "1"; }
25135 };
25136 template <> struct TagToType<0x300a,0x002a> {
25137 static const char* GetVRString() { return "DS"; }
25138 typedef VRToType<VR::DS>::Type Type;
25139 enum : long long { VRType = VR::DS };
25140 enum { VMType = VM::VM1 };
25141 static const char* GetVMString() { return "1"; }
25142 };
25143 template <> struct TagToType<0x300a,0x002b> {
25144 static const char* GetVRString() { return "DS"; }
25145 typedef VRToType<VR::DS>::Type Type;
25146 enum : long long { VRType = VR::DS };
25147 enum { VMType = VM::VM1 };
25148 static const char* GetVMString() { return "1"; }
25149 };
25150 template <> struct TagToType<0x300a,0x002c> {
25151 static const char* GetVRString() { return "DS"; }
25152 typedef VRToType<VR::DS>::Type Type;
25153 enum : long long { VRType = VR::DS };
25154 enum { VMType = VM::VM1 };
25155 static const char* GetVMString() { return "1"; }
25156 };
25157 template <> struct TagToType<0x300a,0x002d> {
25158 static const char* GetVRString() { return "DS"; }
25159 typedef VRToType<VR::DS>::Type Type;
25160 enum : long long { VRType = VR::DS };
25161 enum { VMType = VM::VM1 };
25162 static const char* GetVMString() { return "1"; }
25163 };
25164 template <> struct TagToType<0x300a,0x0040> {
25165 static const char* GetVRString() { return "SQ"; }
25166 typedef VRToType<VR::SQ>::Type Type;
25167 enum : long long { VRType = VR::SQ };
25168 enum { VMType = VM::VM1 };
25169 static const char* GetVMString() { return "1"; }
25170 };
25171 template <> struct TagToType<0x300a,0x0042> {
25172 static const char* GetVRString() { return "IS"; }
25173 typedef VRToType<VR::IS>::Type Type;
25174 enum : long long { VRType = VR::IS };
25175 enum { VMType = VM::VM1 };
25176 static const char* GetVMString() { return "1"; }
25177 };
25178 template <> struct TagToType<0x300a,0x0043> {
25179 static const char* GetVRString() { return "SH"; }
25180 typedef VRToType<VR::SH>::Type Type;
25181 enum : long long { VRType = VR::SH };
25182 enum { VMType = VM::VM1 };
25183 static const char* GetVMString() { return "1"; }
25184 };
25185 template <> struct TagToType<0x300a,0x0044> {
25186 static const char* GetVRString() { return "DS"; }
25187 typedef VRToType<VR::DS>::Type Type;
25188 enum : long long { VRType = VR::DS };
25189 enum { VMType = VM::VM1 };
25190 static const char* GetVMString() { return "1"; }
25191 };
25192 template <> struct TagToType<0x300a,0x0046> {
25193 static const char* GetVRString() { return "DS"; }
25194 typedef VRToType<VR::DS>::Type Type;
25195 enum : long long { VRType = VR::DS };
25196 enum { VMType = VM::VM1 };
25197 static const char* GetVMString() { return "1"; }
25198 };
25199 template <> struct TagToType<0x300a,0x0048> {
25200 static const char* GetVRString() { return "SQ"; }
25201 typedef VRToType<VR::SQ>::Type Type;
25202 enum : long long { VRType = VR::SQ };
25203 enum { VMType = VM::VM1 };
25204 static const char* GetVMString() { return "1"; }
25205 };
25206 template <> struct TagToType<0x300a,0x004a> {
25207 static const char* GetVRString() { return "DS"; }
25208 typedef VRToType<VR::DS>::Type Type;
25209 enum : long long { VRType = VR::DS };
25210 enum { VMType = VM::VM1 };
25211 static const char* GetVMString() { return "1"; }
25212 };
25213 template <> struct TagToType<0x300a,0x004b> {
25214 static const char* GetVRString() { return "FL"; }
25215 typedef VRToType<VR::FL>::Type Type;
25216 enum : long long { VRType = VR::FL };
25217 enum { VMType = VM::VM1 };
25218 static const char* GetVMString() { return "1"; }
25219 };
25220 template <> struct TagToType<0x300a,0x004c> {
25221 static const char* GetVRString() { return "DS"; }
25222 typedef VRToType<VR::DS>::Type Type;
25223 enum : long long { VRType = VR::DS };
25224 enum { VMType = VM::VM1 };
25225 static const char* GetVMString() { return "1"; }
25226 };
25227 template <> struct TagToType<0x300a,0x004e> {
25228 static const char* GetVRString() { return "DS"; }
25229 typedef VRToType<VR::DS>::Type Type;
25230 enum : long long { VRType = VR::DS };
25231 enum { VMType = VM::VM1 };
25232 static const char* GetVMString() { return "1"; }
25233 };
25234 template <> struct TagToType<0x300a,0x004f> {
25235 static const char* GetVRString() { return "FL"; }
25236 typedef VRToType<VR::FL>::Type Type;
25237 enum : long long { VRType = VR::FL };
25238 enum { VMType = VM::VM1 };
25239 static const char* GetVMString() { return "1"; }
25240 };
25241 template <> struct TagToType<0x300a,0x0050> {
25242 static const char* GetVRString() { return "FL"; }
25243 typedef VRToType<VR::FL>::Type Type;
25244 enum : long long { VRType = VR::FL };
25245 enum { VMType = VM::VM1 };
25246 static const char* GetVMString() { return "1"; }
25247 };
25248 template <> struct TagToType<0x300a,0x0051> {
25249 static const char* GetVRString() { return "DS"; }
25250 typedef VRToType<VR::DS>::Type Type;
25251 enum : long long { VRType = VR::DS };
25252 enum { VMType = VM::VM1 };
25253 static const char* GetVMString() { return "1"; }
25254 };
25255 template <> struct TagToType<0x300a,0x0052> {
25256 static const char* GetVRString() { return "DS"; }
25257 typedef VRToType<VR::DS>::Type Type;
25258 enum : long long { VRType = VR::DS };
25259 enum { VMType = VM::VM1 };
25260 static const char* GetVMString() { return "1"; }
25261 };
25262 template <> struct TagToType<0x300a,0x0053> {
25263 static const char* GetVRString() { return "DS"; }
25264 typedef VRToType<VR::DS>::Type Type;
25265 enum : long long { VRType = VR::DS };
25266 enum { VMType = VM::VM1 };
25267 static const char* GetVMString() { return "1"; }
25268 };
25269 template <> struct TagToType<0x300a,0x0055> {
25270 static const char* GetVRString() { return "CS"; }
25271 typedef VRToType<VR::CS>::Type Type;
25272 enum : long long { VRType = VR::CS };
25273 enum { VMType = VM::VM1 };
25274 static const char* GetVMString() { return "1"; }
25275 };
25276 template <> struct TagToType<0x300a,0x0070> {
25277 static const char* GetVRString() { return "SQ"; }
25278 typedef VRToType<VR::SQ>::Type Type;
25279 enum : long long { VRType = VR::SQ };
25280 enum { VMType = VM::VM1 };
25281 static const char* GetVMString() { return "1"; }
25282 };
25283 template <> struct TagToType<0x300a,0x0071> {
25284 static const char* GetVRString() { return "IS"; }
25285 typedef VRToType<VR::IS>::Type Type;
25286 enum : long long { VRType = VR::IS };
25287 enum { VMType = VM::VM1 };
25288 static const char* GetVMString() { return "1"; }
25289 };
25290 template <> struct TagToType<0x300a,0x0072> {
25291 static const char* GetVRString() { return "LO"; }
25292 typedef VRToType<VR::LO>::Type Type;
25293 enum : long long { VRType = VR::LO };
25294 enum { VMType = VM::VM1 };
25295 static const char* GetVMString() { return "1"; }
25296 };
25297 template <> struct TagToType<0x300a,0x0078> {
25298 static const char* GetVRString() { return "IS"; }
25299 typedef VRToType<VR::IS>::Type Type;
25300 enum : long long { VRType = VR::IS };
25301 enum { VMType = VM::VM1 };
25302 static const char* GetVMString() { return "1"; }
25303 };
25304 template <> struct TagToType<0x300a,0x0079> {
25305 static const char* GetVRString() { return "IS"; }
25306 typedef VRToType<VR::IS>::Type Type;
25307 enum : long long { VRType = VR::IS };
25308 enum { VMType = VM::VM1 };
25309 static const char* GetVMString() { return "1"; }
25310 };
25311 template <> struct TagToType<0x300a,0x007a> {
25312 static const char* GetVRString() { return "IS"; }
25313 typedef VRToType<VR::IS>::Type Type;
25314 enum : long long { VRType = VR::IS };
25315 enum { VMType = VM::VM1 };
25316 static const char* GetVMString() { return "1"; }
25317 };
25318 template <> struct TagToType<0x300a,0x007b> {
25319 static const char* GetVRString() { return "LT"; }
25320 typedef VRToType<VR::LT>::Type Type;
25321 enum : long long { VRType = VR::LT };
25322 enum { VMType = VM::VM1 };
25323 static const char* GetVMString() { return "1"; }
25324 };
25325 template <> struct TagToType<0x300a,0x0080> {
25326 static const char* GetVRString() { return "IS"; }
25327 typedef VRToType<VR::IS>::Type Type;
25328 enum : long long { VRType = VR::IS };
25329 enum { VMType = VM::VM1 };
25330 static const char* GetVMString() { return "1"; }
25331 };
25332 template <> struct TagToType<0x300a,0x0082> {
25333 static const char* GetVRString() { return "DS"; }
25334 typedef VRToType<VR::DS>::Type Type;
25335 enum : long long { VRType = VR::DS };
25336 enum { VMType = VM::VM3 };
25337 static const char* GetVMString() { return "3"; }
25338 };
25339 template <> struct TagToType<0x300a,0x0084> {
25340 static const char* GetVRString() { return "DS"; }
25341 typedef VRToType<VR::DS>::Type Type;
25342 enum : long long { VRType = VR::DS };
25343 enum { VMType = VM::VM1 };
25344 static const char* GetVMString() { return "1"; }
25345 };
25346 template <> struct TagToType<0x300a,0x0086> {
25347 static const char* GetVRString() { return "DS"; }
25348 typedef VRToType<VR::DS>::Type Type;
25349 enum : long long { VRType = VR::DS };
25350 enum { VMType = VM::VM1 };
25351 static const char* GetVMString() { return "1"; }
25352 };
25353 template <> struct TagToType<0x300a,0x0088> {
25354 static const char* GetVRString() { return "FL"; }
25355 typedef VRToType<VR::FL>::Type Type;
25356 enum : long long { VRType = VR::FL };
25357 enum { VMType = VM::VM1 };
25358 static const char* GetVMString() { return "1"; }
25359 };
25360 template <> struct TagToType<0x300a,0x0089> {
25361 static const char* GetVRString() { return "FL"; }
25362 typedef VRToType<VR::FL>::Type Type;
25363 enum : long long { VRType = VR::FL };
25364 enum { VMType = VM::VM1 };
25365 static const char* GetVMString() { return "1"; }
25366 };
25367 template <> struct TagToType<0x300a,0x008a> {
25368 static const char* GetVRString() { return "FL"; }
25369 typedef VRToType<VR::FL>::Type Type;
25370 enum : long long { VRType = VR::FL };
25371 enum { VMType = VM::VM1 };
25372 static const char* GetVMString() { return "1"; }
25373 };
25374 template <> struct TagToType<0x300a,0x008b> {
25375 static const char* GetVRString() { return "CS"; }
25376 typedef VRToType<VR::CS>::Type Type;
25377 enum : long long { VRType = VR::CS };
25378 enum { VMType = VM::VM1 };
25379 static const char* GetVMString() { return "1"; }
25380 };
25381 template <> struct TagToType<0x300a,0x008c> {
25382 static const char* GetVRString() { return "SQ"; }
25383 typedef VRToType<VR::SQ>::Type Type;
25384 enum : long long { VRType = VR::SQ };
25385 enum { VMType = VM::VM1 };
25386 static const char* GetVMString() { return "1"; }
25387 };
25388 template <> struct TagToType<0x300a,0x008d> {
25389 static const char* GetVRString() { return "FL"; }
25390 typedef VRToType<VR::FL>::Type Type;
25391 enum : long long { VRType = VR::FL };
25392 enum { VMType = VM::VM1 };
25393 static const char* GetVMString() { return "1"; }
25394 };
25395 template <> struct TagToType<0x300a,0x008e> {
25396 static const char* GetVRString() { return "FL"; }
25397 typedef VRToType<VR::FL>::Type Type;
25398 enum : long long { VRType = VR::FL };
25399 enum { VMType = VM::VM1 };
25400 static const char* GetVMString() { return "1"; }
25401 };
25402 template <> struct TagToType<0x300a,0x008f> {
25403 static const char* GetVRString() { return "FL"; }
25404 typedef VRToType<VR::FL>::Type Type;
25405 enum : long long { VRType = VR::FL };
25406 enum { VMType = VM::VM1 };
25407 static const char* GetVMString() { return "1"; }
25408 };
25409 template <> struct TagToType<0x300a,0x0090> {
25410 static const char* GetVRString() { return "CS"; }
25411 typedef VRToType<VR::CS>::Type Type;
25412 enum : long long { VRType = VR::CS };
25413 enum { VMType = VM::VM1 };
25414 static const char* GetVMString() { return "1"; }
25415 };
25416 template <> struct TagToType<0x300a,0x0091> {
25417 static const char* GetVRString() { return "DS"; }
25418 typedef VRToType<VR::DS>::Type Type;
25419 enum : long long { VRType = VR::DS };
25420 enum { VMType = VM::VM1 };
25421 static const char* GetVMString() { return "1"; }
25422 };
25423 template <> struct TagToType<0x300a,0x0092> {
25424 static const char* GetVRString() { return "CS"; }
25425 typedef VRToType<VR::CS>::Type Type;
25426 enum : long long { VRType = VR::CS };
25427 enum { VMType = VM::VM1 };
25428 static const char* GetVMString() { return "1"; }
25429 };
25430 template <> struct TagToType<0x300a,0x00a0> {
25431 static const char* GetVRString() { return "IS"; }
25432 typedef VRToType<VR::IS>::Type Type;
25433 enum : long long { VRType = VR::IS };
25434 enum { VMType = VM::VM1 };
25435 static const char* GetVMString() { return "1"; }
25436 };
25437 template <> struct TagToType<0x300a,0x00a2> {
25438 static const char* GetVRString() { return "DS"; }
25439 typedef VRToType<VR::DS>::Type Type;
25440 enum : long long { VRType = VR::DS };
25441 enum { VMType = VM::VM3 };
25442 static const char* GetVMString() { return "3"; }
25443 };
25444 template <> struct TagToType<0x300a,0x00a4> {
25445 static const char* GetVRString() { return "DS"; }
25446 typedef VRToType<VR::DS>::Type Type;
25447 enum : long long { VRType = VR::DS };
25448 enum { VMType = VM::VM1 };
25449 static const char* GetVMString() { return "1"; }
25450 };
25451 template <> struct TagToType<0x300a,0x00b0> {
25452 static const char* GetVRString() { return "SQ"; }
25453 typedef VRToType<VR::SQ>::Type Type;
25454 enum : long long { VRType = VR::SQ };
25455 enum { VMType = VM::VM1 };
25456 static const char* GetVMString() { return "1"; }
25457 };
25458 template <> struct TagToType<0x300a,0x00b2> {
25459 static const char* GetVRString() { return "SH"; }
25460 typedef VRToType<VR::SH>::Type Type;
25461 enum : long long { VRType = VR::SH };
25462 enum { VMType = VM::VM1 };
25463 static const char* GetVMString() { return "1"; }
25464 };
25465 template <> struct TagToType<0x300a,0x00b3> {
25466 static const char* GetVRString() { return "CS"; }
25467 typedef VRToType<VR::CS>::Type Type;
25468 enum : long long { VRType = VR::CS };
25469 enum { VMType = VM::VM1 };
25470 static const char* GetVMString() { return "1"; }
25471 };
25472 template <> struct TagToType<0x300a,0x00b4> {
25473 static const char* GetVRString() { return "DS"; }
25474 typedef VRToType<VR::DS>::Type Type;
25475 enum : long long { VRType = VR::DS };
25476 enum { VMType = VM::VM1 };
25477 static const char* GetVMString() { return "1"; }
25478 };
25479 template <> struct TagToType<0x300a,0x00b6> {
25480 static const char* GetVRString() { return "SQ"; }
25481 typedef VRToType<VR::SQ>::Type Type;
25482 enum : long long { VRType = VR::SQ };
25483 enum { VMType = VM::VM1 };
25484 static const char* GetVMString() { return "1"; }
25485 };
25486 template <> struct TagToType<0x300a,0x00b8> {
25487 static const char* GetVRString() { return "CS"; }
25488 typedef VRToType<VR::CS>::Type Type;
25489 enum : long long { VRType = VR::CS };
25490 enum { VMType = VM::VM1 };
25491 static const char* GetVMString() { return "1"; }
25492 };
25493 template <> struct TagToType<0x300a,0x00ba> {
25494 static const char* GetVRString() { return "DS"; }
25495 typedef VRToType<VR::DS>::Type Type;
25496 enum : long long { VRType = VR::DS };
25497 enum { VMType = VM::VM1 };
25498 static const char* GetVMString() { return "1"; }
25499 };
25500 template <> struct TagToType<0x300a,0x00bb> {
25501 static const char* GetVRString() { return "FL"; }
25502 typedef VRToType<VR::FL>::Type Type;
25503 enum : long long { VRType = VR::FL };
25504 enum { VMType = VM::VM1 };
25505 static const char* GetVMString() { return "1"; }
25506 };
25507 template <> struct TagToType<0x300a,0x00bc> {
25508 static const char* GetVRString() { return "IS"; }
25509 typedef VRToType<VR::IS>::Type Type;
25510 enum : long long { VRType = VR::IS };
25511 enum { VMType = VM::VM1 };
25512 static const char* GetVMString() { return "1"; }
25513 };
25514 template <> struct TagToType<0x300a,0x00be> {
25515 static const char* GetVRString() { return "DS"; }
25516 typedef VRToType<VR::DS>::Type Type;
25517 enum : long long { VRType = VR::DS };
25518 enum { VMType = VM::VM3_n };
25519 static const char* GetVMString() { return "3-n"; }
25520 };
25521 template <> struct TagToType<0x300a,0x00c0> {
25522 static const char* GetVRString() { return "IS"; }
25523 typedef VRToType<VR::IS>::Type Type;
25524 enum : long long { VRType = VR::IS };
25525 enum { VMType = VM::VM1 };
25526 static const char* GetVMString() { return "1"; }
25527 };
25528 template <> struct TagToType<0x300a,0x00c2> {
25529 static const char* GetVRString() { return "LO"; }
25530 typedef VRToType<VR::LO>::Type Type;
25531 enum : long long { VRType = VR::LO };
25532 enum { VMType = VM::VM1 };
25533 static const char* GetVMString() { return "1"; }
25534 };
25535 template <> struct TagToType<0x300a,0x00c3> {
25536 static const char* GetVRString() { return "ST"; }
25537 typedef VRToType<VR::ST>::Type Type;
25538 enum : long long { VRType = VR::ST };
25539 enum { VMType = VM::VM1 };
25540 static const char* GetVMString() { return "1"; }
25541 };
25542 template <> struct TagToType<0x300a,0x00c4> {
25543 static const char* GetVRString() { return "CS"; }
25544 typedef VRToType<VR::CS>::Type Type;
25545 enum : long long { VRType = VR::CS };
25546 enum { VMType = VM::VM1 };
25547 static const char* GetVMString() { return "1"; }
25548 };
25549 template <> struct TagToType<0x300a,0x00c5> {
25550 static const char* GetVRString() { return "FD"; }
25551 typedef VRToType<VR::FD>::Type Type;
25552 enum : long long { VRType = VR::FD };
25553 enum { VMType = VM::VM1 };
25554 static const char* GetVMString() { return "1"; }
25555 };
25556 template <> struct TagToType<0x300a,0x00c6> {
25557 static const char* GetVRString() { return "CS"; }
25558 typedef VRToType<VR::CS>::Type Type;
25559 enum : long long { VRType = VR::CS };
25560 enum { VMType = VM::VM1 };
25561 static const char* GetVMString() { return "1"; }
25562 };
25563 template <> struct TagToType<0x300a,0x00c7> {
25564 static const char* GetVRString() { return "CS"; }
25565 typedef VRToType<VR::CS>::Type Type;
25566 enum : long long { VRType = VR::CS };
25567 enum { VMType = VM::VM1 };
25568 static const char* GetVMString() { return "1"; }
25569 };
25570 template <> struct TagToType<0x300a,0x00c8> {
25571 static const char* GetVRString() { return "IS"; }
25572 typedef VRToType<VR::IS>::Type Type;
25573 enum : long long { VRType = VR::IS };
25574 enum { VMType = VM::VM1 };
25575 static const char* GetVMString() { return "1"; }
25576 };
25577 template <> struct TagToType<0x300a,0x00ca> {
25578 static const char* GetVRString() { return "SQ"; }
25579 typedef VRToType<VR::SQ>::Type Type;
25580 enum : long long { VRType = VR::SQ };
25581 enum { VMType = VM::VM1 };
25582 static const char* GetVMString() { return "1"; }
25583 };
25584 template <> struct TagToType<0x300a,0x00cc> {
25585 static const char* GetVRString() { return "LO"; }
25586 typedef VRToType<VR::LO>::Type Type;
25587 enum : long long { VRType = VR::LO };
25588 enum { VMType = VM::VM1_n };
25589 static const char* GetVMString() { return "1-n"; }
25590 };
25591 template <> struct TagToType<0x300a,0x00ce> {
25592 static const char* GetVRString() { return "CS"; }
25593 typedef VRToType<VR::CS>::Type Type;
25594 enum : long long { VRType = VR::CS };
25595 enum { VMType = VM::VM1 };
25596 static const char* GetVMString() { return "1"; }
25597 };
25598 template <> struct TagToType<0x300a,0x00d0> {
25599 static const char* GetVRString() { return "IS"; }
25600 typedef VRToType<VR::IS>::Type Type;
25601 enum : long long { VRType = VR::IS };
25602 enum { VMType = VM::VM1 };
25603 static const char* GetVMString() { return "1"; }
25604 };
25605 template <> struct TagToType<0x300a,0x00d1> {
25606 static const char* GetVRString() { return "SQ"; }
25607 typedef VRToType<VR::SQ>::Type Type;
25608 enum : long long { VRType = VR::SQ };
25609 enum { VMType = VM::VM1 };
25610 static const char* GetVMString() { return "1"; }
25611 };
25612 template <> struct TagToType<0x300a,0x00d2> {
25613 static const char* GetVRString() { return "IS"; }
25614 typedef VRToType<VR::IS>::Type Type;
25615 enum : long long { VRType = VR::IS };
25616 enum { VMType = VM::VM1 };
25617 static const char* GetVMString() { return "1"; }
25618 };
25619 template <> struct TagToType<0x300a,0x00d3> {
25620 static const char* GetVRString() { return "CS"; }
25621 typedef VRToType<VR::CS>::Type Type;
25622 enum : long long { VRType = VR::CS };
25623 enum { VMType = VM::VM1 };
25624 static const char* GetVMString() { return "1"; }
25625 };
25626 template <> struct TagToType<0x300a,0x00d4> {
25627 static const char* GetVRString() { return "SH"; }
25628 typedef VRToType<VR::SH>::Type Type;
25629 enum : long long { VRType = VR::SH };
25630 enum { VMType = VM::VM1 };
25631 static const char* GetVMString() { return "1"; }
25632 };
25633 template <> struct TagToType<0x300a,0x00d5> {
25634 static const char* GetVRString() { return "IS"; }
25635 typedef VRToType<VR::IS>::Type Type;
25636 enum : long long { VRType = VR::IS };
25637 enum { VMType = VM::VM1 };
25638 static const char* GetVMString() { return "1"; }
25639 };
25640 template <> struct TagToType<0x300a,0x00d6> {
25641 static const char* GetVRString() { return "DS"; }
25642 typedef VRToType<VR::DS>::Type Type;
25643 enum : long long { VRType = VR::DS };
25644 enum { VMType = VM::VM1 };
25645 static const char* GetVMString() { return "1"; }
25646 };
25647 template <> struct TagToType<0x300a,0x00d7> {
25648 static const char* GetVRString() { return "FL"; }
25649 typedef VRToType<VR::FL>::Type Type;
25650 enum : long long { VRType = VR::FL };
25651 enum { VMType = VM::VM1 };
25652 static const char* GetVMString() { return "1"; }
25653 };
25654 template <> struct TagToType<0x300a,0x00d8> {
25655 static const char* GetVRString() { return "DS"; }
25656 typedef VRToType<VR::DS>::Type Type;
25657 enum : long long { VRType = VR::DS };
25658 enum { VMType = VM::VM1 };
25659 static const char* GetVMString() { return "1"; }
25660 };
25661 template <> struct TagToType<0x300a,0x00d9> {
25662 static const char* GetVRString() { return "FL"; }
25663 typedef VRToType<VR::FL>::Type Type;
25664 enum : long long { VRType = VR::FL };
25665 enum { VMType = VM::VM1 };
25666 static const char* GetVMString() { return "1"; }
25667 };
25668 template <> struct TagToType<0x300a,0x00da> {
25669 static const char* GetVRString() { return "DS"; }
25670 typedef VRToType<VR::DS>::Type Type;
25671 enum : long long { VRType = VR::DS };
25672 enum { VMType = VM::VM1 };
25673 static const char* GetVMString() { return "1"; }
25674 };
25675 template <> struct TagToType<0x300a,0x00db> {
25676 static const char* GetVRString() { return "FL"; }
25677 typedef VRToType<VR::FL>::Type Type;
25678 enum : long long { VRType = VR::FL };
25679 enum { VMType = VM::VM1 };
25680 static const char* GetVMString() { return "1"; }
25681 };
25682 template <> struct TagToType<0x300a,0x00dc> {
25683 static const char* GetVRString() { return "SH"; }
25684 typedef VRToType<VR::SH>::Type Type;
25685 enum : long long { VRType = VR::SH };
25686 enum { VMType = VM::VM1 };
25687 static const char* GetVMString() { return "1"; }
25688 };
25689 template <> struct TagToType<0x300a,0x00dd> {
25690 static const char* GetVRString() { return "ST"; }
25691 typedef VRToType<VR::ST>::Type Type;
25692 enum : long long { VRType = VR::ST };
25693 enum { VMType = VM::VM1 };
25694 static const char* GetVMString() { return "1"; }
25695 };
25696 template <> struct TagToType<0x300a,0x00de> {
25697 static const char* GetVRString() { return "DS"; }
25698 typedef VRToType<VR::DS>::Type Type;
25699 enum : long long { VRType = VR::DS };
25700 enum { VMType = VM::VM1 };
25701 static const char* GetVMString() { return "1"; }
25702 };
25703 template <> struct TagToType<0x300a,0x00e0> {
25704 static const char* GetVRString() { return "IS"; }
25705 typedef VRToType<VR::IS>::Type Type;
25706 enum : long long { VRType = VR::IS };
25707 enum { VMType = VM::VM1 };
25708 static const char* GetVMString() { return "1"; }
25709 };
25710 template <> struct TagToType<0x300a,0x00e1> {
25711 static const char* GetVRString() { return "SH"; }
25712 typedef VRToType<VR::SH>::Type Type;
25713 enum : long long { VRType = VR::SH };
25714 enum { VMType = VM::VM1 };
25715 static const char* GetVMString() { return "1"; }
25716 };
25717 template <> struct TagToType<0x300a,0x00e2> {
25718 static const char* GetVRString() { return "DS"; }
25719 typedef VRToType<VR::DS>::Type Type;
25720 enum : long long { VRType = VR::DS };
25721 enum { VMType = VM::VM1 };
25722 static const char* GetVMString() { return "1"; }
25723 };
25724 template <> struct TagToType<0x300a,0x00e3> {
25725 static const char* GetVRString() { return "SQ"; }
25726 typedef VRToType<VR::SQ>::Type Type;
25727 enum : long long { VRType = VR::SQ };
25728 enum { VMType = VM::VM1 };
25729 static const char* GetVMString() { return "1"; }
25730 };
25731 template <> struct TagToType<0x300a,0x00e4> {
25732 static const char* GetVRString() { return "IS"; }
25733 typedef VRToType<VR::IS>::Type Type;
25734 enum : long long { VRType = VR::IS };
25735 enum { VMType = VM::VM1 };
25736 static const char* GetVMString() { return "1"; }
25737 };
25738 template <> struct TagToType<0x300a,0x00e5> {
25739 static const char* GetVRString() { return "SH"; }
25740 typedef VRToType<VR::SH>::Type Type;
25741 enum : long long { VRType = VR::SH };
25742 enum { VMType = VM::VM1 };
25743 static const char* GetVMString() { return "1"; }
25744 };
25745 template <> struct TagToType<0x300a,0x00e6> {
25746 static const char* GetVRString() { return "DS"; }
25747 typedef VRToType<VR::DS>::Type Type;
25748 enum : long long { VRType = VR::DS };
25749 enum { VMType = VM::VM1 };
25750 static const char* GetVMString() { return "1"; }
25751 };
25752 template <> struct TagToType<0x300a,0x00e7> {
25753 static const char* GetVRString() { return "IS"; }
25754 typedef VRToType<VR::IS>::Type Type;
25755 enum : long long { VRType = VR::IS };
25756 enum { VMType = VM::VM1 };
25757 static const char* GetVMString() { return "1"; }
25758 };
25759 template <> struct TagToType<0x300a,0x00e8> {
25760 static const char* GetVRString() { return "IS"; }
25761 typedef VRToType<VR::IS>::Type Type;
25762 enum : long long { VRType = VR::IS };
25763 enum { VMType = VM::VM1 };
25764 static const char* GetVMString() { return "1"; }
25765 };
25766 template <> struct TagToType<0x300a,0x00e9> {
25767 static const char* GetVRString() { return "DS"; }
25768 typedef VRToType<VR::DS>::Type Type;
25769 enum : long long { VRType = VR::DS };
25770 enum { VMType = VM::VM2 };
25771 static const char* GetVMString() { return "2"; }
25772 };
25773 template <> struct TagToType<0x300a,0x00ea> {
25774 static const char* GetVRString() { return "DS"; }
25775 typedef VRToType<VR::DS>::Type Type;
25776 enum : long long { VRType = VR::DS };
25777 enum { VMType = VM::VM2 };
25778 static const char* GetVMString() { return "2"; }
25779 };
25780 template <> struct TagToType<0x300a,0x00eb> {
25781 static const char* GetVRString() { return "DS"; }
25782 typedef VRToType<VR::DS>::Type Type;
25783 enum : long long { VRType = VR::DS };
25784 enum { VMType = VM::VM1_n };
25785 static const char* GetVMString() { return "1-n"; }
25786 };
25787 template <> struct TagToType<0x300a,0x00ec> {
25788 static const char* GetVRString() { return "DS"; }
25789 typedef VRToType<VR::DS>::Type Type;
25790 enum : long long { VRType = VR::DS };
25791 enum { VMType = VM::VM1_n };
25792 static const char* GetVMString() { return "1-n"; }
25793 };
25794 template <> struct TagToType<0x300a,0x00ed> {
25795 static const char* GetVRString() { return "IS"; }
25796 typedef VRToType<VR::IS>::Type Type;
25797 enum : long long { VRType = VR::IS };
25798 enum { VMType = VM::VM1 };
25799 static const char* GetVMString() { return "1"; }
25800 };
25801 template <> struct TagToType<0x300a,0x00ee> {
25802 static const char* GetVRString() { return "CS"; }
25803 typedef VRToType<VR::CS>::Type Type;
25804 enum : long long { VRType = VR::CS };
25805 enum { VMType = VM::VM1 };
25806 static const char* GetVMString() { return "1"; }
25807 };
25808 template <> struct TagToType<0x300a,0x00ef> {
25809 static const char* GetVRString() { return "SH"; }
25810 typedef VRToType<VR::SH>::Type Type;
25811 enum : long long { VRType = VR::SH };
25812 enum { VMType = VM::VM1 };
25813 static const char* GetVMString() { return "1"; }
25814 };
25815 template <> struct TagToType<0x300a,0x00f0> {
25816 static const char* GetVRString() { return "IS"; }
25817 typedef VRToType<VR::IS>::Type Type;
25818 enum : long long { VRType = VR::IS };
25819 enum { VMType = VM::VM1 };
25820 static const char* GetVMString() { return "1"; }
25821 };
25822 template <> struct TagToType<0x300a,0x00f2> {
25823 static const char* GetVRString() { return "DS"; }
25824 typedef VRToType<VR::DS>::Type Type;
25825 enum : long long { VRType = VR::DS };
25826 enum { VMType = VM::VM1 };
25827 static const char* GetVMString() { return "1"; }
25828 };
25829 template <> struct TagToType<0x300a,0x00f3> {
25830 static const char* GetVRString() { return "FL"; }
25831 typedef VRToType<VR::FL>::Type Type;
25832 enum : long long { VRType = VR::FL };
25833 enum { VMType = VM::VM1 };
25834 static const char* GetVMString() { return "1"; }
25835 };
25836 template <> struct TagToType<0x300a,0x00f4> {
25837 static const char* GetVRString() { return "SQ"; }
25838 typedef VRToType<VR::SQ>::Type Type;
25839 enum : long long { VRType = VR::SQ };
25840 enum { VMType = VM::VM1 };
25841 static const char* GetVMString() { return "1"; }
25842 };
25843 template <> struct TagToType<0x300a,0x00f5> {
25844 static const char* GetVRString() { return "SH"; }
25845 typedef VRToType<VR::SH>::Type Type;
25846 enum : long long { VRType = VR::SH };
25847 enum { VMType = VM::VM1 };
25848 static const char* GetVMString() { return "1"; }
25849 };
25850 template <> struct TagToType<0x300a,0x00f6> {
25851 static const char* GetVRString() { return "DS"; }
25852 typedef VRToType<VR::DS>::Type Type;
25853 enum : long long { VRType = VR::DS };
25854 enum { VMType = VM::VM1 };
25855 static const char* GetVMString() { return "1"; }
25856 };
25857 template <> struct TagToType<0x300a,0x00f7> {
25858 static const char* GetVRString() { return "FL"; }
25859 typedef VRToType<VR::FL>::Type Type;
25860 enum : long long { VRType = VR::FL };
25861 enum { VMType = VM::VM1 };
25862 static const char* GetVMString() { return "1"; }
25863 };
25864 template <> struct TagToType<0x300a,0x00f8> {
25865 static const char* GetVRString() { return "CS"; }
25866 typedef VRToType<VR::CS>::Type Type;
25867 enum : long long { VRType = VR::CS };
25868 enum { VMType = VM::VM1 };
25869 static const char* GetVMString() { return "1"; }
25870 };
25871 template <> struct TagToType<0x300a,0x00f9> {
25872 static const char* GetVRString() { return "LO"; }
25873 typedef VRToType<VR::LO>::Type Type;
25874 enum : long long { VRType = VR::LO };
25875 enum { VMType = VM::VM1 };
25876 static const char* GetVMString() { return "1"; }
25877 };
25878 template <> struct TagToType<0x300a,0x00fa> {
25879 static const char* GetVRString() { return "CS"; }
25880 typedef VRToType<VR::CS>::Type Type;
25881 enum : long long { VRType = VR::CS };
25882 enum { VMType = VM::VM1 };
25883 static const char* GetVMString() { return "1"; }
25884 };
25885 template <> struct TagToType<0x300a,0x00fb> {
25886 static const char* GetVRString() { return "CS"; }
25887 typedef VRToType<VR::CS>::Type Type;
25888 enum : long long { VRType = VR::CS };
25889 enum { VMType = VM::VM1 };
25890 static const char* GetVMString() { return "1"; }
25891 };
25892 template <> struct TagToType<0x300a,0x00fc> {
25893 static const char* GetVRString() { return "IS"; }
25894 typedef VRToType<VR::IS>::Type Type;
25895 enum : long long { VRType = VR::IS };
25896 enum { VMType = VM::VM1 };
25897 static const char* GetVMString() { return "1"; }
25898 };
25899 template <> struct TagToType<0x300a,0x00fe> {
25900 static const char* GetVRString() { return "LO"; }
25901 typedef VRToType<VR::LO>::Type Type;
25902 enum : long long { VRType = VR::LO };
25903 enum { VMType = VM::VM1 };
25904 static const char* GetVMString() { return "1"; }
25905 };
25906 template <> struct TagToType<0x300a,0x0100> {
25907 static const char* GetVRString() { return "DS"; }
25908 typedef VRToType<VR::DS>::Type Type;
25909 enum : long long { VRType = VR::DS };
25910 enum { VMType = VM::VM1 };
25911 static const char* GetVMString() { return "1"; }
25912 };
25913 template <> struct TagToType<0x300a,0x0102> {
25914 static const char* GetVRString() { return "DS"; }
25915 typedef VRToType<VR::DS>::Type Type;
25916 enum : long long { VRType = VR::DS };
25917 enum { VMType = VM::VM1 };
25918 static const char* GetVMString() { return "1"; }
25919 };
25920 template <> struct TagToType<0x300a,0x0104> {
25921 static const char* GetVRString() { return "IS"; }
25922 typedef VRToType<VR::IS>::Type Type;
25923 enum : long long { VRType = VR::IS };
25924 enum { VMType = VM::VM1 };
25925 static const char* GetVMString() { return "1"; }
25926 };
25927 template <> struct TagToType<0x300a,0x0106> {
25928 static const char* GetVRString() { return "DS"; }
25929 typedef VRToType<VR::DS>::Type Type;
25930 enum : long long { VRType = VR::DS };
25931 enum { VMType = VM::VM2_2n };
25932 static const char* GetVMString() { return "2-2n"; }
25933 };
25934 template <> struct TagToType<0x300a,0x0107> {
25935 static const char* GetVRString() { return "SQ"; }
25936 typedef VRToType<VR::SQ>::Type Type;
25937 enum : long long { VRType = VR::SQ };
25938 enum { VMType = VM::VM1 };
25939 static const char* GetVMString() { return "1"; }
25940 };
25941 template <> struct TagToType<0x300a,0x0108> {
25942 static const char* GetVRString() { return "SH"; }
25943 typedef VRToType<VR::SH>::Type Type;
25944 enum : long long { VRType = VR::SH };
25945 enum { VMType = VM::VM1 };
25946 static const char* GetVMString() { return "1"; }
25947 };
25948 template <> struct TagToType<0x300a,0x0109> {
25949 static const char* GetVRString() { return "CS"; }
25950 typedef VRToType<VR::CS>::Type Type;
25951 enum : long long { VRType = VR::CS };
25952 enum { VMType = VM::VM1 };
25953 static const char* GetVMString() { return "1"; }
25954 };
25955 template <> struct TagToType<0x300a,0x010a> {
25956 static const char* GetVRString() { return "LO"; }
25957 typedef VRToType<VR::LO>::Type Type;
25958 enum : long long { VRType = VR::LO };
25959 enum { VMType = VM::VM1 };
25960 static const char* GetVMString() { return "1"; }
25961 };
25962 template <> struct TagToType<0x300a,0x010c> {
25963 static const char* GetVRString() { return "DS"; }
25964 typedef VRToType<VR::DS>::Type Type;
25965 enum : long long { VRType = VR::DS };
25966 enum { VMType = VM::VM1 };
25967 static const char* GetVMString() { return "1"; }
25968 };
25969 template <> struct TagToType<0x300a,0x010e> {
25970 static const char* GetVRString() { return "DS"; }
25971 typedef VRToType<VR::DS>::Type Type;
25972 enum : long long { VRType = VR::DS };
25973 enum { VMType = VM::VM1 };
25974 static const char* GetVMString() { return "1"; }
25975 };
25976 template <> struct TagToType<0x300a,0x0110> {
25977 static const char* GetVRString() { return "IS"; }
25978 typedef VRToType<VR::IS>::Type Type;
25979 enum : long long { VRType = VR::IS };
25980 enum { VMType = VM::VM1 };
25981 static const char* GetVMString() { return "1"; }
25982 };
25983 template <> struct TagToType<0x300a,0x0111> {
25984 static const char* GetVRString() { return "SQ"; }
25985 typedef VRToType<VR::SQ>::Type Type;
25986 enum : long long { VRType = VR::SQ };
25987 enum { VMType = VM::VM1 };
25988 static const char* GetVMString() { return "1"; }
25989 };
25990 template <> struct TagToType<0x300a,0x0112> {
25991 static const char* GetVRString() { return "IS"; }
25992 typedef VRToType<VR::IS>::Type Type;
25993 enum : long long { VRType = VR::IS };
25994 enum { VMType = VM::VM1 };
25995 static const char* GetVMString() { return "1"; }
25996 };
25997 template <> struct TagToType<0x300a,0x0114> {
25998 static const char* GetVRString() { return "DS"; }
25999 typedef VRToType<VR::DS>::Type Type;
26000 enum : long long { VRType = VR::DS };
26001 enum { VMType = VM::VM1 };
26002 static const char* GetVMString() { return "1"; }
26003 };
26004 template <> struct TagToType<0x300a,0x0115> {
26005 static const char* GetVRString() { return "DS"; }
26006 typedef VRToType<VR::DS>::Type Type;
26007 enum : long long { VRType = VR::DS };
26008 enum { VMType = VM::VM1 };
26009 static const char* GetVMString() { return "1"; }
26010 };
26011 template <> struct TagToType<0x300a,0x0116> {
26012 static const char* GetVRString() { return "SQ"; }
26013 typedef VRToType<VR::SQ>::Type Type;
26014 enum : long long { VRType = VR::SQ };
26015 enum { VMType = VM::VM1 };
26016 static const char* GetVMString() { return "1"; }
26017 };
26018 template <> struct TagToType<0x300a,0x0118> {
26019 static const char* GetVRString() { return "CS"; }
26020 typedef VRToType<VR::CS>::Type Type;
26021 enum : long long { VRType = VR::CS };
26022 enum { VMType = VM::VM1 };
26023 static const char* GetVMString() { return "1"; }
26024 };
26025 template <> struct TagToType<0x300a,0x011a> {
26026 static const char* GetVRString() { return "SQ"; }
26027 typedef VRToType<VR::SQ>::Type Type;
26028 enum : long long { VRType = VR::SQ };
26029 enum { VMType = VM::VM1 };
26030 static const char* GetVMString() { return "1"; }
26031 };
26032 template <> struct TagToType<0x300a,0x011c> {
26033 static const char* GetVRString() { return "DS"; }
26034 typedef VRToType<VR::DS>::Type Type;
26035 enum : long long { VRType = VR::DS };
26036 enum { VMType = VM::VM2_2n };
26037 static const char* GetVMString() { return "2-2n"; }
26038 };
26039 template <> struct TagToType<0x300a,0x011e> {
26040 static const char* GetVRString() { return "DS"; }
26041 typedef VRToType<VR::DS>::Type Type;
26042 enum : long long { VRType = VR::DS };
26043 enum { VMType = VM::VM1 };
26044 static const char* GetVMString() { return "1"; }
26045 };
26046 template <> struct TagToType<0x300a,0x011f> {
26047 static const char* GetVRString() { return "CS"; }
26048 typedef VRToType<VR::CS>::Type Type;
26049 enum : long long { VRType = VR::CS };
26050 enum { VMType = VM::VM1 };
26051 static const char* GetVMString() { return "1"; }
26052 };
26053 template <> struct TagToType<0x300a,0x0120> {
26054 static const char* GetVRString() { return "DS"; }
26055 typedef VRToType<VR::DS>::Type Type;
26056 enum : long long { VRType = VR::DS };
26057 enum { VMType = VM::VM1 };
26058 static const char* GetVMString() { return "1"; }
26059 };
26060 template <> struct TagToType<0x300a,0x0121> {
26061 static const char* GetVRString() { return "CS"; }
26062 typedef VRToType<VR::CS>::Type Type;
26063 enum : long long { VRType = VR::CS };
26064 enum { VMType = VM::VM1 };
26065 static const char* GetVMString() { return "1"; }
26066 };
26067 template <> struct TagToType<0x300a,0x0122> {
26068 static const char* GetVRString() { return "DS"; }
26069 typedef VRToType<VR::DS>::Type Type;
26070 enum : long long { VRType = VR::DS };
26071 enum { VMType = VM::VM1 };
26072 static const char* GetVMString() { return "1"; }
26073 };
26074 template <> struct TagToType<0x300a,0x0123> {
26075 static const char* GetVRString() { return "CS"; }
26076 typedef VRToType<VR::CS>::Type Type;
26077 enum : long long { VRType = VR::CS };
26078 enum { VMType = VM::VM1 };
26079 static const char* GetVMString() { return "1"; }
26080 };
26081 template <> struct TagToType<0x300a,0x0124> {
26082 static const char* GetVRString() { return "DS"; }
26083 typedef VRToType<VR::DS>::Type Type;
26084 enum : long long { VRType = VR::DS };
26085 enum { VMType = VM::VM1 };
26086 static const char* GetVMString() { return "1"; }
26087 };
26088 template <> struct TagToType<0x300a,0x0125> {
26089 static const char* GetVRString() { return "DS"; }
26090 typedef VRToType<VR::DS>::Type Type;
26091 enum : long long { VRType = VR::DS };
26092 enum { VMType = VM::VM1 };
26093 static const char* GetVMString() { return "1"; }
26094 };
26095 template <> struct TagToType<0x300a,0x0126> {
26096 static const char* GetVRString() { return "CS"; }
26097 typedef VRToType<VR::CS>::Type Type;
26098 enum : long long { VRType = VR::CS };
26099 enum { VMType = VM::VM1 };
26100 static const char* GetVMString() { return "1"; }
26101 };
26102 template <> struct TagToType<0x300a,0x0128> {
26103 static const char* GetVRString() { return "DS"; }
26104 typedef VRToType<VR::DS>::Type Type;
26105 enum : long long { VRType = VR::DS };
26106 enum { VMType = VM::VM1 };
26107 static const char* GetVMString() { return "1"; }
26108 };
26109 template <> struct TagToType<0x300a,0x0129> {
26110 static const char* GetVRString() { return "DS"; }
26111 typedef VRToType<VR::DS>::Type Type;
26112 enum : long long { VRType = VR::DS };
26113 enum { VMType = VM::VM1 };
26114 static const char* GetVMString() { return "1"; }
26115 };
26116 template <> struct TagToType<0x300a,0x012a> {
26117 static const char* GetVRString() { return "DS"; }
26118 typedef VRToType<VR::DS>::Type Type;
26119 enum : long long { VRType = VR::DS };
26120 enum { VMType = VM::VM1 };
26121 static const char* GetVMString() { return "1"; }
26122 };
26123 template <> struct TagToType<0x300a,0x012c> {
26124 static const char* GetVRString() { return "DS"; }
26125 typedef VRToType<VR::DS>::Type Type;
26126 enum : long long { VRType = VR::DS };
26127 enum { VMType = VM::VM3 };
26128 static const char* GetVMString() { return "3"; }
26129 };
26130 template <> struct TagToType<0x300a,0x012e> {
26131 static const char* GetVRString() { return "DS"; }
26132 typedef VRToType<VR::DS>::Type Type;
26133 enum : long long { VRType = VR::DS };
26134 enum { VMType = VM::VM3 };
26135 static const char* GetVMString() { return "3"; }
26136 };
26137 template <> struct TagToType<0x300a,0x0130> {
26138 static const char* GetVRString() { return "DS"; }
26139 typedef VRToType<VR::DS>::Type Type;
26140 enum : long long { VRType = VR::DS };
26141 enum { VMType = VM::VM1 };
26142 static const char* GetVMString() { return "1"; }
26143 };
26144 template <> struct TagToType<0x300a,0x0131> {
26145 static const char* GetVRString() { return "FL"; }
26146 typedef VRToType<VR::FL>::Type Type;
26147 enum : long long { VRType = VR::FL };
26148 enum { VMType = VM::VM1 };
26149 static const char* GetVMString() { return "1"; }
26150 };
26151 template <> struct TagToType<0x300a,0x0132> {
26152 static const char* GetVRString() { return "FL"; }
26153 typedef VRToType<VR::FL>::Type Type;
26154 enum : long long { VRType = VR::FL };
26155 enum { VMType = VM::VM1 };
26156 static const char* GetVMString() { return "1"; }
26157 };
26158 template <> struct TagToType<0x300a,0x0133> {
26159 static const char* GetVRString() { return "FL"; }
26160 typedef VRToType<VR::FL>::Type Type;
26161 enum : long long { VRType = VR::FL };
26162 enum { VMType = VM::VM3 };
26163 static const char* GetVMString() { return "3"; }
26164 };
26165 template <> struct TagToType<0x300a,0x0134> {
26166 static const char* GetVRString() { return "DS"; }
26167 typedef VRToType<VR::DS>::Type Type;
26168 enum : long long { VRType = VR::DS };
26169 enum { VMType = VM::VM1 };
26170 static const char* GetVMString() { return "1"; }
26171 };
26172 template <> struct TagToType<0x300a,0x0140> {
26173 static const char* GetVRString() { return "FL"; }
26174 typedef VRToType<VR::FL>::Type Type;
26175 enum : long long { VRType = VR::FL };
26176 enum { VMType = VM::VM1 };
26177 static const char* GetVMString() { return "1"; }
26178 };
26179 template <> struct TagToType<0x300a,0x0142> {
26180 static const char* GetVRString() { return "CS"; }
26181 typedef VRToType<VR::CS>::Type Type;
26182 enum : long long { VRType = VR::CS };
26183 enum { VMType = VM::VM1 };
26184 static const char* GetVMString() { return "1"; }
26185 };
26186 template <> struct TagToType<0x300a,0x0144> {
26187 static const char* GetVRString() { return "FL"; }
26188 typedef VRToType<VR::FL>::Type Type;
26189 enum : long long { VRType = VR::FL };
26190 enum { VMType = VM::VM1 };
26191 static const char* GetVMString() { return "1"; }
26192 };
26193 template <> struct TagToType<0x300a,0x0146> {
26194 static const char* GetVRString() { return "CS"; }
26195 typedef VRToType<VR::CS>::Type Type;
26196 enum : long long { VRType = VR::CS };
26197 enum { VMType = VM::VM1 };
26198 static const char* GetVMString() { return "1"; }
26199 };
26200 template <> struct TagToType<0x300a,0x0148> {
26201 static const char* GetVRString() { return "FL"; }
26202 typedef VRToType<VR::FL>::Type Type;
26203 enum : long long { VRType = VR::FL };
26204 enum { VMType = VM::VM1 };
26205 static const char* GetVMString() { return "1"; }
26206 };
26207 template <> struct TagToType<0x300a,0x014a> {
26208 static const char* GetVRString() { return "FL"; }
26209 typedef VRToType<VR::FL>::Type Type;
26210 enum : long long { VRType = VR::FL };
26211 enum { VMType = VM::VM1 };
26212 static const char* GetVMString() { return "1"; }
26213 };
26214 template <> struct TagToType<0x300a,0x014c> {
26215 static const char* GetVRString() { return "CS"; }
26216 typedef VRToType<VR::CS>::Type Type;
26217 enum : long long { VRType = VR::CS };
26218 enum { VMType = VM::VM1 };
26219 static const char* GetVMString() { return "1"; }
26220 };
26221 template <> struct TagToType<0x300a,0x014e> {
26222 static const char* GetVRString() { return "FL"; }
26223 typedef VRToType<VR::FL>::Type Type;
26224 enum : long long { VRType = VR::FL };
26225 enum { VMType = VM::VM1 };
26226 static const char* GetVMString() { return "1"; }
26227 };
26228 template <> struct TagToType<0x300a,0x0150> {
26229 static const char* GetVRString() { return "CS"; }
26230 typedef VRToType<VR::CS>::Type Type;
26231 enum : long long { VRType = VR::CS };
26232 enum { VMType = VM::VM1 };
26233 static const char* GetVMString() { return "1"; }
26234 };
26235 template <> struct TagToType<0x300a,0x0151> {
26236 static const char* GetVRString() { return "DS"; }
26237 typedef VRToType<VR::DS>::Type Type;
26238 enum : long long { VRType = VR::DS };
26239 enum { VMType = VM::VM1 };
26240 static const char* GetVMString() { return "1"; }
26241 };
26242 template <> struct TagToType<0x300a,0x0152> {
26243 static const char* GetVRString() { return "DS"; }
26244 typedef VRToType<VR::DS>::Type Type;
26245 enum : long long { VRType = VR::DS };
26246 enum { VMType = VM::VM1 };
26247 static const char* GetVMString() { return "1"; }
26248 };
26249 template <> struct TagToType<0x300a,0x0153> {
26250 static const char* GetVRString() { return "DS"; }
26251 typedef VRToType<VR::DS>::Type Type;
26252 enum : long long { VRType = VR::DS };
26253 enum { VMType = VM::VM1 };
26254 static const char* GetVMString() { return "1"; }
26255 };
26256 template <> struct TagToType<0x300a,0x0154> {
26257 static const char* GetVRString() { return "DS"; }
26258 typedef VRToType<VR::DS>::Type Type;
26259 enum : long long { VRType = VR::DS };
26260 enum { VMType = VM::VM1 };
26261 static const char* GetVMString() { return "1"; }
26262 };
26263 template <> struct TagToType<0x300a,0x0155> {
26264 static const char* GetVRString() { return "DS"; }
26265 typedef VRToType<VR::DS>::Type Type;
26266 enum : long long { VRType = VR::DS };
26267 enum { VMType = VM::VM1 };
26268 static const char* GetVMString() { return "1"; }
26269 };
26270 template <> struct TagToType<0x300a,0x0180> {
26271 static const char* GetVRString() { return "SQ"; }
26272 typedef VRToType<VR::SQ>::Type Type;
26273 enum : long long { VRType = VR::SQ };
26274 enum { VMType = VM::VM1 };
26275 static const char* GetVMString() { return "1"; }
26276 };
26277 template <> struct TagToType<0x300a,0x0182> {
26278 static const char* GetVRString() { return "IS"; }
26279 typedef VRToType<VR::IS>::Type Type;
26280 enum : long long { VRType = VR::IS };
26281 enum { VMType = VM::VM1 };
26282 static const char* GetVMString() { return "1"; }
26283 };
26284 template <> struct TagToType<0x300a,0x0183> {
26285 static const char* GetVRString() { return "LO"; }
26286 typedef VRToType<VR::LO>::Type Type;
26287 enum : long long { VRType = VR::LO };
26288 enum { VMType = VM::VM1 };
26289 static const char* GetVMString() { return "1"; }
26290 };
26291 template <> struct TagToType<0x300a,0x0184> {
26292 static const char* GetVRString() { return "LO"; }
26293 typedef VRToType<VR::LO>::Type Type;
26294 enum : long long { VRType = VR::LO };
26295 enum { VMType = VM::VM1 };
26296 static const char* GetVMString() { return "1"; }
26297 };
26298 template <> struct TagToType<0x300a,0x0190> {
26299 static const char* GetVRString() { return "SQ"; }
26300 typedef VRToType<VR::SQ>::Type Type;
26301 enum : long long { VRType = VR::SQ };
26302 enum { VMType = VM::VM1 };
26303 static const char* GetVMString() { return "1"; }
26304 };
26305 template <> struct TagToType<0x300a,0x0192> {
26306 static const char* GetVRString() { return "CS"; }
26307 typedef VRToType<VR::CS>::Type Type;
26308 enum : long long { VRType = VR::CS };
26309 enum { VMType = VM::VM1 };
26310 static const char* GetVMString() { return "1"; }
26311 };
26312 template <> struct TagToType<0x300a,0x0194> {
26313 static const char* GetVRString() { return "SH"; }
26314 typedef VRToType<VR::SH>::Type Type;
26315 enum : long long { VRType = VR::SH };
26316 enum { VMType = VM::VM1 };
26317 static const char* GetVMString() { return "1"; }
26318 };
26319 template <> struct TagToType<0x300a,0x0196> {
26320 static const char* GetVRString() { return "ST"; }
26321 typedef VRToType<VR::ST>::Type Type;
26322 enum : long long { VRType = VR::ST };
26323 enum { VMType = VM::VM1 };
26324 static const char* GetVMString() { return "1"; }
26325 };
26326 template <> struct TagToType<0x300a,0x0198> {
26327 static const char* GetVRString() { return "SH"; }
26328 typedef VRToType<VR::SH>::Type Type;
26329 enum : long long { VRType = VR::SH };
26330 enum { VMType = VM::VM1 };
26331 static const char* GetVMString() { return "1"; }
26332 };
26333 template <> struct TagToType<0x300a,0x0199> {
26334 static const char* GetVRString() { return "FL"; }
26335 typedef VRToType<VR::FL>::Type Type;
26336 enum : long long { VRType = VR::FL };
26337 enum { VMType = VM::VM1 };
26338 static const char* GetVMString() { return "1"; }
26339 };
26340 template <> struct TagToType<0x300a,0x019a> {
26341 static const char* GetVRString() { return "FL"; }
26342 typedef VRToType<VR::FL>::Type Type;
26343 enum : long long { VRType = VR::FL };
26344 enum { VMType = VM::VM1 };
26345 static const char* GetVMString() { return "1"; }
26346 };
26347 template <> struct TagToType<0x300a,0x01a0> {
26348 static const char* GetVRString() { return "SQ"; }
26349 typedef VRToType<VR::SQ>::Type Type;
26350 enum : long long { VRType = VR::SQ };
26351 enum { VMType = VM::VM1 };
26352 static const char* GetVMString() { return "1"; }
26353 };
26354 template <> struct TagToType<0x300a,0x01a2> {
26355 static const char* GetVRString() { return "CS"; }
26356 typedef VRToType<VR::CS>::Type Type;
26357 enum : long long { VRType = VR::CS };
26358 enum { VMType = VM::VM1 };
26359 static const char* GetVMString() { return "1"; }
26360 };
26361 template <> struct TagToType<0x300a,0x01a4> {
26362 static const char* GetVRString() { return "SH"; }
26363 typedef VRToType<VR::SH>::Type Type;
26364 enum : long long { VRType = VR::SH };
26365 enum { VMType = VM::VM1 };
26366 static const char* GetVMString() { return "1"; }
26367 };
26368 template <> struct TagToType<0x300a,0x01a6> {
26369 static const char* GetVRString() { return "ST"; }
26370 typedef VRToType<VR::ST>::Type Type;
26371 enum : long long { VRType = VR::ST };
26372 enum { VMType = VM::VM1 };
26373 static const char* GetVMString() { return "1"; }
26374 };
26375 template <> struct TagToType<0x300a,0x01a8> {
26376 static const char* GetVRString() { return "SH"; }
26377 typedef VRToType<VR::SH>::Type Type;
26378 enum : long long { VRType = VR::SH };
26379 enum { VMType = VM::VM1 };
26380 static const char* GetVMString() { return "1"; }
26381 };
26382 template <> struct TagToType<0x300a,0x01b0> {
26383 static const char* GetVRString() { return "CS"; }
26384 typedef VRToType<VR::CS>::Type Type;
26385 enum : long long { VRType = VR::CS };
26386 enum { VMType = VM::VM1 };
26387 static const char* GetVMString() { return "1"; }
26388 };
26389 template <> struct TagToType<0x300a,0x01b2> {
26390 static const char* GetVRString() { return "ST"; }
26391 typedef VRToType<VR::ST>::Type Type;
26392 enum : long long { VRType = VR::ST };
26393 enum { VMType = VM::VM1 };
26394 static const char* GetVMString() { return "1"; }
26395 };
26396 template <> struct TagToType<0x300a,0x01b4> {
26397 static const char* GetVRString() { return "SQ"; }
26398 typedef VRToType<VR::SQ>::Type Type;
26399 enum : long long { VRType = VR::SQ };
26400 enum { VMType = VM::VM1 };
26401 static const char* GetVMString() { return "1"; }
26402 };
26403 template <> struct TagToType<0x300a,0x01b6> {
26404 static const char* GetVRString() { return "CS"; }
26405 typedef VRToType<VR::CS>::Type Type;
26406 enum : long long { VRType = VR::CS };
26407 enum { VMType = VM::VM1 };
26408 static const char* GetVMString() { return "1"; }
26409 };
26410 template <> struct TagToType<0x300a,0x01b8> {
26411 static const char* GetVRString() { return "SH"; }
26412 typedef VRToType<VR::SH>::Type Type;
26413 enum : long long { VRType = VR::SH };
26414 enum { VMType = VM::VM1 };
26415 static const char* GetVMString() { return "1"; }
26416 };
26417 template <> struct TagToType<0x300a,0x01ba> {
26418 static const char* GetVRString() { return "ST"; }
26419 typedef VRToType<VR::ST>::Type Type;
26420 enum : long long { VRType = VR::ST };
26421 enum { VMType = VM::VM1 };
26422 static const char* GetVMString() { return "1"; }
26423 };
26424 template <> struct TagToType<0x300a,0x01bc> {
26425 static const char* GetVRString() { return "DS"; }
26426 typedef VRToType<VR::DS>::Type Type;
26427 enum : long long { VRType = VR::DS };
26428 enum { VMType = VM::VM1 };
26429 static const char* GetVMString() { return "1"; }
26430 };
26431 template <> struct TagToType<0x300a,0x01d0> {
26432 static const char* GetVRString() { return "ST"; }
26433 typedef VRToType<VR::ST>::Type Type;
26434 enum : long long { VRType = VR::ST };
26435 enum { VMType = VM::VM1 };
26436 static const char* GetVMString() { return "1"; }
26437 };
26438 template <> struct TagToType<0x300a,0x01d2> {
26439 static const char* GetVRString() { return "DS"; }
26440 typedef VRToType<VR::DS>::Type Type;
26441 enum : long long { VRType = VR::DS };
26442 enum { VMType = VM::VM1 };
26443 static const char* GetVMString() { return "1"; }
26444 };
26445 template <> struct TagToType<0x300a,0x01d4> {
26446 static const char* GetVRString() { return "DS"; }
26447 typedef VRToType<VR::DS>::Type Type;
26448 enum : long long { VRType = VR::DS };
26449 enum { VMType = VM::VM1 };
26450 static const char* GetVMString() { return "1"; }
26451 };
26452 template <> struct TagToType<0x300a,0x01d6> {
26453 static const char* GetVRString() { return "DS"; }
26454 typedef VRToType<VR::DS>::Type Type;
26455 enum : long long { VRType = VR::DS };
26456 enum { VMType = VM::VM1 };
26457 static const char* GetVMString() { return "1"; }
26458 };
26459 template <> struct TagToType<0x300a,0x0200> {
26460 static const char* GetVRString() { return "CS"; }
26461 typedef VRToType<VR::CS>::Type Type;
26462 enum : long long { VRType = VR::CS };
26463 enum { VMType = VM::VM1 };
26464 static const char* GetVMString() { return "1"; }
26465 };
26466 template <> struct TagToType<0x300a,0x0202> {
26467 static const char* GetVRString() { return "CS"; }
26468 typedef VRToType<VR::CS>::Type Type;
26469 enum : long long { VRType = VR::CS };
26470 enum { VMType = VM::VM1 };
26471 static const char* GetVMString() { return "1"; }
26472 };
26473 template <> struct TagToType<0x300a,0x0206> {
26474 static const char* GetVRString() { return "SQ"; }
26475 typedef VRToType<VR::SQ>::Type Type;
26476 enum : long long { VRType = VR::SQ };
26477 enum { VMType = VM::VM1 };
26478 static const char* GetVMString() { return "1"; }
26479 };
26480 template <> struct TagToType<0x300a,0x0210> {
26481 static const char* GetVRString() { return "SQ"; }
26482 typedef VRToType<VR::SQ>::Type Type;
26483 enum : long long { VRType = VR::SQ };
26484 enum { VMType = VM::VM1 };
26485 static const char* GetVMString() { return "1"; }
26486 };
26487 template <> struct TagToType<0x300a,0x0212> {
26488 static const char* GetVRString() { return "IS"; }
26489 typedef VRToType<VR::IS>::Type Type;
26490 enum : long long { VRType = VR::IS };
26491 enum { VMType = VM::VM1 };
26492 static const char* GetVMString() { return "1"; }
26493 };
26494 template <> struct TagToType<0x300a,0x0214> {
26495 static const char* GetVRString() { return "CS"; }
26496 typedef VRToType<VR::CS>::Type Type;
26497 enum : long long { VRType = VR::CS };
26498 enum { VMType = VM::VM1 };
26499 static const char* GetVMString() { return "1"; }
26500 };
26501 template <> struct TagToType<0x300a,0x0216> {
26502 static const char* GetVRString() { return "LO"; }
26503 typedef VRToType<VR::LO>::Type Type;
26504 enum : long long { VRType = VR::LO };
26505 enum { VMType = VM::VM1 };
26506 static const char* GetVMString() { return "1"; }
26507 };
26508 template <> struct TagToType<0x300a,0x0218> {
26509 static const char* GetVRString() { return "DS"; }
26510 typedef VRToType<VR::DS>::Type Type;
26511 enum : long long { VRType = VR::DS };
26512 enum { VMType = VM::VM1 };
26513 static const char* GetVMString() { return "1"; }
26514 };
26515 template <> struct TagToType<0x300a,0x021a> {
26516 static const char* GetVRString() { return "DS"; }
26517 typedef VRToType<VR::DS>::Type Type;
26518 enum : long long { VRType = VR::DS };
26519 enum { VMType = VM::VM1 };
26520 static const char* GetVMString() { return "1"; }
26521 };
26522 template <> struct TagToType<0x300a,0x021b> {
26523 static const char* GetVRString() { return "SH"; }
26524 typedef VRToType<VR::SH>::Type Type;
26525 enum : long long { VRType = VR::SH };
26526 enum { VMType = VM::VM1 };
26527 static const char* GetVMString() { return "1"; }
26528 };
26529 template <> struct TagToType<0x300a,0x021c> {
26530 static const char* GetVRString() { return "LO"; }
26531 typedef VRToType<VR::LO>::Type Type;
26532 enum : long long { VRType = VR::LO };
26533 enum { VMType = VM::VM1 };
26534 static const char* GetVMString() { return "1"; }
26535 };
26536 template <> struct TagToType<0x300a,0x0222> {
26537 static const char* GetVRString() { return "DS"; }
26538 typedef VRToType<VR::DS>::Type Type;
26539 enum : long long { VRType = VR::DS };
26540 enum { VMType = VM::VM1 };
26541 static const char* GetVMString() { return "1"; }
26542 };
26543 template <> struct TagToType<0x300a,0x0224> {
26544 static const char* GetVRString() { return "DS"; }
26545 typedef VRToType<VR::DS>::Type Type;
26546 enum : long long { VRType = VR::DS };
26547 enum { VMType = VM::VM1 };
26548 static const char* GetVMString() { return "1"; }
26549 };
26550 template <> struct TagToType<0x300a,0x0226> {
26551 static const char* GetVRString() { return "LO"; }
26552 typedef VRToType<VR::LO>::Type Type;
26553 enum : long long { VRType = VR::LO };
26554 enum { VMType = VM::VM1 };
26555 static const char* GetVMString() { return "1"; }
26556 };
26557 template <> struct TagToType<0x300a,0x0228> {
26558 static const char* GetVRString() { return "DS"; }
26559 typedef VRToType<VR::DS>::Type Type;
26560 enum : long long { VRType = VR::DS };
26561 enum { VMType = VM::VM1 };
26562 static const char* GetVMString() { return "1"; }
26563 };
26564 template <> struct TagToType<0x300a,0x0229> {
26565 static const char* GetVRString() { return "CS"; }
26566 typedef VRToType<VR::CS>::Type Type;
26567 enum : long long { VRType = VR::CS };
26568 enum { VMType = VM::VM1 };
26569 static const char* GetVMString() { return "1"; }
26570 };
26571 template <> struct TagToType<0x300a,0x022a> {
26572 static const char* GetVRString() { return "DS"; }
26573 typedef VRToType<VR::DS>::Type Type;
26574 enum : long long { VRType = VR::DS };
26575 enum { VMType = VM::VM1 };
26576 static const char* GetVMString() { return "1"; }
26577 };
26578 template <> struct TagToType<0x300a,0x022b> {
26579 static const char* GetVRString() { return "DS"; }
26580 typedef VRToType<VR::DS>::Type Type;
26581 enum : long long { VRType = VR::DS };
26582 enum { VMType = VM::VM1 };
26583 static const char* GetVMString() { return "1"; }
26584 };
26585 template <> struct TagToType<0x300a,0x022c> {
26586 static const char* GetVRString() { return "DA"; }
26587 typedef VRToType<VR::DA>::Type Type;
26588 enum : long long { VRType = VR::DA };
26589 enum { VMType = VM::VM1 };
26590 static const char* GetVMString() { return "1"; }
26591 };
26592 template <> struct TagToType<0x300a,0x022e> {
26593 static const char* GetVRString() { return "TM"; }
26594 typedef VRToType<VR::TM>::Type Type;
26595 enum : long long { VRType = VR::TM };
26596 enum { VMType = VM::VM1 };
26597 static const char* GetVMString() { return "1"; }
26598 };
26599 template <> struct TagToType<0x300a,0x0230> {
26600 static const char* GetVRString() { return "SQ"; }
26601 typedef VRToType<VR::SQ>::Type Type;
26602 enum : long long { VRType = VR::SQ };
26603 enum { VMType = VM::VM1 };
26604 static const char* GetVMString() { return "1"; }
26605 };
26606 template <> struct TagToType<0x300a,0x0232> {
26607 static const char* GetVRString() { return "CS"; }
26608 typedef VRToType<VR::CS>::Type Type;
26609 enum : long long { VRType = VR::CS };
26610 enum { VMType = VM::VM1 };
26611 static const char* GetVMString() { return "1"; }
26612 };
26613 template <> struct TagToType<0x300a,0x0234> {
26614 static const char* GetVRString() { return "IS"; }
26615 typedef VRToType<VR::IS>::Type Type;
26616 enum : long long { VRType = VR::IS };
26617 enum { VMType = VM::VM1 };
26618 static const char* GetVMString() { return "1"; }
26619 };
26620 template <> struct TagToType<0x300a,0x0236> {
26621 static const char* GetVRString() { return "LO"; }
26622 typedef VRToType<VR::LO>::Type Type;
26623 enum : long long { VRType = VR::LO };
26624 enum { VMType = VM::VM1 };
26625 static const char* GetVMString() { return "1"; }
26626 };
26627 template <> struct TagToType<0x300a,0x0238> {
26628 static const char* GetVRString() { return "LO"; }
26629 typedef VRToType<VR::LO>::Type Type;
26630 enum : long long { VRType = VR::LO };
26631 enum { VMType = VM::VM1 };
26632 static const char* GetVMString() { return "1"; }
26633 };
26634 template <> struct TagToType<0x300a,0x0240> {
26635 static const char* GetVRString() { return "IS"; }
26636 typedef VRToType<VR::IS>::Type Type;
26637 enum : long long { VRType = VR::IS };
26638 enum { VMType = VM::VM1 };
26639 static const char* GetVMString() { return "1"; }
26640 };
26641 template <> struct TagToType<0x300a,0x0242> {
26642 static const char* GetVRString() { return "SH"; }
26643 typedef VRToType<VR::SH>::Type Type;
26644 enum : long long { VRType = VR::SH };
26645 enum { VMType = VM::VM1 };
26646 static const char* GetVMString() { return "1"; }
26647 };
26648 template <> struct TagToType<0x300a,0x0244> {
26649 static const char* GetVRString() { return "LO"; }
26650 typedef VRToType<VR::LO>::Type Type;
26651 enum : long long { VRType = VR::LO };
26652 enum { VMType = VM::VM1 };
26653 static const char* GetVMString() { return "1"; }
26654 };
26655 template <> struct TagToType<0x300a,0x0250> {
26656 static const char* GetVRString() { return "DS"; }
26657 typedef VRToType<VR::DS>::Type Type;
26658 enum : long long { VRType = VR::DS };
26659 enum { VMType = VM::VM1 };
26660 static const char* GetVMString() { return "1"; }
26661 };
26662 template <> struct TagToType<0x300a,0x0260> {
26663 static const char* GetVRString() { return "SQ"; }
26664 typedef VRToType<VR::SQ>::Type Type;
26665 enum : long long { VRType = VR::SQ };
26666 enum { VMType = VM::VM1 };
26667 static const char* GetVMString() { return "1"; }
26668 };
26669 template <> struct TagToType<0x300a,0x0262> {
26670 static const char* GetVRString() { return "IS"; }
26671 typedef VRToType<VR::IS>::Type Type;
26672 enum : long long { VRType = VR::IS };
26673 enum { VMType = VM::VM1 };
26674 static const char* GetVMString() { return "1"; }
26675 };
26676 template <> struct TagToType<0x300a,0x0263> {
26677 static const char* GetVRString() { return "SH"; }
26678 typedef VRToType<VR::SH>::Type Type;
26679 enum : long long { VRType = VR::SH };
26680 enum { VMType = VM::VM1 };
26681 static const char* GetVMString() { return "1"; }
26682 };
26683 template <> struct TagToType<0x300a,0x0264> {
26684 static const char* GetVRString() { return "CS"; }
26685 typedef VRToType<VR::CS>::Type Type;
26686 enum : long long { VRType = VR::CS };
26687 enum { VMType = VM::VM1 };
26688 static const char* GetVMString() { return "1"; }
26689 };
26690 template <> struct TagToType<0x300a,0x0266> {
26691 static const char* GetVRString() { return "LO"; }
26692 typedef VRToType<VR::LO>::Type Type;
26693 enum : long long { VRType = VR::LO };
26694 enum { VMType = VM::VM1 };
26695 static const char* GetVMString() { return "1"; }
26696 };
26697 template <> struct TagToType<0x300a,0x026a> {
26698 static const char* GetVRString() { return "DS"; }
26699 typedef VRToType<VR::DS>::Type Type;
26700 enum : long long { VRType = VR::DS };
26701 enum { VMType = VM::VM1 };
26702 static const char* GetVMString() { return "1"; }
26703 };
26704 template <> struct TagToType<0x300a,0x026c> {
26705 static const char* GetVRString() { return "DS"; }
26706 typedef VRToType<VR::DS>::Type Type;
26707 enum : long long { VRType = VR::DS };
26708 enum { VMType = VM::VM1 };
26709 static const char* GetVMString() { return "1"; }
26710 };
26711 template <> struct TagToType<0x300a,0x0280> {
26712 static const char* GetVRString() { return "SQ"; }
26713 typedef VRToType<VR::SQ>::Type Type;
26714 enum : long long { VRType = VR::SQ };
26715 enum { VMType = VM::VM1 };
26716 static const char* GetVMString() { return "1"; }
26717 };
26718 template <> struct TagToType<0x300a,0x0282> {
26719 static const char* GetVRString() { return "IS"; }
26720 typedef VRToType<VR::IS>::Type Type;
26721 enum : long long { VRType = VR::IS };
26722 enum { VMType = VM::VM1 };
26723 static const char* GetVMString() { return "1"; }
26724 };
26725 template <> struct TagToType<0x300a,0x0284> {
26726 static const char* GetVRString() { return "DS"; }
26727 typedef VRToType<VR::DS>::Type Type;
26728 enum : long long { VRType = VR::DS };
26729 enum { VMType = VM::VM1 };
26730 static const char* GetVMString() { return "1"; }
26731 };
26732 template <> struct TagToType<0x300a,0x0286> {
26733 static const char* GetVRString() { return "DS"; }
26734 typedef VRToType<VR::DS>::Type Type;
26735 enum : long long { VRType = VR::DS };
26736 enum { VMType = VM::VM1 };
26737 static const char* GetVMString() { return "1"; }
26738 };
26739 template <> struct TagToType<0x300a,0x0288> {
26740 static const char* GetVRString() { return "CS"; }
26741 typedef VRToType<VR::CS>::Type Type;
26742 enum : long long { VRType = VR::CS };
26743 enum { VMType = VM::VM1 };
26744 static const char* GetVMString() { return "1"; }
26745 };
26746 template <> struct TagToType<0x300a,0x028a> {
26747 static const char* GetVRString() { return "IS"; }
26748 typedef VRToType<VR::IS>::Type Type;
26749 enum : long long { VRType = VR::IS };
26750 enum { VMType = VM::VM1 };
26751 static const char* GetVMString() { return "1"; }
26752 };
26753 template <> struct TagToType<0x300a,0x028c> {
26754 static const char* GetVRString() { return "DS"; }
26755 typedef VRToType<VR::DS>::Type Type;
26756 enum : long long { VRType = VR::DS };
26757 enum { VMType = VM::VM1 };
26758 static const char* GetVMString() { return "1"; }
26759 };
26760 template <> struct TagToType<0x300a,0x0290> {
26761 static const char* GetVRString() { return "IS"; }
26762 typedef VRToType<VR::IS>::Type Type;
26763 enum : long long { VRType = VR::IS };
26764 enum { VMType = VM::VM1 };
26765 static const char* GetVMString() { return "1"; }
26766 };
26767 template <> struct TagToType<0x300a,0x0291> {
26768 static const char* GetVRString() { return "SH"; }
26769 typedef VRToType<VR::SH>::Type Type;
26770 enum : long long { VRType = VR::SH };
26771 enum { VMType = VM::VM1 };
26772 static const char* GetVMString() { return "1"; }
26773 };
26774 template <> struct TagToType<0x300a,0x0292> {
26775 static const char* GetVRString() { return "CS"; }
26776 typedef VRToType<VR::CS>::Type Type;
26777 enum : long long { VRType = VR::CS };
26778 enum { VMType = VM::VM1 };
26779 static const char* GetVMString() { return "1"; }
26780 };
26781 template <> struct TagToType<0x300a,0x0294> {
26782 static const char* GetVRString() { return "LO"; }
26783 typedef VRToType<VR::LO>::Type Type;
26784 enum : long long { VRType = VR::LO };
26785 enum { VMType = VM::VM1 };
26786 static const char* GetVMString() { return "1"; }
26787 };
26788 template <> struct TagToType<0x300a,0x0296> {
26789 static const char* GetVRString() { return "DS"; }
26790 typedef VRToType<VR::DS>::Type Type;
26791 enum : long long { VRType = VR::DS };
26792 enum { VMType = VM::VM1 };
26793 static const char* GetVMString() { return "1"; }
26794 };
26795 template <> struct TagToType<0x300a,0x0298> {
26796 static const char* GetVRString() { return "LO"; }
26797 typedef VRToType<VR::LO>::Type Type;
26798 enum : long long { VRType = VR::LO };
26799 enum { VMType = VM::VM1 };
26800 static const char* GetVMString() { return "1"; }
26801 };
26802 template <> struct TagToType<0x300a,0x029c> {
26803 static const char* GetVRString() { return "DS"; }
26804 typedef VRToType<VR::DS>::Type Type;
26805 enum : long long { VRType = VR::DS };
26806 enum { VMType = VM::VM1 };
26807 static const char* GetVMString() { return "1"; }
26808 };
26809 template <> struct TagToType<0x300a,0x029e> {
26810 static const char* GetVRString() { return "DS"; }
26811 typedef VRToType<VR::DS>::Type Type;
26812 enum : long long { VRType = VR::DS };
26813 enum { VMType = VM::VM1 };
26814 static const char* GetVMString() { return "1"; }
26815 };
26816 template <> struct TagToType<0x300a,0x02a0> {
26817 static const char* GetVRString() { return "DS"; }
26818 typedef VRToType<VR::DS>::Type Type;
26819 enum : long long { VRType = VR::DS };
26820 enum { VMType = VM::VM1 };
26821 static const char* GetVMString() { return "1"; }
26822 };
26823 template <> struct TagToType<0x300a,0x02a2> {
26824 static const char* GetVRString() { return "IS"; }
26825 typedef VRToType<VR::IS>::Type Type;
26826 enum : long long { VRType = VR::IS };
26827 enum { VMType = VM::VM1 };
26828 static const char* GetVMString() { return "1"; }
26829 };
26830 template <> struct TagToType<0x300a,0x02a4> {
26831 static const char* GetVRString() { return "DS"; }
26832 typedef VRToType<VR::DS>::Type Type;
26833 enum : long long { VRType = VR::DS };
26834 enum { VMType = VM::VM1 };
26835 static const char* GetVMString() { return "1"; }
26836 };
26837 template <> struct TagToType<0x300a,0x02b0> {
26838 static const char* GetVRString() { return "SQ"; }
26839 typedef VRToType<VR::SQ>::Type Type;
26840 enum : long long { VRType = VR::SQ };
26841 enum { VMType = VM::VM1 };
26842 static const char* GetVMString() { return "1"; }
26843 };
26844 template <> struct TagToType<0x300a,0x02b2> {
26845 static const char* GetVRString() { return "IS"; }
26846 typedef VRToType<VR::IS>::Type Type;
26847 enum : long long { VRType = VR::IS };
26848 enum { VMType = VM::VM1 };
26849 static const char* GetVMString() { return "1"; }
26850 };
26851 template <> struct TagToType<0x300a,0x02b3> {
26852 static const char* GetVRString() { return "SH"; }
26853 typedef VRToType<VR::SH>::Type Type;
26854 enum : long long { VRType = VR::SH };
26855 enum { VMType = VM::VM1 };
26856 static const char* GetVMString() { return "1"; }
26857 };
26858 template <> struct TagToType<0x300a,0x02b4> {
26859 static const char* GetVRString() { return "LO"; }
26860 typedef VRToType<VR::LO>::Type Type;
26861 enum : long long { VRType = VR::LO };
26862 enum { VMType = VM::VM1 };
26863 static const char* GetVMString() { return "1"; }
26864 };
26865 template <> struct TagToType<0x300a,0x02b8> {
26866 static const char* GetVRString() { return "DS"; }
26867 typedef VRToType<VR::DS>::Type Type;
26868 enum : long long { VRType = VR::DS };
26869 enum { VMType = VM::VM1 };
26870 static const char* GetVMString() { return "1"; }
26871 };
26872 template <> struct TagToType<0x300a,0x02ba> {
26873 static const char* GetVRString() { return "DS"; }
26874 typedef VRToType<VR::DS>::Type Type;
26875 enum : long long { VRType = VR::DS };
26876 enum { VMType = VM::VM1 };
26877 static const char* GetVMString() { return "1"; }
26878 };
26879 template <> struct TagToType<0x300a,0x02c8> {
26880 static const char* GetVRString() { return "DS"; }
26881 typedef VRToType<VR::DS>::Type Type;
26882 enum : long long { VRType = VR::DS };
26883 enum { VMType = VM::VM1 };
26884 static const char* GetVMString() { return "1"; }
26885 };
26886 template <> struct TagToType<0x300a,0x02d0> {
26887 static const char* GetVRString() { return "SQ"; }
26888 typedef VRToType<VR::SQ>::Type Type;
26889 enum : long long { VRType = VR::SQ };
26890 enum { VMType = VM::VM1 };
26891 static const char* GetVMString() { return "1"; }
26892 };
26893 template <> struct TagToType<0x300a,0x02d2> {
26894 static const char* GetVRString() { return "DS"; }
26895 typedef VRToType<VR::DS>::Type Type;
26896 enum : long long { VRType = VR::DS };
26897 enum { VMType = VM::VM1 };
26898 static const char* GetVMString() { return "1"; }
26899 };
26900 template <> struct TagToType<0x300a,0x02d4> {
26901 static const char* GetVRString() { return "DS"; }
26902 typedef VRToType<VR::DS>::Type Type;
26903 enum : long long { VRType = VR::DS };
26904 enum { VMType = VM::VM3 };
26905 static const char* GetVMString() { return "3"; }
26906 };
26907 template <> struct TagToType<0x300a,0x02d6> {
26908 static const char* GetVRString() { return "DS"; }
26909 typedef VRToType<VR::DS>::Type Type;
26910 enum : long long { VRType = VR::DS };
26911 enum { VMType = VM::VM1 };
26912 static const char* GetVMString() { return "1"; }
26913 };
26914 template <> struct TagToType<0x300a,0x02e0> {
26915 static const char* GetVRString() { return "CS"; }
26916 typedef VRToType<VR::CS>::Type Type;
26917 enum : long long { VRType = VR::CS };
26918 enum { VMType = VM::VM1 };
26919 static const char* GetVMString() { return "1"; }
26920 };
26921 template <> struct TagToType<0x300a,0x02e1> {
26922 static const char* GetVRString() { return "CS"; }
26923 typedef VRToType<VR::CS>::Type Type;
26924 enum : long long { VRType = VR::CS };
26925 enum { VMType = VM::VM1 };
26926 static const char* GetVMString() { return "1"; }
26927 };
26928 template <> struct TagToType<0x300a,0x02e2> {
26929 static const char* GetVRString() { return "DS"; }
26930 typedef VRToType<VR::DS>::Type Type;
26931 enum : long long { VRType = VR::DS };
26932 enum { VMType = VM::VM1_n };
26933 static const char* GetVMString() { return "1-n"; }
26934 };
26935 template <> struct TagToType<0x300a,0x02e3> {
26936 static const char* GetVRString() { return "FL"; }
26937 typedef VRToType<VR::FL>::Type Type;
26938 enum : long long { VRType = VR::FL };
26939 enum { VMType = VM::VM1 };
26940 static const char* GetVMString() { return "1"; }
26941 };
26942 template <> struct TagToType<0x300a,0x02e4> {
26943 static const char* GetVRString() { return "FL"; }
26944 typedef VRToType<VR::FL>::Type Type;
26945 enum : long long { VRType = VR::FL };
26946 enum { VMType = VM::VM1 };
26947 static const char* GetVMString() { return "1"; }
26948 };
26949 template <> struct TagToType<0x300a,0x02e5> {
26950 static const char* GetVRString() { return "FL"; }
26951 typedef VRToType<VR::FL>::Type Type;
26952 enum : long long { VRType = VR::FL };
26953 enum { VMType = VM::VM1 };
26954 static const char* GetVMString() { return "1"; }
26955 };
26956 template <> struct TagToType<0x300a,0x02e6> {
26957 static const char* GetVRString() { return "FL"; }
26958 typedef VRToType<VR::FL>::Type Type;
26959 enum : long long { VRType = VR::FL };
26960 enum { VMType = VM::VM1_n };
26961 static const char* GetVMString() { return "1-n"; }
26962 };
26963 template <> struct TagToType<0x300a,0x02e7> {
26964 static const char* GetVRString() { return "FL"; }
26965 typedef VRToType<VR::FL>::Type Type;
26966 enum : long long { VRType = VR::FL };
26967 enum { VMType = VM::VM1 };
26968 static const char* GetVMString() { return "1"; }
26969 };
26970 template <> struct TagToType<0x300a,0x02e8> {
26971 static const char* GetVRString() { return "FL"; }
26972 typedef VRToType<VR::FL>::Type Type;
26973 enum : long long { VRType = VR::FL };
26974 enum { VMType = VM::VM1 };
26975 static const char* GetVMString() { return "1"; }
26976 };
26977 template <> struct TagToType<0x300a,0x02ea> {
26978 static const char* GetVRString() { return "SQ"; }
26979 typedef VRToType<VR::SQ>::Type Type;
26980 enum : long long { VRType = VR::SQ };
26981 enum { VMType = VM::VM1 };
26982 static const char* GetVMString() { return "1"; }
26983 };
26984 template <> struct TagToType<0x300a,0x02eb> {
26985 static const char* GetVRString() { return "LT"; }
26986 typedef VRToType<VR::LT>::Type Type;
26987 enum : long long { VRType = VR::LT };
26988 enum { VMType = VM::VM1 };
26989 static const char* GetVMString() { return "1"; }
26990 };
26991 template <> struct TagToType<0x300a,0x0302> {
26992 static const char* GetVRString() { return "IS"; }
26993 typedef VRToType<VR::IS>::Type Type;
26994 enum : long long { VRType = VR::IS };
26995 enum { VMType = VM::VM1 };
26996 static const char* GetVMString() { return "1"; }
26997 };
26998 template <> struct TagToType<0x300a,0x0304> {
26999 static const char* GetVRString() { return "IS"; }
27000 typedef VRToType<VR::IS>::Type Type;
27001 enum : long long { VRType = VR::IS };
27002 enum { VMType = VM::VM1 };
27003 static const char* GetVMString() { return "1"; }
27004 };
27005 template <> struct TagToType<0x300a,0x0306> {
27006 static const char* GetVRString() { return "SS"; }
27007 typedef VRToType<VR::SS>::Type Type;
27008 enum : long long { VRType = VR::SS };
27009 enum { VMType = VM::VM1 };
27010 static const char* GetVMString() { return "1"; }
27011 };
27012 template <> struct TagToType<0x300a,0x0308> {
27013 static const char* GetVRString() { return "CS"; }
27014 typedef VRToType<VR::CS>::Type Type;
27015 enum : long long { VRType = VR::CS };
27016 enum { VMType = VM::VM1 };
27017 static const char* GetVMString() { return "1"; }
27018 };
27019 template <> struct TagToType<0x300a,0x0309> {
27020 static const char* GetVRString() { return "CS"; }
27021 typedef VRToType<VR::CS>::Type Type;
27022 enum : long long { VRType = VR::CS };
27023 enum { VMType = VM::VM1 };
27024 static const char* GetVMString() { return "1"; }
27025 };
27026 template <> struct TagToType<0x300a,0x030a> {
27027 static const char* GetVRString() { return "FL"; }
27028 typedef VRToType<VR::FL>::Type Type;
27029 enum : long long { VRType = VR::FL };
27030 enum { VMType = VM::VM2 };
27031 static const char* GetVMString() { return "2"; }
27032 };
27033 template <> struct TagToType<0x300a,0x030c> {
27034 static const char* GetVRString() { return "SQ"; }
27035 typedef VRToType<VR::SQ>::Type Type;
27036 enum : long long { VRType = VR::SQ };
27037 enum { VMType = VM::VM1 };
27038 static const char* GetVMString() { return "1"; }
27039 };
27040 template <> struct TagToType<0x300a,0x030d> {
27041 static const char* GetVRString() { return "FL"; }
27042 typedef VRToType<VR::FL>::Type Type;
27043 enum : long long { VRType = VR::FL };
27044 enum { VMType = VM::VM1 };
27045 static const char* GetVMString() { return "1"; }
27046 };
27047 template <> struct TagToType<0x300a,0x030f> {
27048 static const char* GetVRString() { return "SH"; }
27049 typedef VRToType<VR::SH>::Type Type;
27050 enum : long long { VRType = VR::SH };
27051 enum { VMType = VM::VM1 };
27052 static const char* GetVMString() { return "1"; }
27053 };
27054 template <> struct TagToType<0x300a,0x0312> {
27055 static const char* GetVRString() { return "IS"; }
27056 typedef VRToType<VR::IS>::Type Type;
27057 enum : long long { VRType = VR::IS };
27058 enum { VMType = VM::VM1 };
27059 static const char* GetVMString() { return "1"; }
27060 };
27061 template <> struct TagToType<0x300a,0x0314> {
27062 static const char* GetVRString() { return "SQ"; }
27063 typedef VRToType<VR::SQ>::Type Type;
27064 enum : long long { VRType = VR::SQ };
27065 enum { VMType = VM::VM1 };
27066 static const char* GetVMString() { return "1"; }
27067 };
27068 template <> struct TagToType<0x300a,0x0316> {
27069 static const char* GetVRString() { return "IS"; }
27070 typedef VRToType<VR::IS>::Type Type;
27071 enum : long long { VRType = VR::IS };
27072 enum { VMType = VM::VM1 };
27073 static const char* GetVMString() { return "1"; }
27074 };
27075 template <> struct TagToType<0x300a,0x0318> {
27076 static const char* GetVRString() { return "SH"; }
27077 typedef VRToType<VR::SH>::Type Type;
27078 enum : long long { VRType = VR::SH };
27079 enum { VMType = VM::VM1 };
27080 static const char* GetVMString() { return "1"; }
27081 };
27082 template <> struct TagToType<0x300a,0x0320> {
27083 static const char* GetVRString() { return "CS"; }
27084 typedef VRToType<VR::CS>::Type Type;
27085 enum : long long { VRType = VR::CS };
27086 enum { VMType = VM::VM1 };
27087 static const char* GetVMString() { return "1"; }
27088 };
27089 template <> struct TagToType<0x300a,0x0322> {
27090 static const char* GetVRString() { return "LO"; }
27091 typedef VRToType<VR::LO>::Type Type;
27092 enum : long long { VRType = VR::LO };
27093 enum { VMType = VM::VM1 };
27094 static const char* GetVMString() { return "1"; }
27095 };
27096 template <> struct TagToType<0x300a,0x0330> {
27097 static const char* GetVRString() { return "IS"; }
27098 typedef VRToType<VR::IS>::Type Type;
27099 enum : long long { VRType = VR::IS };
27100 enum { VMType = VM::VM1 };
27101 static const char* GetVMString() { return "1"; }
27102 };
27103 template <> struct TagToType<0x300a,0x0332> {
27104 static const char* GetVRString() { return "SQ"; }
27105 typedef VRToType<VR::SQ>::Type Type;
27106 enum : long long { VRType = VR::SQ };
27107 enum { VMType = VM::VM1 };
27108 static const char* GetVMString() { return "1"; }
27109 };
27110 template <> struct TagToType<0x300a,0x0334> {
27111 static const char* GetVRString() { return "IS"; }
27112 typedef VRToType<VR::IS>::Type Type;
27113 enum : long long { VRType = VR::IS };
27114 enum { VMType = VM::VM1 };
27115 static const char* GetVMString() { return "1"; }
27116 };
27117 template <> struct TagToType<0x300a,0x0336> {
27118 static const char* GetVRString() { return "SH"; }
27119 typedef VRToType<VR::SH>::Type Type;
27120 enum : long long { VRType = VR::SH };
27121 enum { VMType = VM::VM1 };
27122 static const char* GetVMString() { return "1"; }
27123 };
27124 template <> struct TagToType<0x300a,0x0338> {
27125 static const char* GetVRString() { return "CS"; }
27126 typedef VRToType<VR::CS>::Type Type;
27127 enum : long long { VRType = VR::CS };
27128 enum { VMType = VM::VM1 };
27129 static const char* GetVMString() { return "1"; }
27130 };
27131 template <> struct TagToType<0x300a,0x033a> {
27132 static const char* GetVRString() { return "LO"; }
27133 typedef VRToType<VR::LO>::Type Type;
27134 enum : long long { VRType = VR::LO };
27135 enum { VMType = VM::VM1 };
27136 static const char* GetVMString() { return "1"; }
27137 };
27138 template <> struct TagToType<0x300a,0x033c> {
27139 static const char* GetVRString() { return "FL"; }
27140 typedef VRToType<VR::FL>::Type Type;
27141 enum : long long { VRType = VR::FL };
27142 enum { VMType = VM::VM1 };
27143 static const char* GetVMString() { return "1"; }
27144 };
27145 template <> struct TagToType<0x300a,0x0340> {
27146 static const char* GetVRString() { return "IS"; }
27147 typedef VRToType<VR::IS>::Type Type;
27148 enum : long long { VRType = VR::IS };
27149 enum { VMType = VM::VM1 };
27150 static const char* GetVMString() { return "1"; }
27151 };
27152 template <> struct TagToType<0x300a,0x0342> {
27153 static const char* GetVRString() { return "SQ"; }
27154 typedef VRToType<VR::SQ>::Type Type;
27155 enum : long long { VRType = VR::SQ };
27156 enum { VMType = VM::VM1 };
27157 static const char* GetVMString() { return "1"; }
27158 };
27159 template <> struct TagToType<0x300a,0x0344> {
27160 static const char* GetVRString() { return "IS"; }
27161 typedef VRToType<VR::IS>::Type Type;
27162 enum : long long { VRType = VR::IS };
27163 enum { VMType = VM::VM1 };
27164 static const char* GetVMString() { return "1"; }
27165 };
27166 template <> struct TagToType<0x300a,0x0346> {
27167 static const char* GetVRString() { return "SH"; }
27168 typedef VRToType<VR::SH>::Type Type;
27169 enum : long long { VRType = VR::SH };
27170 enum { VMType = VM::VM1 };
27171 static const char* GetVMString() { return "1"; }
27172 };
27173 template <> struct TagToType<0x300a,0x0348> {
27174 static const char* GetVRString() { return "CS"; }
27175 typedef VRToType<VR::CS>::Type Type;
27176 enum : long long { VRType = VR::CS };
27177 enum { VMType = VM::VM1 };
27178 static const char* GetVMString() { return "1"; }
27179 };
27180 template <> struct TagToType<0x300a,0x034a> {
27181 static const char* GetVRString() { return "LO"; }
27182 typedef VRToType<VR::LO>::Type Type;
27183 enum : long long { VRType = VR::LO };
27184 enum { VMType = VM::VM1 };
27185 static const char* GetVMString() { return "1"; }
27186 };
27187 template <> struct TagToType<0x300a,0x034c> {
27188 static const char* GetVRString() { return "SH"; }
27189 typedef VRToType<VR::SH>::Type Type;
27190 enum : long long { VRType = VR::SH };
27191 enum { VMType = VM::VM1 };
27192 static const char* GetVMString() { return "1"; }
27193 };
27194 template <> struct TagToType<0x300a,0x0350> {
27195 static const char* GetVRString() { return "CS"; }
27196 typedef VRToType<VR::CS>::Type Type;
27197 enum : long long { VRType = VR::CS };
27198 enum { VMType = VM::VM1 };
27199 static const char* GetVMString() { return "1"; }
27200 };
27201 template <> struct TagToType<0x300a,0x0352> {
27202 static const char* GetVRString() { return "SH"; }
27203 typedef VRToType<VR::SH>::Type Type;
27204 enum : long long { VRType = VR::SH };
27205 enum { VMType = VM::VM1 };
27206 static const char* GetVMString() { return "1"; }
27207 };
27208 template <> struct TagToType<0x300a,0x0354> {
27209 static const char* GetVRString() { return "LO"; }
27210 typedef VRToType<VR::LO>::Type Type;
27211 enum : long long { VRType = VR::LO };
27212 enum { VMType = VM::VM1 };
27213 static const char* GetVMString() { return "1"; }
27214 };
27215 template <> struct TagToType<0x300a,0x0355> {
27216 static const char* GetVRString() { return "LO"; }
27217 typedef VRToType<VR::LO>::Type Type;
27218 enum : long long { VRType = VR::LO };
27219 enum { VMType = VM::VM1 };
27220 static const char* GetVMString() { return "1"; }
27221 };
27222 template <> struct TagToType<0x300a,0x0356> {
27223 static const char* GetVRString() { return "FL"; }
27224 typedef VRToType<VR::FL>::Type Type;
27225 enum : long long { VRType = VR::FL };
27226 enum { VMType = VM::VM1 };
27227 static const char* GetVMString() { return "1"; }
27228 };
27229 template <> struct TagToType<0x300a,0x0358> {
27230 static const char* GetVRString() { return "FL"; }
27231 typedef VRToType<VR::FL>::Type Type;
27232 enum : long long { VRType = VR::FL };
27233 enum { VMType = VM::VM1 };
27234 static const char* GetVMString() { return "1"; }
27235 };
27236 template <> struct TagToType<0x300a,0x035a> {
27237 static const char* GetVRString() { return "FL"; }
27238 typedef VRToType<VR::FL>::Type Type;
27239 enum : long long { VRType = VR::FL };
27240 enum { VMType = VM::VM1 };
27241 static const char* GetVMString() { return "1"; }
27242 };
27243 template <> struct TagToType<0x300a,0x0360> {
27244 static const char* GetVRString() { return "SQ"; }
27245 typedef VRToType<VR::SQ>::Type Type;
27246 enum : long long { VRType = VR::SQ };
27247 enum { VMType = VM::VM1 };
27248 static const char* GetVMString() { return "1"; }
27249 };
27250 template <> struct TagToType<0x300a,0x0362> {
27251 static const char* GetVRString() { return "LO"; }
27252 typedef VRToType<VR::LO>::Type Type;
27253 enum : long long { VRType = VR::LO };
27254 enum { VMType = VM::VM1 };
27255 static const char* GetVMString() { return "1"; }
27256 };
27257 template <> struct TagToType<0x300a,0x0364> {
27258 static const char* GetVRString() { return "FL"; }
27259 typedef VRToType<VR::FL>::Type Type;
27260 enum : long long { VRType = VR::FL };
27261 enum { VMType = VM::VM1 };
27262 static const char* GetVMString() { return "1"; }
27263 };
27264 template <> struct TagToType<0x300a,0x0366> {
27265 static const char* GetVRString() { return "FL"; }
27266 typedef VRToType<VR::FL>::Type Type;
27267 enum : long long { VRType = VR::FL };
27268 enum { VMType = VM::VM1 };
27269 static const char* GetVMString() { return "1"; }
27270 };
27271 template <> struct TagToType<0x300a,0x0370> {
27272 static const char* GetVRString() { return "SQ"; }
27273 typedef VRToType<VR::SQ>::Type Type;
27274 enum : long long { VRType = VR::SQ };
27275 enum { VMType = VM::VM1 };
27276 static const char* GetVMString() { return "1"; }
27277 };
27278 template <> struct TagToType<0x300a,0x0372> {
27279 static const char* GetVRString() { return "LO"; }
27280 typedef VRToType<VR::LO>::Type Type;
27281 enum : long long { VRType = VR::LO };
27282 enum { VMType = VM::VM1 };
27283 static const char* GetVMString() { return "1"; }
27284 };
27285 template <> struct TagToType<0x300a,0x0374> {
27286 static const char* GetVRString() { return "FL"; }
27287 typedef VRToType<VR::FL>::Type Type;
27288 enum : long long { VRType = VR::FL };
27289 enum { VMType = VM::VM1 };
27290 static const char* GetVMString() { return "1"; }
27291 };
27292 template <> struct TagToType<0x300a,0x0380> {
27293 static const char* GetVRString() { return "SQ"; }
27294 typedef VRToType<VR::SQ>::Type Type;
27295 enum : long long { VRType = VR::SQ };
27296 enum { VMType = VM::VM1 };
27297 static const char* GetVMString() { return "1"; }
27298 };
27299 template <> struct TagToType<0x300a,0x0382> {
27300 static const char* GetVRString() { return "FL"; }
27301 typedef VRToType<VR::FL>::Type Type;
27302 enum : long long { VRType = VR::FL };
27303 enum { VMType = VM::VM1 };
27304 static const char* GetVMString() { return "1"; }
27305 };
27306 template <> struct TagToType<0x300a,0x0384> {
27307 static const char* GetVRString() { return "FL"; }
27308 typedef VRToType<VR::FL>::Type Type;
27309 enum : long long { VRType = VR::FL };
27310 enum { VMType = VM::VM1 };
27311 static const char* GetVMString() { return "1"; }
27312 };
27313 template <> struct TagToType<0x300a,0x0386> {
27314 static const char* GetVRString() { return "FL"; }
27315 typedef VRToType<VR::FL>::Type Type;
27316 enum : long long { VRType = VR::FL };
27317 enum { VMType = VM::VM1 };
27318 static const char* GetVMString() { return "1"; }
27319 };
27320 template <> struct TagToType<0x300a,0x0388> {
27321 static const char* GetVRString() { return "FL"; }
27322 typedef VRToType<VR::FL>::Type Type;
27323 enum : long long { VRType = VR::FL };
27324 enum { VMType = VM::VM1 };
27325 static const char* GetVMString() { return "1"; }
27326 };
27327 template <> struct TagToType<0x300a,0x038a> {
27328 static const char* GetVRString() { return "FL"; }
27329 typedef VRToType<VR::FL>::Type Type;
27330 enum : long long { VRType = VR::FL };
27331 enum { VMType = VM::VM1 };
27332 static const char* GetVMString() { return "1"; }
27333 };
27334 template <> struct TagToType<0x300a,0x038f> {
27335 static const char* GetVRString() { return "FL"; }
27336 typedef VRToType<VR::FL>::Type Type;
27337 enum : long long { VRType = VR::FL };
27338 enum { VMType = VM::VM1_n };
27339 static const char* GetVMString() { return "1-n"; }
27340 };
27341 template <> struct TagToType<0x300a,0x0390> {
27342 static const char* GetVRString() { return "SH"; }
27343 typedef VRToType<VR::SH>::Type Type;
27344 enum : long long { VRType = VR::SH };
27345 enum { VMType = VM::VM1 };
27346 static const char* GetVMString() { return "1"; }
27347 };
27348 template <> struct TagToType<0x300a,0x0391> {
27349 static const char* GetVRString() { return "IS"; }
27350 typedef VRToType<VR::IS>::Type Type;
27351 enum : long long { VRType = VR::IS };
27352 enum { VMType = VM::VM1_n };
27353 static const char* GetVMString() { return "1-n"; }
27354 };
27355 template <> struct TagToType<0x300a,0x0392> {
27356 static const char* GetVRString() { return "IS"; }
27357 typedef VRToType<VR::IS>::Type Type;
27358 enum : long long { VRType = VR::IS };
27359 enum { VMType = VM::VM1 };
27360 static const char* GetVMString() { return "1"; }
27361 };
27362 template <> struct TagToType<0x300a,0x0393> {
27363 static const char* GetVRString() { return "CS"; }
27364 typedef VRToType<VR::CS>::Type Type;
27365 enum : long long { VRType = VR::CS };
27366 enum { VMType = VM::VM1 };
27367 static const char* GetVMString() { return "1"; }
27368 };
27369 template <> struct TagToType<0x300a,0x0394> {
27370 static const char* GetVRString() { return "FL"; }
27371 typedef VRToType<VR::FL>::Type Type;
27372 enum : long long { VRType = VR::FL };
27373 enum { VMType = VM::VM1_n };
27374 static const char* GetVMString() { return "1-n"; }
27375 };
27376 template <> struct TagToType<0x300a,0x0395> {
27377 static const char* GetVRString() { return "CS"; }
27378 typedef VRToType<VR::CS>::Type Type;
27379 enum : long long { VRType = VR::CS };
27380 enum { VMType = VM::VM1 };
27381 static const char* GetVMString() { return "1"; }
27382 };
27383 template <> struct TagToType<0x300a,0x0396> {
27384 static const char* GetVRString() { return "FL"; }
27385 typedef VRToType<VR::FL>::Type Type;
27386 enum : long long { VRType = VR::FL };
27387 enum { VMType = VM::VM1_n };
27388 static const char* GetVMString() { return "1-n"; }
27389 };
27390 template <> struct TagToType<0x300a,0x0398> {
27391 static const char* GetVRString() { return "FL"; }
27392 typedef VRToType<VR::FL>::Type Type;
27393 enum : long long { VRType = VR::FL };
27394 enum { VMType = VM::VM2 };
27395 static const char* GetVMString() { return "2"; }
27396 };
27397 template <> struct TagToType<0x300a,0x039a> {
27398 static const char* GetVRString() { return "IS"; }
27399 typedef VRToType<VR::IS>::Type Type;
27400 enum : long long { VRType = VR::IS };
27401 enum { VMType = VM::VM1 };
27402 static const char* GetVMString() { return "1"; }
27403 };
27404 template <> struct TagToType<0x300a,0x03a0> {
27405 static const char* GetVRString() { return "SQ"; }
27406 typedef VRToType<VR::SQ>::Type Type;
27407 enum : long long { VRType = VR::SQ };
27408 enum { VMType = VM::VM1 };
27409 static const char* GetVMString() { return "1"; }
27410 };
27411 template <> struct TagToType<0x300a,0x03a2> {
27412 static const char* GetVRString() { return "SQ"; }
27413 typedef VRToType<VR::SQ>::Type Type;
27414 enum : long long { VRType = VR::SQ };
27415 enum { VMType = VM::VM1 };
27416 static const char* GetVMString() { return "1"; }
27417 };
27418 template <> struct TagToType<0x300a,0x03a4> {
27419 static const char* GetVRString() { return "SQ"; }
27420 typedef VRToType<VR::SQ>::Type Type;
27421 enum : long long { VRType = VR::SQ };
27422 enum { VMType = VM::VM1 };
27423 static const char* GetVMString() { return "1"; }
27424 };
27425 template <> struct TagToType<0x300a,0x03a6> {
27426 static const char* GetVRString() { return "SQ"; }
27427 typedef VRToType<VR::SQ>::Type Type;
27428 enum : long long { VRType = VR::SQ };
27429 enum { VMType = VM::VM1 };
27430 static const char* GetVMString() { return "1"; }
27431 };
27432 template <> struct TagToType<0x300a,0x03a8> {
27433 static const char* GetVRString() { return "SQ"; }
27434 typedef VRToType<VR::SQ>::Type Type;
27435 enum : long long { VRType = VR::SQ };
27436 enum { VMType = VM::VM1 };
27437 static const char* GetVMString() { return "1"; }
27438 };
27439 template <> struct TagToType<0x300a,0x03aa> {
27440 static const char* GetVRString() { return "SQ"; }
27441 typedef VRToType<VR::SQ>::Type Type;
27442 enum : long long { VRType = VR::SQ };
27443 enum { VMType = VM::VM1 };
27444 static const char* GetVMString() { return "1"; }
27445 };
27446 template <> struct TagToType<0x300a,0x03ac> {
27447 static const char* GetVRString() { return "SQ"; }
27448 typedef VRToType<VR::SQ>::Type Type;
27449 enum : long long { VRType = VR::SQ };
27450 enum { VMType = VM::VM1 };
27451 static const char* GetVMString() { return "1"; }
27452 };
27453 template <> struct TagToType<0x300a,0x0401> {
27454 static const char* GetVRString() { return "SQ"; }
27455 typedef VRToType<VR::SQ>::Type Type;
27456 enum : long long { VRType = VR::SQ };
27457 enum { VMType = VM::VM1 };
27458 static const char* GetVMString() { return "1"; }
27459 };
27460 template <> struct TagToType<0x300a,0x0402> {
27461 static const char* GetVRString() { return "ST"; }
27462 typedef VRToType<VR::ST>::Type Type;
27463 enum : long long { VRType = VR::ST };
27464 enum { VMType = VM::VM1 };
27465 static const char* GetVMString() { return "1"; }
27466 };
27467 template <> struct TagToType<0x300a,0x0410> {
27468 static const char* GetVRString() { return "SQ"; }
27469 typedef VRToType<VR::SQ>::Type Type;
27470 enum : long long { VRType = VR::SQ };
27471 enum { VMType = VM::VM1 };
27472 static const char* GetVMString() { return "1"; }
27473 };
27474 template <> struct TagToType<0x300a,0x0412> {
27475 static const char* GetVRString() { return "FL"; }
27476 typedef VRToType<VR::FL>::Type Type;
27477 enum : long long { VRType = VR::FL };
27478 enum { VMType = VM::VM3 };
27479 static const char* GetVMString() { return "3"; }
27480 };
27481 template <> struct TagToType<0x300a,0x0420> {
27482 static const char* GetVRString() { return "SQ"; }
27483 typedef VRToType<VR::SQ>::Type Type;
27484 enum : long long { VRType = VR::SQ };
27485 enum { VMType = VM::VM1 };
27486 static const char* GetVMString() { return "1"; }
27487 };
27488 template <> struct TagToType<0x300a,0x0421> {
27489 static const char* GetVRString() { return "SH"; }
27490 typedef VRToType<VR::SH>::Type Type;
27491 enum : long long { VRType = VR::SH };
27492 enum { VMType = VM::VM1 };
27493 static const char* GetVMString() { return "1"; }
27494 };
27495 template <> struct TagToType<0x300a,0x0422> {
27496 static const char* GetVRString() { return "ST"; }
27497 typedef VRToType<VR::ST>::Type Type;
27498 enum : long long { VRType = VR::ST };
27499 enum { VMType = VM::VM1 };
27500 static const char* GetVMString() { return "1"; }
27501 };
27502 template <> struct TagToType<0x300a,0x0423> {
27503 static const char* GetVRString() { return "CS"; }
27504 typedef VRToType<VR::CS>::Type Type;
27505 enum : long long { VRType = VR::CS };
27506 enum { VMType = VM::VM1 };
27507 static const char* GetVMString() { return "1"; }
27508 };
27509 template <> struct TagToType<0x300a,0x0424> {
27510 static const char* GetVRString() { return "IS"; }
27511 typedef VRToType<VR::IS>::Type Type;
27512 enum : long long { VRType = VR::IS };
27513 enum { VMType = VM::VM1 };
27514 static const char* GetVMString() { return "1"; }
27515 };
27516 template <> struct TagToType<0x300a,0x0425> {
27517 static const char* GetVRString() { return "FL"; }
27518 typedef VRToType<VR::FL>::Type Type;
27519 enum : long long { VRType = VR::FL };
27520 enum { VMType = VM::VM1 };
27521 static const char* GetVMString() { return "1"; }
27522 };
27523 template <> struct TagToType<0x300a,0x0431> {
27524 static const char* GetVRString() { return "SQ"; }
27525 typedef VRToType<VR::SQ>::Type Type;
27526 enum : long long { VRType = VR::SQ };
27527 enum { VMType = VM::VM1 };
27528 static const char* GetVMString() { return "1"; }
27529 };
27530 template <> struct TagToType<0x300a,0x0432> {
27531 static const char* GetVRString() { return "CS"; }
27532 typedef VRToType<VR::CS>::Type Type;
27533 enum : long long { VRType = VR::CS };
27534 enum { VMType = VM::VM1 };
27535 static const char* GetVMString() { return "1"; }
27536 };
27537 template <> struct TagToType<0x300a,0x0433> {
27538 static const char* GetVRString() { return "FL"; }
27539 typedef VRToType<VR::FL>::Type Type;
27540 enum : long long { VRType = VR::FL };
27541 enum { VMType = VM::VM1 };
27542 static const char* GetVMString() { return "1"; }
27543 };
27544 template <> struct TagToType<0x300a,0x0434> {
27545 static const char* GetVRString() { return "FL"; }
27546 typedef VRToType<VR::FL>::Type Type;
27547 enum : long long { VRType = VR::FL };
27548 enum { VMType = VM::VM1 };
27549 static const char* GetVMString() { return "1"; }
27550 };
27551 template <> struct TagToType<0x300a,0x0435> {
27552 static const char* GetVRString() { return "FL"; }
27553 typedef VRToType<VR::FL>::Type Type;
27554 enum : long long { VRType = VR::FL };
27555 enum { VMType = VM::VM1 };
27556 static const char* GetVMString() { return "1"; }
27557 };
27558 template <> struct TagToType<0x300a,0x0436> {
27559 static const char* GetVRString() { return "FL"; }
27560 typedef VRToType<VR::FL>::Type Type;
27561 enum : long long { VRType = VR::FL };
27562 enum { VMType = VM::VM1 };
27563 static const char* GetVMString() { return "1"; }
27564 };
27565 template <> struct TagToType<0x300a,0x0440> {
27566 static const char* GetVRString() { return "IS"; }
27567 typedef VRToType<VR::IS>::Type Type;
27568 enum : long long { VRType = VR::IS };
27569 enum { VMType = VM::VM1 };
27570 static const char* GetVMString() { return "1"; }
27571 };
27572 template <> struct TagToType<0x300a,0x0441> {
27573 static const char* GetVRString() { return "SQ"; }
27574 typedef VRToType<VR::SQ>::Type Type;
27575 enum : long long { VRType = VR::SQ };
27576 enum { VMType = VM::VM1 };
27577 static const char* GetVMString() { return "1"; }
27578 };
27579 template <> struct TagToType<0x300a,0x0442> {
27580 static const char* GetVRString() { return "DS"; }
27581 typedef VRToType<VR::DS>::Type Type;
27582 enum : long long { VRType = VR::DS };
27583 enum { VMType = VM::VM1 };
27584 static const char* GetVMString() { return "1"; }
27585 };
27586 template <> struct TagToType<0x300a,0x0443> {
27587 static const char* GetVRString() { return "US"; }
27588 typedef VRToType<VR::US>::Type Type;
27589 enum : long long { VRType = VR::US };
27590 enum { VMType = VM::VM1 };
27591 static const char* GetVMString() { return "1"; }
27592 };
27593 template <> struct TagToType<0x300a,0x0450> {
27594 static const char* GetVRString() { return "SQ"; }
27595 typedef VRToType<VR::SQ>::Type Type;
27596 enum : long long { VRType = VR::SQ };
27597 enum { VMType = VM::VM1 };
27598 static const char* GetVMString() { return "1"; }
27599 };
27600 template <> struct TagToType<0x300a,0x0451> {
27601 static const char* GetVRString() { return "CS"; }
27602 typedef VRToType<VR::CS>::Type Type;
27603 enum : long long { VRType = VR::CS };
27604 enum { VMType = VM::VM1 };
27605 static const char* GetVMString() { return "1"; }
27606 };
27607 template <> struct TagToType<0x300a,0x0452> {
27608 static const char* GetVRString() { return "CS"; }
27609 typedef VRToType<VR::CS>::Type Type;
27610 enum : long long { VRType = VR::CS };
27611 enum { VMType = VM::VM1 };
27612 static const char* GetVMString() { return "1"; }
27613 };
27614 template <> struct TagToType<0x300a,0x0453> {
27615 static const char* GetVRString() { return "SQ"; }
27616 typedef VRToType<VR::SQ>::Type Type;
27617 enum : long long { VRType = VR::SQ };
27618 enum { VMType = VM::VM1 };
27619 static const char* GetVMString() { return "1"; }
27620 };
27621 template <> struct TagToType<0x300a,0x0501> {
27622 static const char* GetVRString() { return "FL"; }
27623 typedef VRToType<VR::FL>::Type Type;
27624 enum : long long { VRType = VR::FL };
27625 enum { VMType = VM::VM1 };
27626 static const char* GetVMString() { return "1"; }
27627 };
27628 template <> struct TagToType<0x300a,0x0502> {
27629 static const char* GetVRString() { return "FL"; }
27630 typedef VRToType<VR::FL>::Type Type;
27631 enum : long long { VRType = VR::FL };
27632 enum { VMType = VM::VM1 };
27633 static const char* GetVMString() { return "1"; }
27634 };
27635 template <> struct TagToType<0x300a,0x0503> {
27636 static const char* GetVRString() { return "FL"; }
27637 typedef VRToType<VR::FL>::Type Type;
27638 enum : long long { VRType = VR::FL };
27639 enum { VMType = VM::VM2 };
27640 static const char* GetVMString() { return "2"; }
27641 };
27642 template <> struct TagToType<0x300a,0x0504> {
27643 static const char* GetVRString() { return "FL"; }
27644 typedef VRToType<VR::FL>::Type Type;
27645 enum : long long { VRType = VR::FL };
27646 enum { VMType = VM::VM2 };
27647 static const char* GetVMString() { return "2"; }
27648 };
27649 template <> struct TagToType<0x300a,0x0505> {
27650 static const char* GetVRString() { return "SQ"; }
27651 typedef VRToType<VR::SQ>::Type Type;
27652 enum : long long { VRType = VR::SQ };
27653 enum { VMType = VM::VM1 };
27654 static const char* GetVMString() { return "1"; }
27655 };
27656 template <> struct TagToType<0x300a,0x0506> {
27657 static const char* GetVRString() { return "SQ"; }
27658 typedef VRToType<VR::SQ>::Type Type;
27659 enum : long long { VRType = VR::SQ };
27660 enum { VMType = VM::VM1 };
27661 static const char* GetVMString() { return "1"; }
27662 };
27663 template <> struct TagToType<0x300a,0x0507> {
27664 static const char* GetVRString() { return "FL"; }
27665 typedef VRToType<VR::FL>::Type Type;
27666 enum : long long { VRType = VR::FL };
27667 enum { VMType = VM::VM1 };
27668 static const char* GetVMString() { return "1"; }
27669 };
27670 template <> struct TagToType<0x300a,0x0508> {
27671 static const char* GetVRString() { return "FL"; }
27672 typedef VRToType<VR::FL>::Type Type;
27673 enum : long long { VRType = VR::FL };
27674 enum { VMType = VM::VM1 };
27675 static const char* GetVMString() { return "1"; }
27676 };
27677 template <> struct TagToType<0x300a,0x0509> {
27678 static const char* GetVRString() { return "FL"; }
27679 typedef VRToType<VR::FL>::Type Type;
27680 enum : long long { VRType = VR::FL };
27681 enum { VMType = VM::VM2 };
27682 static const char* GetVMString() { return "2"; }
27683 };
27684 template <> struct TagToType<0x300a,0x0510> {
27685 static const char* GetVRString() { return "FL"; }
27686 typedef VRToType<VR::FL>::Type Type;
27687 enum : long long { VRType = VR::FL };
27688 enum { VMType = VM::VM2 };
27689 static const char* GetVMString() { return "2"; }
27690 };
27691 template <> struct TagToType<0x300a,0x0511> {
27692 static const char* GetVRString() { return "CS"; }
27693 typedef VRToType<VR::CS>::Type Type;
27694 enum : long long { VRType = VR::CS };
27695 enum { VMType = VM::VM1 };
27696 static const char* GetVMString() { return "1"; }
27697 };
27698 template <> struct TagToType<0x300a,0x0512> {
27699 static const char* GetVRString() { return "CS"; }
27700 typedef VRToType<VR::CS>::Type Type;
27701 enum : long long { VRType = VR::CS };
27702 enum { VMType = VM::VM1 };
27703 static const char* GetVMString() { return "1"; }
27704 };
27705 template <> struct TagToType<0x300c,0x0002> {
27706 static const char* GetVRString() { return "SQ"; }
27707 typedef VRToType<VR::SQ>::Type Type;
27708 enum : long long { VRType = VR::SQ };
27709 enum { VMType = VM::VM1 };
27710 static const char* GetVMString() { return "1"; }
27711 };
27712 template <> struct TagToType<0x300c,0x0004> {
27713 static const char* GetVRString() { return "SQ"; }
27714 typedef VRToType<VR::SQ>::Type Type;
27715 enum : long long { VRType = VR::SQ };
27716 enum { VMType = VM::VM1 };
27717 static const char* GetVMString() { return "1"; }
27718 };
27719 template <> struct TagToType<0x300c,0x0006> {
27720 static const char* GetVRString() { return "IS"; }
27721 typedef VRToType<VR::IS>::Type Type;
27722 enum : long long { VRType = VR::IS };
27723 enum { VMType = VM::VM1 };
27724 static const char* GetVMString() { return "1"; }
27725 };
27726 template <> struct TagToType<0x300c,0x0007> {
27727 static const char* GetVRString() { return "IS"; }
27728 typedef VRToType<VR::IS>::Type Type;
27729 enum : long long { VRType = VR::IS };
27730 enum { VMType = VM::VM1 };
27731 static const char* GetVMString() { return "1"; }
27732 };
27733 template <> struct TagToType<0x300c,0x0008> {
27734 static const char* GetVRString() { return "DS"; }
27735 typedef VRToType<VR::DS>::Type Type;
27736 enum : long long { VRType = VR::DS };
27737 enum { VMType = VM::VM1 };
27738 static const char* GetVMString() { return "1"; }
27739 };
27740 template <> struct TagToType<0x300c,0x0009> {
27741 static const char* GetVRString() { return "DS"; }
27742 typedef VRToType<VR::DS>::Type Type;
27743 enum : long long { VRType = VR::DS };
27744 enum { VMType = VM::VM1 };
27745 static const char* GetVMString() { return "1"; }
27746 };
27747 template <> struct TagToType<0x300c,0x000a> {
27748 static const char* GetVRString() { return "SQ"; }
27749 typedef VRToType<VR::SQ>::Type Type;
27750 enum : long long { VRType = VR::SQ };
27751 enum { VMType = VM::VM1 };
27752 static const char* GetVMString() { return "1"; }
27753 };
27754 template <> struct TagToType<0x300c,0x000c> {
27755 static const char* GetVRString() { return "IS"; }
27756 typedef VRToType<VR::IS>::Type Type;
27757 enum : long long { VRType = VR::IS };
27758 enum { VMType = VM::VM1 };
27759 static const char* GetVMString() { return "1"; }
27760 };
27761 template <> struct TagToType<0x300c,0x000e> {
27762 static const char* GetVRString() { return "IS"; }
27763 typedef VRToType<VR::IS>::Type Type;
27764 enum : long long { VRType = VR::IS };
27765 enum { VMType = VM::VM1 };
27766 static const char* GetVMString() { return "1"; }
27767 };
27768 template <> struct TagToType<0x300c,0x0020> {
27769 static const char* GetVRString() { return "SQ"; }
27770 typedef VRToType<VR::SQ>::Type Type;
27771 enum : long long { VRType = VR::SQ };
27772 enum { VMType = VM::VM1 };
27773 static const char* GetVMString() { return "1"; }
27774 };
27775 template <> struct TagToType<0x300c,0x0022> {
27776 static const char* GetVRString() { return "IS"; }
27777 typedef VRToType<VR::IS>::Type Type;
27778 enum : long long { VRType = VR::IS };
27779 enum { VMType = VM::VM1 };
27780 static const char* GetVMString() { return "1"; }
27781 };
27782 template <> struct TagToType<0x300c,0x0040> {
27783 static const char* GetVRString() { return "SQ"; }
27784 typedef VRToType<VR::SQ>::Type Type;
27785 enum : long long { VRType = VR::SQ };
27786 enum { VMType = VM::VM1 };
27787 static const char* GetVMString() { return "1"; }
27788 };
27789 template <> struct TagToType<0x300c,0x0042> {
27790 static const char* GetVRString() { return "SQ"; }
27791 typedef VRToType<VR::SQ>::Type Type;
27792 enum : long long { VRType = VR::SQ };
27793 enum { VMType = VM::VM1 };
27794 static const char* GetVMString() { return "1"; }
27795 };
27796 template <> struct TagToType<0x300c,0x0050> {
27797 static const char* GetVRString() { return "SQ"; }
27798 typedef VRToType<VR::SQ>::Type Type;
27799 enum : long long { VRType = VR::SQ };
27800 enum { VMType = VM::VM1 };
27801 static const char* GetVMString() { return "1"; }
27802 };
27803 template <> struct TagToType<0x300c,0x0051> {
27804 static const char* GetVRString() { return "IS"; }
27805 typedef VRToType<VR::IS>::Type Type;
27806 enum : long long { VRType = VR::IS };
27807 enum { VMType = VM::VM1 };
27808 static const char* GetVMString() { return "1"; }
27809 };
27810 template <> struct TagToType<0x300c,0x0055> {
27811 static const char* GetVRString() { return "SQ"; }
27812 typedef VRToType<VR::SQ>::Type Type;
27813 enum : long long { VRType = VR::SQ };
27814 enum { VMType = VM::VM1 };
27815 static const char* GetVMString() { return "1"; }
27816 };
27817 template <> struct TagToType<0x300c,0x0060> {
27818 static const char* GetVRString() { return "SQ"; }
27819 typedef VRToType<VR::SQ>::Type Type;
27820 enum : long long { VRType = VR::SQ };
27821 enum { VMType = VM::VM1 };
27822 static const char* GetVMString() { return "1"; }
27823 };
27824 template <> struct TagToType<0x300c,0x006a> {
27825 static const char* GetVRString() { return "IS"; }
27826 typedef VRToType<VR::IS>::Type Type;
27827 enum : long long { VRType = VR::IS };
27828 enum { VMType = VM::VM1 };
27829 static const char* GetVMString() { return "1"; }
27830 };
27831 template <> struct TagToType<0x300c,0x0080> {
27832 static const char* GetVRString() { return "SQ"; }
27833 typedef VRToType<VR::SQ>::Type Type;
27834 enum : long long { VRType = VR::SQ };
27835 enum { VMType = VM::VM1 };
27836 static const char* GetVMString() { return "1"; }
27837 };
27838 template <> struct TagToType<0x300c,0x00a0> {
27839 static const char* GetVRString() { return "IS"; }
27840 typedef VRToType<VR::IS>::Type Type;
27841 enum : long long { VRType = VR::IS };
27842 enum { VMType = VM::VM1 };
27843 static const char* GetVMString() { return "1"; }
27844 };
27845 template <> struct TagToType<0x300c,0x00b0> {
27846 static const char* GetVRString() { return "SQ"; }
27847 typedef VRToType<VR::SQ>::Type Type;
27848 enum : long long { VRType = VR::SQ };
27849 enum { VMType = VM::VM1 };
27850 static const char* GetVMString() { return "1"; }
27851 };
27852 template <> struct TagToType<0x300c,0x00c0> {
27853 static const char* GetVRString() { return "IS"; }
27854 typedef VRToType<VR::IS>::Type Type;
27855 enum : long long { VRType = VR::IS };
27856 enum { VMType = VM::VM1 };
27857 static const char* GetVMString() { return "1"; }
27858 };
27859 template <> struct TagToType<0x300c,0x00d0> {
27860 static const char* GetVRString() { return "IS"; }
27861 typedef VRToType<VR::IS>::Type Type;
27862 enum : long long { VRType = VR::IS };
27863 enum { VMType = VM::VM1 };
27864 static const char* GetVMString() { return "1"; }
27865 };
27866 template <> struct TagToType<0x300c,0x00e0> {
27867 static const char* GetVRString() { return "IS"; }
27868 typedef VRToType<VR::IS>::Type Type;
27869 enum : long long { VRType = VR::IS };
27870 enum { VMType = VM::VM1 };
27871 static const char* GetVMString() { return "1"; }
27872 };
27873 template <> struct TagToType<0x300c,0x00f0> {
27874 static const char* GetVRString() { return "IS"; }
27875 typedef VRToType<VR::IS>::Type Type;
27876 enum : long long { VRType = VR::IS };
27877 enum { VMType = VM::VM1 };
27878 static const char* GetVMString() { return "1"; }
27879 };
27880 template <> struct TagToType<0x300c,0x00f2> {
27881 static const char* GetVRString() { return "SQ"; }
27882 typedef VRToType<VR::SQ>::Type Type;
27883 enum : long long { VRType = VR::SQ };
27884 enum { VMType = VM::VM1 };
27885 static const char* GetVMString() { return "1"; }
27886 };
27887 template <> struct TagToType<0x300c,0x00f4> {
27888 static const char* GetVRString() { return "IS"; }
27889 typedef VRToType<VR::IS>::Type Type;
27890 enum : long long { VRType = VR::IS };
27891 enum { VMType = VM::VM1 };
27892 static const char* GetVMString() { return "1"; }
27893 };
27894 template <> struct TagToType<0x300c,0x00f6> {
27895 static const char* GetVRString() { return "IS"; }
27896 typedef VRToType<VR::IS>::Type Type;
27897 enum : long long { VRType = VR::IS };
27898 enum { VMType = VM::VM1 };
27899 static const char* GetVMString() { return "1"; }
27900 };
27901 template <> struct TagToType<0x300c,0x0100> {
27902 static const char* GetVRString() { return "IS"; }
27903 typedef VRToType<VR::IS>::Type Type;
27904 enum : long long { VRType = VR::IS };
27905 enum { VMType = VM::VM1 };
27906 static const char* GetVMString() { return "1"; }
27907 };
27908 template <> struct TagToType<0x300c,0x0102> {
27909 static const char* GetVRString() { return "IS"; }
27910 typedef VRToType<VR::IS>::Type Type;
27911 enum : long long { VRType = VR::IS };
27912 enum { VMType = VM::VM1 };
27913 static const char* GetVMString() { return "1"; }
27914 };
27915 template <> struct TagToType<0x300c,0x0104> {
27916 static const char* GetVRString() { return "IS"; }
27917 typedef VRToType<VR::IS>::Type Type;
27918 enum : long long { VRType = VR::IS };
27919 enum { VMType = VM::VM1 };
27920 static const char* GetVMString() { return "1"; }
27921 };
27922 template <> struct TagToType<0x300c,0x0111> {
27923 static const char* GetVRString() { return "SQ"; }
27924 typedef VRToType<VR::SQ>::Type Type;
27925 enum : long long { VRType = VR::SQ };
27926 enum { VMType = VM::VM1 };
27927 static const char* GetVMString() { return "1"; }
27928 };
27929 template <> struct TagToType<0x300c,0x0112> {
27930 static const char* GetVRString() { return "CS"; }
27931 typedef VRToType<VR::CS>::Type Type;
27932 enum : long long { VRType = VR::CS };
27933 enum { VMType = VM::VM1 };
27934 static const char* GetVMString() { return "1"; }
27935 };
27936 template <> struct TagToType<0x300c,0x0113> {
27937 static const char* GetVRString() { return "LO"; }
27938 typedef VRToType<VR::LO>::Type Type;
27939 enum : long long { VRType = VR::LO };
27940 enum { VMType = VM::VM1 };
27941 static const char* GetVMString() { return "1"; }
27942 };
27943 template <> struct TagToType<0x300e,0x0002> {
27944 static const char* GetVRString() { return "CS"; }
27945 typedef VRToType<VR::CS>::Type Type;
27946 enum : long long { VRType = VR::CS };
27947 enum { VMType = VM::VM1 };
27948 static const char* GetVMString() { return "1"; }
27949 };
27950 template <> struct TagToType<0x300e,0x0004> {
27951 static const char* GetVRString() { return "DA"; }
27952 typedef VRToType<VR::DA>::Type Type;
27953 enum : long long { VRType = VR::DA };
27954 enum { VMType = VM::VM1 };
27955 static const char* GetVMString() { return "1"; }
27956 };
27957 template <> struct TagToType<0x300e,0x0005> {
27958 static const char* GetVRString() { return "TM"; }
27959 typedef VRToType<VR::TM>::Type Type;
27960 enum : long long { VRType = VR::TM };
27961 enum { VMType = VM::VM1 };
27962 static const char* GetVMString() { return "1"; }
27963 };
27964 template <> struct TagToType<0x300e,0x0008> {
27965 static const char* GetVRString() { return "PN"; }
27966 typedef VRToType<VR::PN>::Type Type;
27967 enum : long long { VRType = VR::PN };
27968 enum { VMType = VM::VM1 };
27969 static const char* GetVMString() { return "1"; }
27970 };
27971 template <> struct TagToType<0x4000,0x0010> {
27972 static const char* GetVRString() { return "LT"; }
27973 typedef VRToType<VR::LT>::Type Type;
27974 enum : long long { VRType = VR::LT };
27975 enum { VMType = VM::VM1 };
27976 static const char* GetVMString() { return "1"; }
27977 };
27978 template <> struct TagToType<0x4000,0x4000> {
27979 static const char* GetVRString() { return "LT"; }
27980 typedef VRToType<VR::LT>::Type Type;
27981 enum : long long { VRType = VR::LT };
27982 enum { VMType = VM::VM1 };
27983 static const char* GetVMString() { return "1"; }
27984 };
27985 template <> struct TagToType<0x4008,0x0040> {
27986 static const char* GetVRString() { return "SH"; }
27987 typedef VRToType<VR::SH>::Type Type;
27988 enum : long long { VRType = VR::SH };
27989 enum { VMType = VM::VM1 };
27990 static const char* GetVMString() { return "1"; }
27991 };
27992 template <> struct TagToType<0x4008,0x0042> {
27993 static const char* GetVRString() { return "LO"; }
27994 typedef VRToType<VR::LO>::Type Type;
27995 enum : long long { VRType = VR::LO };
27996 enum { VMType = VM::VM1 };
27997 static const char* GetVMString() { return "1"; }
27998 };
27999 template <> struct TagToType<0x4008,0x0050> {
28000 static const char* GetVRString() { return "SQ"; }
28001 typedef VRToType<VR::SQ>::Type Type;
28002 enum : long long { VRType = VR::SQ };
28003 enum { VMType = VM::VM1 };
28004 static const char* GetVMString() { return "1"; }
28005 };
28006 template <> struct TagToType<0x4008,0x00ff> {
28007 static const char* GetVRString() { return "CS"; }
28008 typedef VRToType<VR::CS>::Type Type;
28009 enum : long long { VRType = VR::CS };
28010 enum { VMType = VM::VM1 };
28011 static const char* GetVMString() { return "1"; }
28012 };
28013 template <> struct TagToType<0x4008,0x0100> {
28014 static const char* GetVRString() { return "DA"; }
28015 typedef VRToType<VR::DA>::Type Type;
28016 enum : long long { VRType = VR::DA };
28017 enum { VMType = VM::VM1 };
28018 static const char* GetVMString() { return "1"; }
28019 };
28020 template <> struct TagToType<0x4008,0x0101> {
28021 static const char* GetVRString() { return "TM"; }
28022 typedef VRToType<VR::TM>::Type Type;
28023 enum : long long { VRType = VR::TM };
28024 enum { VMType = VM::VM1 };
28025 static const char* GetVMString() { return "1"; }
28026 };
28027 template <> struct TagToType<0x4008,0x0102> {
28028 static const char* GetVRString() { return "PN"; }
28029 typedef VRToType<VR::PN>::Type Type;
28030 enum : long long { VRType = VR::PN };
28031 enum { VMType = VM::VM1 };
28032 static const char* GetVMString() { return "1"; }
28033 };
28034 template <> struct TagToType<0x4008,0x0103> {
28035 static const char* GetVRString() { return "LO"; }
28036 typedef VRToType<VR::LO>::Type Type;
28037 enum : long long { VRType = VR::LO };
28038 enum { VMType = VM::VM1 };
28039 static const char* GetVMString() { return "1"; }
28040 };
28041 template <> struct TagToType<0x4008,0x0108> {
28042 static const char* GetVRString() { return "DA"; }
28043 typedef VRToType<VR::DA>::Type Type;
28044 enum : long long { VRType = VR::DA };
28045 enum { VMType = VM::VM1 };
28046 static const char* GetVMString() { return "1"; }
28047 };
28048 template <> struct TagToType<0x4008,0x0109> {
28049 static const char* GetVRString() { return "TM"; }
28050 typedef VRToType<VR::TM>::Type Type;
28051 enum : long long { VRType = VR::TM };
28052 enum { VMType = VM::VM1 };
28053 static const char* GetVMString() { return "1"; }
28054 };
28055 template <> struct TagToType<0x4008,0x010a> {
28056 static const char* GetVRString() { return "PN"; }
28057 typedef VRToType<VR::PN>::Type Type;
28058 enum : long long { VRType = VR::PN };
28059 enum { VMType = VM::VM1 };
28060 static const char* GetVMString() { return "1"; }
28061 };
28062 template <> struct TagToType<0x4008,0x010b> {
28063 static const char* GetVRString() { return "ST"; }
28064 typedef VRToType<VR::ST>::Type Type;
28065 enum : long long { VRType = VR::ST };
28066 enum { VMType = VM::VM1 };
28067 static const char* GetVMString() { return "1"; }
28068 };
28069 template <> struct TagToType<0x4008,0x010c> {
28070 static const char* GetVRString() { return "PN"; }
28071 typedef VRToType<VR::PN>::Type Type;
28072 enum : long long { VRType = VR::PN };
28073 enum { VMType = VM::VM1 };
28074 static const char* GetVMString() { return "1"; }
28075 };
28076 template <> struct TagToType<0x4008,0x0111> {
28077 static const char* GetVRString() { return "SQ"; }
28078 typedef VRToType<VR::SQ>::Type Type;
28079 enum : long long { VRType = VR::SQ };
28080 enum { VMType = VM::VM1 };
28081 static const char* GetVMString() { return "1"; }
28082 };
28083 template <> struct TagToType<0x4008,0x0112> {
28084 static const char* GetVRString() { return "DA"; }
28085 typedef VRToType<VR::DA>::Type Type;
28086 enum : long long { VRType = VR::DA };
28087 enum { VMType = VM::VM1 };
28088 static const char* GetVMString() { return "1"; }
28089 };
28090 template <> struct TagToType<0x4008,0x0113> {
28091 static const char* GetVRString() { return "TM"; }
28092 typedef VRToType<VR::TM>::Type Type;
28093 enum : long long { VRType = VR::TM };
28094 enum { VMType = VM::VM1 };
28095 static const char* GetVMString() { return "1"; }
28096 };
28097 template <> struct TagToType<0x4008,0x0114> {
28098 static const char* GetVRString() { return "PN"; }
28099 typedef VRToType<VR::PN>::Type Type;
28100 enum : long long { VRType = VR::PN };
28101 enum { VMType = VM::VM1 };
28102 static const char* GetVMString() { return "1"; }
28103 };
28104 template <> struct TagToType<0x4008,0x0115> {
28105 static const char* GetVRString() { return "LT"; }
28106 typedef VRToType<VR::LT>::Type Type;
28107 enum : long long { VRType = VR::LT };
28108 enum { VMType = VM::VM1 };
28109 static const char* GetVMString() { return "1"; }
28110 };
28111 template <> struct TagToType<0x4008,0x0117> {
28112 static const char* GetVRString() { return "SQ"; }
28113 typedef VRToType<VR::SQ>::Type Type;
28114 enum : long long { VRType = VR::SQ };
28115 enum { VMType = VM::VM1 };
28116 static const char* GetVMString() { return "1"; }
28117 };
28118 template <> struct TagToType<0x4008,0x0118> {
28119 static const char* GetVRString() { return "SQ"; }
28120 typedef VRToType<VR::SQ>::Type Type;
28121 enum : long long { VRType = VR::SQ };
28122 enum { VMType = VM::VM1 };
28123 static const char* GetVMString() { return "1"; }
28124 };
28125 template <> struct TagToType<0x4008,0x0119> {
28126 static const char* GetVRString() { return "PN"; }
28127 typedef VRToType<VR::PN>::Type Type;
28128 enum : long long { VRType = VR::PN };
28129 enum { VMType = VM::VM1 };
28130 static const char* GetVMString() { return "1"; }
28131 };
28132 template <> struct TagToType<0x4008,0x011a> {
28133 static const char* GetVRString() { return "LO"; }
28134 typedef VRToType<VR::LO>::Type Type;
28135 enum : long long { VRType = VR::LO };
28136 enum { VMType = VM::VM1 };
28137 static const char* GetVMString() { return "1"; }
28138 };
28139 template <> struct TagToType<0x4008,0x0200> {
28140 static const char* GetVRString() { return "SH"; }
28141 typedef VRToType<VR::SH>::Type Type;
28142 enum : long long { VRType = VR::SH };
28143 enum { VMType = VM::VM1 };
28144 static const char* GetVMString() { return "1"; }
28145 };
28146 template <> struct TagToType<0x4008,0x0202> {
28147 static const char* GetVRString() { return "LO"; }
28148 typedef VRToType<VR::LO>::Type Type;
28149 enum : long long { VRType = VR::LO };
28150 enum { VMType = VM::VM1 };
28151 static const char* GetVMString() { return "1"; }
28152 };
28153 template <> struct TagToType<0x4008,0x0210> {
28154 static const char* GetVRString() { return "CS"; }
28155 typedef VRToType<VR::CS>::Type Type;
28156 enum : long long { VRType = VR::CS };
28157 enum { VMType = VM::VM1 };
28158 static const char* GetVMString() { return "1"; }
28159 };
28160 template <> struct TagToType<0x4008,0x0212> {
28161 static const char* GetVRString() { return "CS"; }
28162 typedef VRToType<VR::CS>::Type Type;
28163 enum : long long { VRType = VR::CS };
28164 enum { VMType = VM::VM1 };
28165 static const char* GetVMString() { return "1"; }
28166 };
28167 template <> struct TagToType<0x4008,0x0300> {
28168 static const char* GetVRString() { return "ST"; }
28169 typedef VRToType<VR::ST>::Type Type;
28170 enum : long long { VRType = VR::ST };
28171 enum { VMType = VM::VM1 };
28172 static const char* GetVMString() { return "1"; }
28173 };
28174 template <> struct TagToType<0x4008,0x4000> {
28175 static const char* GetVRString() { return "ST"; }
28176 typedef VRToType<VR::ST>::Type Type;
28177 enum : long long { VRType = VR::ST };
28178 enum { VMType = VM::VM1 };
28179 static const char* GetVMString() { return "1"; }
28180 };
28181 template <> struct TagToType<0x4010,0x0001> {
28182 static const char* GetVRString() { return "CS"; }
28183 typedef VRToType<VR::CS>::Type Type;
28184 enum : long long { VRType = VR::CS };
28185 enum { VMType = VM::VM1 };
28186 static const char* GetVMString() { return "1"; }
28187 };
28188 template <> struct TagToType<0x4010,0x0002> {
28189 static const char* GetVRString() { return "CS"; }
28190 typedef VRToType<VR::CS>::Type Type;
28191 enum : long long { VRType = VR::CS };
28192 enum { VMType = VM::VM1 };
28193 static const char* GetVMString() { return "1"; }
28194 };
28195 template <> struct TagToType<0x4010,0x0004> {
28196 static const char* GetVRString() { return "SQ"; }
28197 typedef VRToType<VR::SQ>::Type Type;
28198 enum : long long { VRType = VR::SQ };
28199 enum { VMType = VM::VM1 };
28200 static const char* GetVMString() { return "1"; }
28201 };
28202 template <> struct TagToType<0x4010,0x1001> {
28203 static const char* GetVRString() { return "SQ"; }
28204 typedef VRToType<VR::SQ>::Type Type;
28205 enum : long long { VRType = VR::SQ };
28206 enum { VMType = VM::VM1 };
28207 static const char* GetVMString() { return "1"; }
28208 };
28209 template <> struct TagToType<0x4010,0x1004> {
28210 static const char* GetVRString() { return "FL"; }
28211 typedef VRToType<VR::FL>::Type Type;
28212 enum : long long { VRType = VR::FL };
28213 enum { VMType = VM::VM3 };
28214 static const char* GetVMString() { return "3"; }
28215 };
28216 template <> struct TagToType<0x4010,0x1005> {
28217 static const char* GetVRString() { return "FL"; }
28218 typedef VRToType<VR::FL>::Type Type;
28219 enum : long long { VRType = VR::FL };
28220 enum { VMType = VM::VM3 };
28221 static const char* GetVMString() { return "3"; }
28222 };
28223 template <> struct TagToType<0x4010,0x1006> {
28224 static const char* GetVRString() { return "OB"; }
28225 typedef VRToType<VR::OB>::Type Type;
28226 enum : long long { VRType = VR::OB };
28227 enum { VMType = VM::VM1 };
28228 static const char* GetVMString() { return "1"; }
28229 };
28230 template <> struct TagToType<0x4010,0x1007> {
28231 static const char* GetVRString() { return "SH"; }
28232 typedef VRToType<VR::SH>::Type Type;
28233 enum : long long { VRType = VR::SH };
28234 enum { VMType = VM::VM1 };
28235 static const char* GetVMString() { return "1"; }
28236 };
28237 template <> struct TagToType<0x4010,0x1008> {
28238 static const char* GetVRString() { return "CS"; }
28239 typedef VRToType<VR::CS>::Type Type;
28240 enum : long long { VRType = VR::CS };
28241 enum { VMType = VM::VM1 };
28242 static const char* GetVMString() { return "1"; }
28243 };
28244 template <> struct TagToType<0x4010,0x1009> {
28245 static const char* GetVRString() { return "CS"; }
28246 typedef VRToType<VR::CS>::Type Type;
28247 enum : long long { VRType = VR::CS };
28248 enum { VMType = VM::VM1 };
28249 static const char* GetVMString() { return "1"; }
28250 };
28251 template <> struct TagToType<0x4010,0x100a> {
28252 static const char* GetVRString() { return "SQ"; }
28253 typedef VRToType<VR::SQ>::Type Type;
28254 enum : long long { VRType = VR::SQ };
28255 enum { VMType = VM::VM1 };
28256 static const char* GetVMString() { return "1"; }
28257 };
28258 template <> struct TagToType<0x4010,0x1010> {
28259 static const char* GetVRString() { return "US"; }
28260 typedef VRToType<VR::US>::Type Type;
28261 enum : long long { VRType = VR::US };
28262 enum { VMType = VM::VM1 };
28263 static const char* GetVMString() { return "1"; }
28264 };
28265 template <> struct TagToType<0x4010,0x1011> {
28266 static const char* GetVRString() { return "SQ"; }
28267 typedef VRToType<VR::SQ>::Type Type;
28268 enum : long long { VRType = VR::SQ };
28269 enum { VMType = VM::VM1 };
28270 static const char* GetVMString() { return "1"; }
28271 };
28272 template <> struct TagToType<0x4010,0x1012> {
28273 static const char* GetVRString() { return "CS"; }
28274 typedef VRToType<VR::CS>::Type Type;
28275 enum : long long { VRType = VR::CS };
28276 enum { VMType = VM::VM1 };
28277 static const char* GetVMString() { return "1"; }
28278 };
28279 template <> struct TagToType<0x4010,0x1013> {
28280 static const char* GetVRString() { return "LT"; }
28281 typedef VRToType<VR::LT>::Type Type;
28282 enum : long long { VRType = VR::LT };
28283 enum { VMType = VM::VM1 };
28284 static const char* GetVMString() { return "1"; }
28285 };
28286 template <> struct TagToType<0x4010,0x1014> {
28287 static const char* GetVRString() { return "CS"; }
28288 typedef VRToType<VR::CS>::Type Type;
28289 enum : long long { VRType = VR::CS };
28290 enum { VMType = VM::VM1 };
28291 static const char* GetVMString() { return "1"; }
28292 };
28293 template <> struct TagToType<0x4010,0x1015> {
28294 static const char* GetVRString() { return "CS"; }
28295 typedef VRToType<VR::CS>::Type Type;
28296 enum : long long { VRType = VR::CS };
28297 enum { VMType = VM::VM1 };
28298 static const char* GetVMString() { return "1"; }
28299 };
28300 template <> struct TagToType<0x4010,0x1016> {
28301 static const char* GetVRString() { return "FL"; }
28302 typedef VRToType<VR::FL>::Type Type;
28303 enum : long long { VRType = VR::FL };
28304 enum { VMType = VM::VM1 };
28305 static const char* GetVMString() { return "1"; }
28306 };
28307 template <> struct TagToType<0x4010,0x1017> {
28308 static const char* GetVRString() { return "FL"; }
28309 typedef VRToType<VR::FL>::Type Type;
28310 enum : long long { VRType = VR::FL };
28311 enum { VMType = VM::VM1 };
28312 static const char* GetVMString() { return "1"; }
28313 };
28314 template <> struct TagToType<0x4010,0x1018> {
28315 static const char* GetVRString() { return "FL"; }
28316 typedef VRToType<VR::FL>::Type Type;
28317 enum : long long { VRType = VR::FL };
28318 enum { VMType = VM::VM1 };
28319 static const char* GetVMString() { return "1"; }
28320 };
28321 template <> struct TagToType<0x4010,0x1019> {
28322 static const char* GetVRString() { return "FL"; }
28323 typedef VRToType<VR::FL>::Type Type;
28324 enum : long long { VRType = VR::FL };
28325 enum { VMType = VM::VM1 };
28326 static const char* GetVMString() { return "1"; }
28327 };
28328 template <> struct TagToType<0x4010,0x101a> {
28329 static const char* GetVRString() { return "SH"; }
28330 typedef VRToType<VR::SH>::Type Type;
28331 enum : long long { VRType = VR::SH };
28332 enum { VMType = VM::VM1 };
28333 static const char* GetVMString() { return "1"; }
28334 };
28335 template <> struct TagToType<0x4010,0x101b> {
28336 static const char* GetVRString() { return "FL"; }
28337 typedef VRToType<VR::FL>::Type Type;
28338 enum : long long { VRType = VR::FL };
28339 enum { VMType = VM::VM3 };
28340 static const char* GetVMString() { return "3"; }
28341 };
28342 template <> struct TagToType<0x4010,0x101c> {
28343 static const char* GetVRString() { return "FL"; }
28344 typedef VRToType<VR::FL>::Type Type;
28345 enum : long long { VRType = VR::FL };
28346 enum { VMType = VM::VM3 };
28347 static const char* GetVMString() { return "3"; }
28348 };
28349 template <> struct TagToType<0x4010,0x101d> {
28350 static const char* GetVRString() { return "FL"; }
28351 typedef VRToType<VR::FL>::Type Type;
28352 enum : long long { VRType = VR::FL };
28353 enum { VMType = VM::VM6_n };
28354 static const char* GetVMString() { return "6-n"; }
28355 };
28356 template <> struct TagToType<0x4010,0x101e> {
28357 static const char* GetVRString() { return "SH"; }
28358 typedef VRToType<VR::SH>::Type Type;
28359 enum : long long { VRType = VR::SH };
28360 enum { VMType = VM::VM1 };
28361 static const char* GetVMString() { return "1"; }
28362 };
28363 template <> struct TagToType<0x4010,0x101f> {
28364 static const char* GetVRString() { return "SH"; }
28365 typedef VRToType<VR::SH>::Type Type;
28366 enum : long long { VRType = VR::SH };
28367 enum { VMType = VM::VM1 };
28368 static const char* GetVMString() { return "1"; }
28369 };
28370 template <> struct TagToType<0x4010,0x1020> {
28371 static const char* GetVRString() { return "CS"; }
28372 typedef VRToType<VR::CS>::Type Type;
28373 enum : long long { VRType = VR::CS };
28374 enum { VMType = VM::VM1 };
28375 static const char* GetVMString() { return "1"; }
28376 };
28377 template <> struct TagToType<0x4010,0x1021> {
28378 static const char* GetVRString() { return "CS"; }
28379 typedef VRToType<VR::CS>::Type Type;
28380 enum : long long { VRType = VR::CS };
28381 enum { VMType = VM::VM1_n };
28382 static const char* GetVMString() { return "1-n"; }
28383 };
28384 template <> struct TagToType<0x4010,0x1023> {
28385 static const char* GetVRString() { return "FL"; }
28386 typedef VRToType<VR::FL>::Type Type;
28387 enum : long long { VRType = VR::FL };
28388 enum { VMType = VM::VM1 };
28389 static const char* GetVMString() { return "1"; }
28390 };
28391 template <> struct TagToType<0x4010,0x1024> {
28392 static const char* GetVRString() { return "CS"; }
28393 typedef VRToType<VR::CS>::Type Type;
28394 enum : long long { VRType = VR::CS };
28395 enum { VMType = VM::VM1 };
28396 static const char* GetVMString() { return "1"; }
28397 };
28398 template <> struct TagToType<0x4010,0x1025> {
28399 static const char* GetVRString() { return "DT"; }
28400 typedef VRToType<VR::DT>::Type Type;
28401 enum : long long { VRType = VR::DT };
28402 enum { VMType = VM::VM1 };
28403 static const char* GetVMString() { return "1"; }
28404 };
28405 template <> struct TagToType<0x4010,0x1026> {
28406 static const char* GetVRString() { return "DT"; }
28407 typedef VRToType<VR::DT>::Type Type;
28408 enum : long long { VRType = VR::DT };
28409 enum { VMType = VM::VM1 };
28410 static const char* GetVMString() { return "1"; }
28411 };
28412 template <> struct TagToType<0x4010,0x1027> {
28413 static const char* GetVRString() { return "CS"; }
28414 typedef VRToType<VR::CS>::Type Type;
28415 enum : long long { VRType = VR::CS };
28416 enum { VMType = VM::VM1 };
28417 static const char* GetVMString() { return "1"; }
28418 };
28419 template <> struct TagToType<0x4010,0x1028> {
28420 static const char* GetVRString() { return "CS"; }
28421 typedef VRToType<VR::CS>::Type Type;
28422 enum : long long { VRType = VR::CS };
28423 enum { VMType = VM::VM1 };
28424 static const char* GetVMString() { return "1"; }
28425 };
28426 template <> struct TagToType<0x4010,0x1029> {
28427 static const char* GetVRString() { return "LO"; }
28428 typedef VRToType<VR::LO>::Type Type;
28429 enum : long long { VRType = VR::LO };
28430 enum { VMType = VM::VM1_n };
28431 static const char* GetVMString() { return "1-n"; }
28432 };
28433 template <> struct TagToType<0x4010,0x102a> {
28434 static const char* GetVRString() { return "SH"; }
28435 typedef VRToType<VR::SH>::Type Type;
28436 enum : long long { VRType = VR::SH };
28437 enum { VMType = VM::VM1 };
28438 static const char* GetVMString() { return "1"; }
28439 };
28440 template <> struct TagToType<0x4010,0x102b> {
28441 static const char* GetVRString() { return "DT"; }
28442 typedef VRToType<VR::DT>::Type Type;
28443 enum : long long { VRType = VR::DT };
28444 enum { VMType = VM::VM1 };
28445 static const char* GetVMString() { return "1"; }
28446 };
28447 template <> struct TagToType<0x4010,0x1031> {
28448 static const char* GetVRString() { return "CS"; }
28449 typedef VRToType<VR::CS>::Type Type;
28450 enum : long long { VRType = VR::CS };
28451 enum { VMType = VM::VM1 };
28452 static const char* GetVMString() { return "1"; }
28453 };
28454 template <> struct TagToType<0x4010,0x1033> {
28455 static const char* GetVRString() { return "US"; }
28456 typedef VRToType<VR::US>::Type Type;
28457 enum : long long { VRType = VR::US };
28458 enum { VMType = VM::VM1 };
28459 static const char* GetVMString() { return "1"; }
28460 };
28461 template <> struct TagToType<0x4010,0x1034> {
28462 static const char* GetVRString() { return "US"; }
28463 typedef VRToType<VR::US>::Type Type;
28464 enum : long long { VRType = VR::US };
28465 enum { VMType = VM::VM1 };
28466 static const char* GetVMString() { return "1"; }
28467 };
28468 template <> struct TagToType<0x4010,0x1037> {
28469 static const char* GetVRString() { return "SQ"; }
28470 typedef VRToType<VR::SQ>::Type Type;
28471 enum : long long { VRType = VR::SQ };
28472 enum { VMType = VM::VM1 };
28473 static const char* GetVMString() { return "1"; }
28474 };
28475 template <> struct TagToType<0x4010,0x1038> {
28476 static const char* GetVRString() { return "SQ"; }
28477 typedef VRToType<VR::SQ>::Type Type;
28478 enum : long long { VRType = VR::SQ };
28479 enum { VMType = VM::VM1 };
28480 static const char* GetVMString() { return "1"; }
28481 };
28482 template <> struct TagToType<0x4010,0x1039> {
28483 static const char* GetVRString() { return "CS"; }
28484 typedef VRToType<VR::CS>::Type Type;
28485 enum : long long { VRType = VR::CS };
28486 enum { VMType = VM::VM1 };
28487 static const char* GetVMString() { return "1"; }
28488 };
28489 template <> struct TagToType<0x4010,0x103a> {
28490 static const char* GetVRString() { return "CS"; }
28491 typedef VRToType<VR::CS>::Type Type;
28492 enum : long long { VRType = VR::CS };
28493 enum { VMType = VM::VM1 };
28494 static const char* GetVMString() { return "1"; }
28495 };
28496 template <> struct TagToType<0x4010,0x1041> {
28497 static const char* GetVRString() { return "DT"; }
28498 typedef VRToType<VR::DT>::Type Type;
28499 enum : long long { VRType = VR::DT };
28500 enum { VMType = VM::VM1 };
28501 static const char* GetVMString() { return "1"; }
28502 };
28503 template <> struct TagToType<0x4010,0x1042> {
28504 static const char* GetVRString() { return "CS"; }
28505 typedef VRToType<VR::CS>::Type Type;
28506 enum : long long { VRType = VR::CS };
28507 enum { VMType = VM::VM1 };
28508 static const char* GetVMString() { return "1"; }
28509 };
28510 template <> struct TagToType<0x4010,0x1043> {
28511 static const char* GetVRString() { return "FL"; }
28512 typedef VRToType<VR::FL>::Type Type;
28513 enum : long long { VRType = VR::FL };
28514 enum { VMType = VM::VM3 };
28515 static const char* GetVMString() { return "3"; }
28516 };
28517 template <> struct TagToType<0x4010,0x1044> {
28518 static const char* GetVRString() { return "CS"; }
28519 typedef VRToType<VR::CS>::Type Type;
28520 enum : long long { VRType = VR::CS };
28521 enum { VMType = VM::VM1 };
28522 static const char* GetVMString() { return "1"; }
28523 };
28524 template <> struct TagToType<0x4010,0x1045> {
28525 static const char* GetVRString() { return "SQ"; }
28526 typedef VRToType<VR::SQ>::Type Type;
28527 enum : long long { VRType = VR::SQ };
28528 enum { VMType = VM::VM1 };
28529 static const char* GetVMString() { return "1"; }
28530 };
28531 template <> struct TagToType<0x4010,0x1046> {
28532 static const char* GetVRString() { return "CS"; }
28533 typedef VRToType<VR::CS>::Type Type;
28534 enum : long long { VRType = VR::CS };
28535 enum { VMType = VM::VM1 };
28536 static const char* GetVMString() { return "1"; }
28537 };
28538 template <> struct TagToType<0x4010,0x1047> {
28539 static const char* GetVRString() { return "SQ"; }
28540 typedef VRToType<VR::SQ>::Type Type;
28541 enum : long long { VRType = VR::SQ };
28542 enum { VMType = VM::VM1 };
28543 static const char* GetVMString() { return "1"; }
28544 };
28545 template <> struct TagToType<0x4010,0x1048> {
28546 static const char* GetVRString() { return "CS"; }
28547 typedef VRToType<VR::CS>::Type Type;
28548 enum : long long { VRType = VR::CS };
28549 enum { VMType = VM::VM1 };
28550 static const char* GetVMString() { return "1"; }
28551 };
28552 template <> struct TagToType<0x4010,0x1051> {
28553 static const char* GetVRString() { return "LO"; }
28554 typedef VRToType<VR::LO>::Type Type;
28555 enum : long long { VRType = VR::LO };
28556 enum { VMType = VM::VM1 };
28557 static const char* GetVMString() { return "1"; }
28558 };
28559 template <> struct TagToType<0x4010,0x1052> {
28560 static const char* GetVRString() { return "SH"; }
28561 typedef VRToType<VR::SH>::Type Type;
28562 enum : long long { VRType = VR::SH };
28563 enum { VMType = VM::VM1 };
28564 static const char* GetVMString() { return "1"; }
28565 };
28566 template <> struct TagToType<0x4010,0x1053> {
28567 static const char* GetVRString() { return "LO"; }
28568 typedef VRToType<VR::LO>::Type Type;
28569 enum : long long { VRType = VR::LO };
28570 enum { VMType = VM::VM1 };
28571 static const char* GetVMString() { return "1"; }
28572 };
28573 template <> struct TagToType<0x4010,0x1054> {
28574 static const char* GetVRString() { return "SH"; }
28575 typedef VRToType<VR::SH>::Type Type;
28576 enum : long long { VRType = VR::SH };
28577 enum { VMType = VM::VM1 };
28578 static const char* GetVMString() { return "1"; }
28579 };
28580 template <> struct TagToType<0x4010,0x1055> {
28581 static const char* GetVRString() { return "SH"; }
28582 typedef VRToType<VR::SH>::Type Type;
28583 enum : long long { VRType = VR::SH };
28584 enum { VMType = VM::VM1 };
28585 static const char* GetVMString() { return "1"; }
28586 };
28587 template <> struct TagToType<0x4010,0x1056> {
28588 static const char* GetVRString() { return "CS"; }
28589 typedef VRToType<VR::CS>::Type Type;
28590 enum : long long { VRType = VR::CS };
28591 enum { VMType = VM::VM1 };
28592 static const char* GetVMString() { return "1"; }
28593 };
28594 template <> struct TagToType<0x4010,0x1058> {
28595 static const char* GetVRString() { return "SH"; }
28596 typedef VRToType<VR::SH>::Type Type;
28597 enum : long long { VRType = VR::SH };
28598 enum { VMType = VM::VM1 };
28599 static const char* GetVMString() { return "1"; }
28600 };
28601 template <> struct TagToType<0x4010,0x1059> {
28602 static const char* GetVRString() { return "CS"; }
28603 typedef VRToType<VR::CS>::Type Type;
28604 enum : long long { VRType = VR::CS };
28605 enum { VMType = VM::VM1 };
28606 static const char* GetVMString() { return "1"; }
28607 };
28608 template <> struct TagToType<0x4010,0x1060> {
28609 static const char* GetVRString() { return "FL"; }
28610 typedef VRToType<VR::FL>::Type Type;
28611 enum : long long { VRType = VR::FL };
28612 enum { VMType = VM::VM3 };
28613 static const char* GetVMString() { return "3"; }
28614 };
28615 template <> struct TagToType<0x4010,0x1061> {
28616 static const char* GetVRString() { return "FL"; }
28617 typedef VRToType<VR::FL>::Type Type;
28618 enum : long long { VRType = VR::FL };
28619 enum { VMType = VM::VM3 };
28620 static const char* GetVMString() { return "3"; }
28621 };
28622 template <> struct TagToType<0x4010,0x1062> {
28623 static const char* GetVRString() { return "FL"; }
28624 typedef VRToType<VR::FL>::Type Type;
28625 enum : long long { VRType = VR::FL };
28626 enum { VMType = VM::VM1 };
28627 static const char* GetVMString() { return "1"; }
28628 };
28629 template <> struct TagToType<0x4010,0x1064> {
28630 static const char* GetVRString() { return "SQ"; }
28631 typedef VRToType<VR::SQ>::Type Type;
28632 enum : long long { VRType = VR::SQ };
28633 enum { VMType = VM::VM1 };
28634 static const char* GetVMString() { return "1"; }
28635 };
28636 template <> struct TagToType<0x4010,0x1067> {
28637 static const char* GetVRString() { return "CS"; }
28638 typedef VRToType<VR::CS>::Type Type;
28639 enum : long long { VRType = VR::CS };
28640 enum { VMType = VM::VM1 };
28641 static const char* GetVMString() { return "1"; }
28642 };
28643 template <> struct TagToType<0x4010,0x1068> {
28644 static const char* GetVRString() { return "LT"; }
28645 typedef VRToType<VR::LT>::Type Type;
28646 enum : long long { VRType = VR::LT };
28647 enum { VMType = VM::VM1 };
28648 static const char* GetVMString() { return "1"; }
28649 };
28650 template <> struct TagToType<0x4010,0x1069> {
28651 static const char* GetVRString() { return "FL"; }
28652 typedef VRToType<VR::FL>::Type Type;
28653 enum : long long { VRType = VR::FL };
28654 enum { VMType = VM::VM1 };
28655 static const char* GetVMString() { return "1"; }
28656 };
28657 template <> struct TagToType<0x4010,0x106c> {
28658 static const char* GetVRString() { return "OB"; }
28659 typedef VRToType<VR::OB>::Type Type;
28660 enum : long long { VRType = VR::OB };
28661 enum { VMType = VM::VM1 };
28662 static const char* GetVMString() { return "1"; }
28663 };
28664 template <> struct TagToType<0x4010,0x106d> {
28665 static const char* GetVRString() { return "CS"; }
28666 typedef VRToType<VR::CS>::Type Type;
28667 enum : long long { VRType = VR::CS };
28668 enum { VMType = VM::VM1 };
28669 static const char* GetVMString() { return "1"; }
28670 };
28671 template <> struct TagToType<0x4010,0x106e> {
28672 static const char* GetVRString() { return "CS"; }
28673 typedef VRToType<VR::CS>::Type Type;
28674 enum : long long { VRType = VR::CS };
28675 enum { VMType = VM::VM1 };
28676 static const char* GetVMString() { return "1"; }
28677 };
28678 template <> struct TagToType<0x4010,0x106f> {
28679 static const char* GetVRString() { return "SQ"; }
28680 typedef VRToType<VR::SQ>::Type Type;
28681 enum : long long { VRType = VR::SQ };
28682 enum { VMType = VM::VM1 };
28683 static const char* GetVMString() { return "1"; }
28684 };
28685 template <> struct TagToType<0x4010,0x1070> {
28686 static const char* GetVRString() { return "CS"; }
28687 typedef VRToType<VR::CS>::Type Type;
28688 enum : long long { VRType = VR::CS };
28689 enum { VMType = VM::VM1 };
28690 static const char* GetVMString() { return "1"; }
28691 };
28692 template <> struct TagToType<0x4010,0x1071> {
28693 static const char* GetVRString() { return "SQ"; }
28694 typedef VRToType<VR::SQ>::Type Type;
28695 enum : long long { VRType = VR::SQ };
28696 enum { VMType = VM::VM1 };
28697 static const char* GetVMString() { return "1"; }
28698 };
28699 template <> struct TagToType<0x4010,0x1072> {
28700 static const char* GetVRString() { return "SQ"; }
28701 typedef VRToType<VR::SQ>::Type Type;
28702 enum : long long { VRType = VR::SQ };
28703 enum { VMType = VM::VM1 };
28704 static const char* GetVMString() { return "1"; }
28705 };
28706 template <> struct TagToType<0x4010,0x1073> {
28707 static const char* GetVRString() { return "FD"; }
28708 typedef VRToType<VR::FD>::Type Type;
28709 enum : long long { VRType = VR::FD };
28710 enum { VMType = VM::VM1 };
28711 static const char* GetVMString() { return "1"; }
28712 };
28713 template <> struct TagToType<0x4010,0x1075> {
28714 static const char* GetVRString() { return "DS"; }
28715 typedef VRToType<VR::DS>::Type Type;
28716 enum : long long { VRType = VR::DS };
28717 enum { VMType = VM::VM1 };
28718 static const char* GetVMString() { return "1"; }
28719 };
28720 template <> struct TagToType<0x4010,0x1076> {
28721 static const char* GetVRString() { return "SQ"; }
28722 typedef VRToType<VR::SQ>::Type Type;
28723 enum : long long { VRType = VR::SQ };
28724 enum { VMType = VM::VM1 };
28725 static const char* GetVMString() { return "1"; }
28726 };
28727 template <> struct TagToType<0x4010,0x1077> {
28728 static const char* GetVRString() { return "SQ"; }
28729 typedef VRToType<VR::SQ>::Type Type;
28730 enum : long long { VRType = VR::SQ };
28731 enum { VMType = VM::VM1 };
28732 static const char* GetVMString() { return "1"; }
28733 };
28734 template <> struct TagToType<0x4010,0x1078> {
28735 static const char* GetVRString() { return "ST"; }
28736 typedef VRToType<VR::ST>::Type Type;
28737 enum : long long { VRType = VR::ST };
28738 enum { VMType = VM::VM1 };
28739 static const char* GetVMString() { return "1"; }
28740 };
28741 template <> struct TagToType<0x4010,0x1079> {
28742 static const char* GetVRString() { return "SQ"; }
28743 typedef VRToType<VR::SQ>::Type Type;
28744 enum : long long { VRType = VR::SQ };
28745 enum { VMType = VM::VM1 };
28746 static const char* GetVMString() { return "1"; }
28747 };
28748 template <> struct TagToType<0x4010,0x107a> {
28749 static const char* GetVRString() { return "FL"; }
28750 typedef VRToType<VR::FL>::Type Type;
28751 enum : long long { VRType = VR::FL };
28752 enum { VMType = VM::VM3 };
28753 static const char* GetVMString() { return "3"; }
28754 };
28755 template <> struct TagToType<0x4010,0x107b> {
28756 static const char* GetVRString() { return "SQ"; }
28757 typedef VRToType<VR::SQ>::Type Type;
28758 enum : long long { VRType = VR::SQ };
28759 enum { VMType = VM::VM1 };
28760 static const char* GetVMString() { return "1"; }
28761 };
28762 template <> struct TagToType<0x4010,0x107c> {
28763 static const char* GetVRString() { return "CS"; }
28764 typedef VRToType<VR::CS>::Type Type;
28765 enum : long long { VRType = VR::CS };
28766 enum { VMType = VM::VM1 };
28767 static const char* GetVMString() { return "1"; }
28768 };
28769 template <> struct TagToType<0x4010,0x107d> {
28770 static const char* GetVRString() { return "SQ"; }
28771 typedef VRToType<VR::SQ>::Type Type;
28772 enum : long long { VRType = VR::SQ };
28773 enum { VMType = VM::VM1 };
28774 static const char* GetVMString() { return "1"; }
28775 };
28776 template <> struct TagToType<0x4010,0x107e> {
28777 static const char* GetVRString() { return "DS"; }
28778 typedef VRToType<VR::DS>::Type Type;
28779 enum : long long { VRType = VR::DS };
28780 enum { VMType = VM::VM6 };
28781 static const char* GetVMString() { return "6"; }
28782 };
28783 template <> struct TagToType<0x4ffe,0x0001> {
28784 static const char* GetVRString() { return "SQ"; }
28785 typedef VRToType<VR::SQ>::Type Type;
28786 enum : long long { VRType = VR::SQ };
28787 enum { VMType = VM::VM1 };
28788 static const char* GetVMString() { return "1"; }
28789 };
28790 template <> struct TagToType<0x5000,0x0005> {
28791 static const char* GetVRString() { return "US"; }
28792 typedef VRToType<VR::US>::Type Type;
28793 enum : long long { VRType = VR::US };
28794 enum { VMType = VM::VM1 };
28795 static const char* GetVMString() { return "1"; }
28796 };
28797 template <> struct TagToType<0x5000,0x0010> {
28798 static const char* GetVRString() { return "US"; }
28799 typedef VRToType<VR::US>::Type Type;
28800 enum : long long { VRType = VR::US };
28801 enum { VMType = VM::VM1 };
28802 static const char* GetVMString() { return "1"; }
28803 };
28804 template <> struct TagToType<0x5000,0x0020> {
28805 static const char* GetVRString() { return "CS"; }
28806 typedef VRToType<VR::CS>::Type Type;
28807 enum : long long { VRType = VR::CS };
28808 enum { VMType = VM::VM1 };
28809 static const char* GetVMString() { return "1"; }
28810 };
28811 template <> struct TagToType<0x5000,0x0022> {
28812 static const char* GetVRString() { return "LO"; }
28813 typedef VRToType<VR::LO>::Type Type;
28814 enum : long long { VRType = VR::LO };
28815 enum { VMType = VM::VM1 };
28816 static const char* GetVMString() { return "1"; }
28817 };
28818 template <> struct TagToType<0x5000,0x0030> {
28819 static const char* GetVRString() { return "SH"; }
28820 typedef VRToType<VR::SH>::Type Type;
28821 enum : long long { VRType = VR::SH };
28822 enum { VMType = VM::VM1_n };
28823 static const char* GetVMString() { return "1-n"; }
28824 };
28825 template <> struct TagToType<0x5000,0x0040> {
28826 static const char* GetVRString() { return "SH"; }
28827 typedef VRToType<VR::SH>::Type Type;
28828 enum : long long { VRType = VR::SH };
28829 enum { VMType = VM::VM1_n };
28830 static const char* GetVMString() { return "1-n"; }
28831 };
28832 template <> struct TagToType<0x5000,0x0103> {
28833 static const char* GetVRString() { return "US"; }
28834 typedef VRToType<VR::US>::Type Type;
28835 enum : long long { VRType = VR::US };
28836 enum { VMType = VM::VM1 };
28837 static const char* GetVMString() { return "1"; }
28838 };
28839 template <> struct TagToType<0x5000,0x0104> {
28840 static const char* GetVRString() { return "US"; }
28841 typedef VRToType<VR::US>::Type Type;
28842 enum : long long { VRType = VR::US };
28843 enum { VMType = VM::VM1_n };
28844 static const char* GetVMString() { return "1-n"; }
28845 };
28846 template <> struct TagToType<0x5000,0x0105> {
28847 static const char* GetVRString() { return "US"; }
28848 typedef VRToType<VR::US>::Type Type;
28849 enum : long long { VRType = VR::US };
28850 enum { VMType = VM::VM1_n };
28851 static const char* GetVMString() { return "1-n"; }
28852 };
28853 template <> struct TagToType<0x5000,0x0106> {
28854 static const char* GetVRString() { return "SH"; }
28855 typedef VRToType<VR::SH>::Type Type;
28856 enum : long long { VRType = VR::SH };
28857 enum { VMType = VM::VM1_n };
28858 static const char* GetVMString() { return "1-n"; }
28859 };
28860 template <> struct TagToType<0x5000,0x0110> {
28861 static const char* GetVRString() { return "US"; }
28862 typedef VRToType<VR::US>::Type Type;
28863 enum : long long { VRType = VR::US };
28864 enum { VMType = VM::VM1_n };
28865 static const char* GetVMString() { return "1-n"; }
28866 };
28867 template <> struct TagToType<0x5000,0x0112> {
28868 static const char* GetVRString() { return "US"; }
28869 typedef VRToType<VR::US>::Type Type;
28870 enum : long long { VRType = VR::US };
28871 enum { VMType = VM::VM1_n };
28872 static const char* GetVMString() { return "1-n"; }
28873 };
28874 template <> struct TagToType<0x5000,0x0114> {
28875 static const char* GetVRString() { return "US"; }
28876 typedef VRToType<VR::US>::Type Type;
28877 enum : long long { VRType = VR::US };
28878 enum { VMType = VM::VM1_n };
28879 static const char* GetVMString() { return "1-n"; }
28880 };
28881 template <> struct TagToType<0x5000,0x1001> {
28882 static const char* GetVRString() { return "CS"; }
28883 typedef VRToType<VR::CS>::Type Type;
28884 enum : long long { VRType = VR::CS };
28885 enum { VMType = VM::VM1 };
28886 static const char* GetVMString() { return "1"; }
28887 };
28888 template <> struct TagToType<0x5000,0x2000> {
28889 static const char* GetVRString() { return "US"; }
28890 typedef VRToType<VR::US>::Type Type;
28891 enum : long long { VRType = VR::US };
28892 enum { VMType = VM::VM1 };
28893 static const char* GetVMString() { return "1"; }
28894 };
28895 template <> struct TagToType<0x5000,0x2002> {
28896 static const char* GetVRString() { return "US"; }
28897 typedef VRToType<VR::US>::Type Type;
28898 enum : long long { VRType = VR::US };
28899 enum { VMType = VM::VM1 };
28900 static const char* GetVMString() { return "1"; }
28901 };
28902 template <> struct TagToType<0x5000,0x2004> {
28903 static const char* GetVRString() { return "US"; }
28904 typedef VRToType<VR::US>::Type Type;
28905 enum : long long { VRType = VR::US };
28906 enum { VMType = VM::VM1 };
28907 static const char* GetVMString() { return "1"; }
28908 };
28909 template <> struct TagToType<0x5000,0x2006> {
28910 static const char* GetVRString() { return "UL"; }
28911 typedef VRToType<VR::UL>::Type Type;
28912 enum : long long { VRType = VR::UL };
28913 enum { VMType = VM::VM1 };
28914 static const char* GetVMString() { return "1"; }
28915 };
28916 template <> struct TagToType<0x5000,0x2008> {
28917 static const char* GetVRString() { return "UL"; }
28918 typedef VRToType<VR::UL>::Type Type;
28919 enum : long long { VRType = VR::UL };
28920 enum { VMType = VM::VM1 };
28921 static const char* GetVMString() { return "1"; }
28922 };
28923 template <> struct TagToType<0x5000,0x200a> {
28924 static const char* GetVRString() { return "UL"; }
28925 typedef VRToType<VR::UL>::Type Type;
28926 enum : long long { VRType = VR::UL };
28927 enum { VMType = VM::VM1 };
28928 static const char* GetVMString() { return "1"; }
28929 };
28930 template <> struct TagToType<0x5000,0x200e> {
28931 static const char* GetVRString() { return "LT"; }
28932 typedef VRToType<VR::LT>::Type Type;
28933 enum : long long { VRType = VR::LT };
28934 enum { VMType = VM::VM1 };
28935 static const char* GetVMString() { return "1"; }
28936 };
28937 template <> struct TagToType<0x5000,0x2500> {
28938 static const char* GetVRString() { return "LO"; }
28939 typedef VRToType<VR::LO>::Type Type;
28940 enum : long long { VRType = VR::LO };
28941 enum { VMType = VM::VM1 };
28942 static const char* GetVMString() { return "1"; }
28943 };
28944 template <> struct TagToType<0x5000,0x2600> {
28945 static const char* GetVRString() { return "SQ"; }
28946 typedef VRToType<VR::SQ>::Type Type;
28947 enum : long long { VRType = VR::SQ };
28948 enum { VMType = VM::VM1 };
28949 static const char* GetVMString() { return "1"; }
28950 };
28951 template <> struct TagToType<0x5000,0x2610> {
28952 static const char* GetVRString() { return "US"; }
28953 typedef VRToType<VR::US>::Type Type;
28954 enum : long long { VRType = VR::US };
28955 enum { VMType = VM::VM1 };
28956 static const char* GetVMString() { return "1"; }
28957 };
28958 template <> struct TagToType<0x5200,0x9229> {
28959 static const char* GetVRString() { return "SQ"; }
28960 typedef VRToType<VR::SQ>::Type Type;
28961 enum : long long { VRType = VR::SQ };
28962 enum { VMType = VM::VM1 };
28963 static const char* GetVMString() { return "1"; }
28964 };
28965 template <> struct TagToType<0x5200,0x9230> {
28966 static const char* GetVRString() { return "SQ"; }
28967 typedef VRToType<VR::SQ>::Type Type;
28968 enum : long long { VRType = VR::SQ };
28969 enum { VMType = VM::VM1 };
28970 static const char* GetVMString() { return "1"; }
28971 };
28972 template <> struct TagToType<0x5400,0x0100> {
28973 static const char* GetVRString() { return "SQ"; }
28974 typedef VRToType<VR::SQ>::Type Type;
28975 enum : long long { VRType = VR::SQ };
28976 enum { VMType = VM::VM1 };
28977 static const char* GetVMString() { return "1"; }
28978 };
28979 template <> struct TagToType<0x5400,0x1004> {
28980 static const char* GetVRString() { return "US"; }
28981 typedef VRToType<VR::US>::Type Type;
28982 enum : long long { VRType = VR::US };
28983 enum { VMType = VM::VM1 };
28984 static const char* GetVMString() { return "1"; }
28985 };
28986 template <> struct TagToType<0x5400,0x1006> {
28987 static const char* GetVRString() { return "CS"; }
28988 typedef VRToType<VR::CS>::Type Type;
28989 enum : long long { VRType = VR::CS };
28990 enum { VMType = VM::VM1 };
28991 static const char* GetVMString() { return "1"; }
28992 };
28993 template <> struct TagToType<0x5600,0x0010> {
28994 static const char* GetVRString() { return "OF"; }
28995 typedef VRToType<VR::OF>::Type Type;
28996 enum : long long { VRType = VR::OF };
28997 enum { VMType = VM::VM1 };
28998 static const char* GetVMString() { return "1"; }
28999 };
29000 template <> struct TagToType<0x5600,0x0020> {
29001 static const char* GetVRString() { return "OF"; }
29002 typedef VRToType<VR::OF>::Type Type;
29003 enum : long long { VRType = VR::OF };
29004 enum { VMType = VM::VM1 };
29005 static const char* GetVMString() { return "1"; }
29006 };
29007 template <> struct TagToType<0x6000,0x0010> {
29008 static const char* GetVRString() { return "US"; }
29009 typedef VRToType<VR::US>::Type Type;
29010 enum : long long { VRType = VR::US };
29011 enum { VMType = VM::VM1 };
29012 static const char* GetVMString() { return "1"; }
29013 };
29014 template <> struct TagToType<0x6000,0x0011> {
29015 static const char* GetVRString() { return "US"; }
29016 typedef VRToType<VR::US>::Type Type;
29017 enum : long long { VRType = VR::US };
29018 enum { VMType = VM::VM1 };
29019 static const char* GetVMString() { return "1"; }
29020 };
29021 template <> struct TagToType<0x6000,0x0012> {
29022 static const char* GetVRString() { return "US"; }
29023 typedef VRToType<VR::US>::Type Type;
29024 enum : long long { VRType = VR::US };
29025 enum { VMType = VM::VM1 };
29026 static const char* GetVMString() { return "1"; }
29027 };
29028 template <> struct TagToType<0x6000,0x0015> {
29029 static const char* GetVRString() { return "IS"; }
29030 typedef VRToType<VR::IS>::Type Type;
29031 enum : long long { VRType = VR::IS };
29032 enum { VMType = VM::VM1 };
29033 static const char* GetVMString() { return "1"; }
29034 };
29035 template <> struct TagToType<0x6000,0x0022> {
29036 static const char* GetVRString() { return "LO"; }
29037 typedef VRToType<VR::LO>::Type Type;
29038 enum : long long { VRType = VR::LO };
29039 enum { VMType = VM::VM1 };
29040 static const char* GetVMString() { return "1"; }
29041 };
29042 template <> struct TagToType<0x6000,0x0040> {
29043 static const char* GetVRString() { return "CS"; }
29044 typedef VRToType<VR::CS>::Type Type;
29045 enum : long long { VRType = VR::CS };
29046 enum { VMType = VM::VM1 };
29047 static const char* GetVMString() { return "1"; }
29048 };
29049 template <> struct TagToType<0x6000,0x0045> {
29050 static const char* GetVRString() { return "LO"; }
29051 typedef VRToType<VR::LO>::Type Type;
29052 enum : long long { VRType = VR::LO };
29053 enum { VMType = VM::VM1 };
29054 static const char* GetVMString() { return "1"; }
29055 };
29056 template <> struct TagToType<0x6000,0x0050> {
29057 static const char* GetVRString() { return "SS"; }
29058 typedef VRToType<VR::SS>::Type Type;
29059 enum : long long { VRType = VR::SS };
29060 enum { VMType = VM::VM2 };
29061 static const char* GetVMString() { return "2"; }
29062 };
29063 template <> struct TagToType<0x6000,0x0051> {
29064 static const char* GetVRString() { return "US"; }
29065 typedef VRToType<VR::US>::Type Type;
29066 enum : long long { VRType = VR::US };
29067 enum { VMType = VM::VM1 };
29068 static const char* GetVMString() { return "1"; }
29069 };
29070 template <> struct TagToType<0x6000,0x0052> {
29071 static const char* GetVRString() { return "US"; }
29072 typedef VRToType<VR::US>::Type Type;
29073 enum : long long { VRType = VR::US };
29074 enum { VMType = VM::VM1 };
29075 static const char* GetVMString() { return "1"; }
29076 };
29077 template <> struct TagToType<0x6000,0x0060> {
29078 static const char* GetVRString() { return "CS"; }
29079 typedef VRToType<VR::CS>::Type Type;
29080 enum : long long { VRType = VR::CS };
29081 enum { VMType = VM::VM1 };
29082 static const char* GetVMString() { return "1"; }
29083 };
29084 template <> struct TagToType<0x6000,0x0061> {
29085 static const char* GetVRString() { return "SH"; }
29086 typedef VRToType<VR::SH>::Type Type;
29087 enum : long long { VRType = VR::SH };
29088 enum { VMType = VM::VM1 };
29089 static const char* GetVMString() { return "1"; }
29090 };
29091 template <> struct TagToType<0x6000,0x0062> {
29092 static const char* GetVRString() { return "SH"; }
29093 typedef VRToType<VR::SH>::Type Type;
29094 enum : long long { VRType = VR::SH };
29095 enum { VMType = VM::VM1 };
29096 static const char* GetVMString() { return "1"; }
29097 };
29098 template <> struct TagToType<0x6000,0x0063> {
29099 static const char* GetVRString() { return "CS"; }
29100 typedef VRToType<VR::CS>::Type Type;
29101 enum : long long { VRType = VR::CS };
29102 enum { VMType = VM::VM1 };
29103 static const char* GetVMString() { return "1"; }
29104 };
29105 template <> struct TagToType<0x6000,0x0066> {
29106 static const char* GetVRString() { return "AT"; }
29107 typedef VRToType<VR::AT>::Type Type;
29108 enum : long long { VRType = VR::AT };
29109 enum { VMType = VM::VM1_n };
29110 static const char* GetVMString() { return "1-n"; }
29111 };
29112 template <> struct TagToType<0x6000,0x0068> {
29113 static const char* GetVRString() { return "US"; }
29114 typedef VRToType<VR::US>::Type Type;
29115 enum : long long { VRType = VR::US };
29116 enum { VMType = VM::VM1 };
29117 static const char* GetVMString() { return "1"; }
29118 };
29119 template <> struct TagToType<0x6000,0x0069> {
29120 static const char* GetVRString() { return "US"; }
29121 typedef VRToType<VR::US>::Type Type;
29122 enum : long long { VRType = VR::US };
29123 enum { VMType = VM::VM1 };
29124 static const char* GetVMString() { return "1"; }
29125 };
29126 template <> struct TagToType<0x6000,0x0100> {
29127 static const char* GetVRString() { return "US"; }
29128 typedef VRToType<VR::US>::Type Type;
29129 enum : long long { VRType = VR::US };
29130 enum { VMType = VM::VM1 };
29131 static const char* GetVMString() { return "1"; }
29132 };
29133 template <> struct TagToType<0x6000,0x0102> {
29134 static const char* GetVRString() { return "US"; }
29135 typedef VRToType<VR::US>::Type Type;
29136 enum : long long { VRType = VR::US };
29137 enum { VMType = VM::VM1 };
29138 static const char* GetVMString() { return "1"; }
29139 };
29140 template <> struct TagToType<0x6000,0x0110> {
29141 static const char* GetVRString() { return "CS"; }
29142 typedef VRToType<VR::CS>::Type Type;
29143 enum : long long { VRType = VR::CS };
29144 enum { VMType = VM::VM1 };
29145 static const char* GetVMString() { return "1"; }
29146 };
29147 template <> struct TagToType<0x6000,0x0200> {
29148 static const char* GetVRString() { return "US"; }
29149 typedef VRToType<VR::US>::Type Type;
29150 enum : long long { VRType = VR::US };
29151 enum { VMType = VM::VM1 };
29152 static const char* GetVMString() { return "1"; }
29153 };
29154 template <> struct TagToType<0x6000,0x0800> {
29155 static const char* GetVRString() { return "CS"; }
29156 typedef VRToType<VR::CS>::Type Type;
29157 enum : long long { VRType = VR::CS };
29158 enum { VMType = VM::VM1_n };
29159 static const char* GetVMString() { return "1-n"; }
29160 };
29161 template <> struct TagToType<0x6000,0x0802> {
29162 static const char* GetVRString() { return "US"; }
29163 typedef VRToType<VR::US>::Type Type;
29164 enum : long long { VRType = VR::US };
29165 enum { VMType = VM::VM1 };
29166 static const char* GetVMString() { return "1"; }
29167 };
29168 template <> struct TagToType<0x6000,0x0803> {
29169 static const char* GetVRString() { return "AT"; }
29170 typedef VRToType<VR::AT>::Type Type;
29171 enum : long long { VRType = VR::AT };
29172 enum { VMType = VM::VM1_n };
29173 static const char* GetVMString() { return "1-n"; }
29174 };
29175 template <> struct TagToType<0x6000,0x0804> {
29176 static const char* GetVRString() { return "US"; }
29177 typedef VRToType<VR::US>::Type Type;
29178 enum : long long { VRType = VR::US };
29179 enum { VMType = VM::VM1 };
29180 static const char* GetVMString() { return "1"; }
29181 };
29182 template <> struct TagToType<0x6000,0x1001> {
29183 static const char* GetVRString() { return "CS"; }
29184 typedef VRToType<VR::CS>::Type Type;
29185 enum : long long { VRType = VR::CS };
29186 enum { VMType = VM::VM1 };
29187 static const char* GetVMString() { return "1"; }
29188 };
29189 template <> struct TagToType<0x6000,0x1100> {
29190 static const char* GetVRString() { return "US"; }
29191 typedef VRToType<VR::US>::Type Type;
29192 enum : long long { VRType = VR::US };
29193 enum { VMType = VM::VM1 };
29194 static const char* GetVMString() { return "1"; }
29195 };
29196 template <> struct TagToType<0x6000,0x1101> {
29197 static const char* GetVRString() { return "US"; }
29198 typedef VRToType<VR::US>::Type Type;
29199 enum : long long { VRType = VR::US };
29200 enum { VMType = VM::VM1 };
29201 static const char* GetVMString() { return "1"; }
29202 };
29203 template <> struct TagToType<0x6000,0x1102> {
29204 static const char* GetVRString() { return "US"; }
29205 typedef VRToType<VR::US>::Type Type;
29206 enum : long long { VRType = VR::US };
29207 enum { VMType = VM::VM1 };
29208 static const char* GetVMString() { return "1"; }
29209 };
29210 template <> struct TagToType<0x6000,0x1103> {
29211 static const char* GetVRString() { return "US"; }
29212 typedef VRToType<VR::US>::Type Type;
29213 enum : long long { VRType = VR::US };
29214 enum { VMType = VM::VM1 };
29215 static const char* GetVMString() { return "1"; }
29216 };
29217 template <> struct TagToType<0x6000,0x1200> {
29218 static const char* GetVRString() { return "US"; }
29219 typedef VRToType<VR::US>::Type Type;
29220 enum : long long { VRType = VR::US };
29221 enum { VMType = VM::VM1_n };
29222 static const char* GetVMString() { return "1-n"; }
29223 };
29224 template <> struct TagToType<0x6000,0x1201> {
29225 static const char* GetVRString() { return "US"; }
29226 typedef VRToType<VR::US>::Type Type;
29227 enum : long long { VRType = VR::US };
29228 enum { VMType = VM::VM1_n };
29229 static const char* GetVMString() { return "1-n"; }
29230 };
29231 template <> struct TagToType<0x6000,0x1202> {
29232 static const char* GetVRString() { return "US"; }
29233 typedef VRToType<VR::US>::Type Type;
29234 enum : long long { VRType = VR::US };
29235 enum { VMType = VM::VM1_n };
29236 static const char* GetVMString() { return "1-n"; }
29237 };
29238 template <> struct TagToType<0x6000,0x1203> {
29239 static const char* GetVRString() { return "US"; }
29240 typedef VRToType<VR::US>::Type Type;
29241 enum : long long { VRType = VR::US };
29242 enum { VMType = VM::VM1_n };
29243 static const char* GetVMString() { return "1-n"; }
29244 };
29245 template <> struct TagToType<0x6000,0x1301> {
29246 static const char* GetVRString() { return "IS"; }
29247 typedef VRToType<VR::IS>::Type Type;
29248 enum : long long { VRType = VR::IS };
29249 enum { VMType = VM::VM1 };
29250 static const char* GetVMString() { return "1"; }
29251 };
29252 template <> struct TagToType<0x6000,0x1302> {
29253 static const char* GetVRString() { return "DS"; }
29254 typedef VRToType<VR::DS>::Type Type;
29255 enum : long long { VRType = VR::DS };
29256 enum { VMType = VM::VM1 };
29257 static const char* GetVMString() { return "1"; }
29258 };
29259 template <> struct TagToType<0x6000,0x1303> {
29260 static const char* GetVRString() { return "DS"; }
29261 typedef VRToType<VR::DS>::Type Type;
29262 enum : long long { VRType = VR::DS };
29263 enum { VMType = VM::VM1 };
29264 static const char* GetVMString() { return "1"; }
29265 };
29266 template <> struct TagToType<0x6000,0x1500> {
29267 static const char* GetVRString() { return "LO"; }
29268 typedef VRToType<VR::LO>::Type Type;
29269 enum : long long { VRType = VR::LO };
29270 enum { VMType = VM::VM1 };
29271 static const char* GetVMString() { return "1"; }
29272 };
29273 template <> struct TagToType<0x6000,0x4000> {
29274 static const char* GetVRString() { return "LT"; }
29275 typedef VRToType<VR::LT>::Type Type;
29276 enum : long long { VRType = VR::LT };
29277 enum { VMType = VM::VM1 };
29278 static const char* GetVMString() { return "1"; }
29279 };
29280 template <> struct TagToType<0x7fe0,0x0008> {
29281 static const char* GetVRString() { return "OF"; }
29282 typedef VRToType<VR::OF>::Type Type;
29283 enum : long long { VRType = VR::OF };
29284 enum { VMType = VM::VM1 };
29285 static const char* GetVMString() { return "1"; }
29286 };
29287 template <> struct TagToType<0x7fe0,0x0009> {
29288 static const char* GetVRString() { return "OD"; }
29289 typedef VRToType<VR::OD>::Type Type;
29290 enum : long long { VRType = VR::OD };
29291 enum { VMType = VM::VM1 };
29292 static const char* GetVMString() { return "1"; }
29293 };
29294 template <> struct TagToType<0x7fe0,0x0020> {
29295 static const char* GetVRString() { return "OW"; }
29296 typedef VRToType<VR::OW>::Type Type;
29297 enum : long long { VRType = VR::OW };
29298 enum { VMType = VM::VM1 };
29299 static const char* GetVMString() { return "1"; }
29300 };
29301 template <> struct TagToType<0x7fe0,0x0030> {
29302 static const char* GetVRString() { return "OW"; }
29303 typedef VRToType<VR::OW>::Type Type;
29304 enum : long long { VRType = VR::OW };
29305 enum { VMType = VM::VM1 };
29306 static const char* GetVMString() { return "1"; }
29307 };
29308 template <> struct TagToType<0x7fe0,0x0040> {
29309 static const char* GetVRString() { return "OW"; }
29310 typedef VRToType<VR::OW>::Type Type;
29311 enum : long long { VRType = VR::OW };
29312 enum { VMType = VM::VM1 };
29313 static const char* GetVMString() { return "1"; }
29314 };
29315 template <> struct TagToType<0x7f00,0x0011> {
29316 static const char* GetVRString() { return "US"; }
29317 typedef VRToType<VR::US>::Type Type;
29318 enum : long long { VRType = VR::US };
29319 enum { VMType = VM::VM1 };
29320 static const char* GetVMString() { return "1"; }
29321 };
29322 template <> struct TagToType<0x7f00,0x0020> {
29323 static const char* GetVRString() { return "OW"; }
29324 typedef VRToType<VR::OW>::Type Type;
29325 enum : long long { VRType = VR::OW };
29326 enum { VMType = VM::VM1 };
29327 static const char* GetVMString() { return "1"; }
29328 };
29329 template <> struct TagToType<0x7f00,0x0030> {
29330 static const char* GetVRString() { return "OW"; }
29331 typedef VRToType<VR::OW>::Type Type;
29332 enum : long long { VRType = VR::OW };
29333 enum { VMType = VM::VM1 };
29334 static const char* GetVMString() { return "1"; }
29335 };
29336 template <> struct TagToType<0x7f00,0x0040> {
29337 static const char* GetVRString() { return "OW"; }
29338 typedef VRToType<VR::OW>::Type Type;
29339 enum : long long { VRType = VR::OW };
29340 enum { VMType = VM::VM1 };
29341 static const char* GetVMString() { return "1"; }
29342 };
29343 template <> struct TagToType<0xfffa,0xfffa> {
29344 static const char* GetVRString() { return "SQ"; }
29345 typedef VRToType<VR::SQ>::Type Type;
29346 enum : long long { VRType = VR::SQ };
29347 enum { VMType = VM::VM1 };
29348 static const char* GetVMString() { return "1"; }
29349 };
29350 template <> struct TagToType<0xfffc,0xfffc> {
29351 static const char* GetVRString() { return "OB"; }
29352 typedef VRToType<VR::OB>::Type Type;
29353 enum : long long { VRType = VR::OB };
29354 enum { VMType = VM::VM1 };
29355 static const char* GetVMString() { return "1"; }
29356 };
29357 
29358 } // end namespace gdcm
29359 #endif // GDCMTAGTOTYPE_H
29360