Logo Search packages:      
Sourcecode: gdcm version File versions  Download package

gdcmTagToType.h

// GENERATED FILE DO NOT EDIT
// $ xsltproc TagToType.xsl DICOMV3.xml > gdcmTagToType.h

/*=========================================================================

  Program: GDCM (Grassroots DICOM). A DICOM library
  Module:  $URL: https://gdcm.svn.sourceforge.net/svnroot/gdcm/trunk/Source/DataDictionary/TagToType.xsl $

  Copyright (c) 2006-2010 Mathieu Malaterre
  All rights reserved.
  See Copyright.txt or http://gdcm.sourceforge.net/Copyright.html for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/

#ifndef GDCMTAGTOTYPE_H
#define GDCMTAGTOTYPE_H

#include "gdcmVR.h"
#include "gdcmVM.h"
#include "gdcmStaticAssert.h"

namespace gdcm {
// default template: the compiler should only pick it up when the element is private:
00029 template <uint16_t group,uint16_t element> struct TagToType {
//GDCM_STATIC_ASSERT( group % 2 );
enum { VRType = VR::VRALL };
enum { VMType = VM::VM1_n };
};
// template for group length:
00035 template <uint16_t group> struct TagToType<group,0x0000> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00042 template <> struct TagToType<0x0000,0x0000> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00049 template <> struct TagToType<0x0000,0x0001> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00056 template <> struct TagToType<0x0000,0x0002> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00063 template <> struct TagToType<0x0000,0x0003> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00070 template <> struct TagToType<0x0000,0x0010> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00077 template <> struct TagToType<0x0000,0x0100> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00084 template <> struct TagToType<0x0000,0x0110> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00091 template <> struct TagToType<0x0000,0x0120> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00098 template <> struct TagToType<0x0000,0x0200> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
enum { VRType = VR::AE };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00105 template <> struct TagToType<0x0000,0x0300> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
enum { VRType = VR::AE };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00112 template <> struct TagToType<0x0000,0x0400> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
enum { VRType = VR::AE };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00119 template <> struct TagToType<0x0000,0x0600> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
enum { VRType = VR::AE };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00126 template <> struct TagToType<0x0000,0x0700> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00133 template <> struct TagToType<0x0000,0x0800> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00140 template <> struct TagToType<0x0000,0x0850> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00147 template <> struct TagToType<0x0000,0x0860> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00154 template <> struct TagToType<0x0000,0x0900> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00161 template <> struct TagToType<0x0000,0x0901> {
static const char* GetVRString() { return "AT"; }
typedef VRToType<VR::AT>::Type Type;
enum { VRType = VR::AT };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
00168 template <> struct TagToType<0x0000,0x0902> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00175 template <> struct TagToType<0x0000,0x0903> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00182 template <> struct TagToType<0x0000,0x1000> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00189 template <> struct TagToType<0x0000,0x1001> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00196 template <> struct TagToType<0x0000,0x1002> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00203 template <> struct TagToType<0x0000,0x1005> {
static const char* GetVRString() { return "AT"; }
typedef VRToType<VR::AT>::Type Type;
enum { VRType = VR::AT };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
00210 template <> struct TagToType<0x0000,0x1008> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00217 template <> struct TagToType<0x0000,0x1020> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00224 template <> struct TagToType<0x0000,0x1021> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00231 template <> struct TagToType<0x0000,0x1022> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00238 template <> struct TagToType<0x0000,0x1023> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00245 template <> struct TagToType<0x0000,0x1030> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
enum { VRType = VR::AE };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00252 template <> struct TagToType<0x0000,0x1031> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00259 template <> struct TagToType<0x0000,0x4000> {
static const char* GetVRString() { return "AT"; }
typedef VRToType<VR::AT>::Type Type;
enum { VRType = VR::AT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00266 template <> struct TagToType<0x0000,0x4010> {
static const char* GetVRString() { return "AT"; }
typedef VRToType<VR::AT>::Type Type;
enum { VRType = VR::AT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00273 template <> struct TagToType<0x0000,0x5010> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00280 template <> struct TagToType<0x0000,0x5020> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00287 template <> struct TagToType<0x0000,0x5110> {
static const char* GetVRString() { return "AT"; }
typedef VRToType<VR::AT>::Type Type;
enum { VRType = VR::AT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00294 template <> struct TagToType<0x0000,0x5120> {
static const char* GetVRString() { return "AT"; }
typedef VRToType<VR::AT>::Type Type;
enum { VRType = VR::AT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00301 template <> struct TagToType<0x0000,0x5130> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00308 template <> struct TagToType<0x0000,0x5140> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00315 template <> struct TagToType<0x0000,0x5150> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00322 template <> struct TagToType<0x0000,0x5160> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00329 template <> struct TagToType<0x0000,0x5170> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00336 template <> struct TagToType<0x0000,0x5180> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00343 template <> struct TagToType<0x0000,0x5190> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00350 template <> struct TagToType<0x0000,0x51a0> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00357 template <> struct TagToType<0x0000,0x51b0> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
00364 template <> struct TagToType<0x0002,0x0000> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00371 template <> struct TagToType<0x0002,0x0001> {
static const char* GetVRString() { return "OB"; }
typedef VRToType<VR::OB>::Type Type;
enum { VRType = VR::OB };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00378 template <> struct TagToType<0x0002,0x0002> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00385 template <> struct TagToType<0x0002,0x0003> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00392 template <> struct TagToType<0x0002,0x0010> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00399 template <> struct TagToType<0x0002,0x0012> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00406 template <> struct TagToType<0x0002,0x0013> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00413 template <> struct TagToType<0x0002,0x0016> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
enum { VRType = VR::AE };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00420 template <> struct TagToType<0x0002,0x0100> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00427 template <> struct TagToType<0x0002,0x0102> {
static const char* GetVRString() { return "OB"; }
typedef VRToType<VR::OB>::Type Type;
enum { VRType = VR::OB };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00434 template <> struct TagToType<0x0004,0x1130> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00441 template <> struct TagToType<0x0004,0x1141> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_8 };
static const char* GetVMString() { return "1-8"; }
};
00448 template <> struct TagToType<0x0004,0x1142> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00455 template <> struct TagToType<0x0004,0x1200> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00462 template <> struct TagToType<0x0004,0x1202> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00469 template <> struct TagToType<0x0004,0x1212> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00476 template <> struct TagToType<0x0004,0x1220> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00483 template <> struct TagToType<0x0004,0x1400> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00490 template <> struct TagToType<0x0004,0x1410> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00497 template <> struct TagToType<0x0004,0x1420> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00504 template <> struct TagToType<0x0004,0x1430> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00511 template <> struct TagToType<0x0004,0x1432> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00518 template <> struct TagToType<0x0004,0x1500> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_8 };
static const char* GetVMString() { return "1-8"; }
};
00525 template <> struct TagToType<0x0004,0x1504> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00532 template <> struct TagToType<0x0004,0x1510> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00539 template <> struct TagToType<0x0004,0x1511> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00546 template <> struct TagToType<0x0004,0x1512> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00553 template <> struct TagToType<0x0004,0x151a> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
00560 template <> struct TagToType<0x0004,0x1600> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00567 template <> struct TagToType<0x0008,0x0001> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00574 template <> struct TagToType<0x0008,0x0005> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
00581 template <> struct TagToType<0x0008,0x0006> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00588 template <> struct TagToType<0x0008,0x0008> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM2_n };
static const char* GetVMString() { return "2-n"; }
};
00595 template <> struct TagToType<0x0008,0x0010> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00602 template <> struct TagToType<0x0008,0x0012> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
enum { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00609 template <> struct TagToType<0x0008,0x0013> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00616 template <> struct TagToType<0x0008,0x0014> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00623 template <> struct TagToType<0x0008,0x0016> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00630 template <> struct TagToType<0x0008,0x0018> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00637 template <> struct TagToType<0x0008,0x001a> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
00644 template <> struct TagToType<0x0008,0x001b> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00651 template <> struct TagToType<0x0008,0x0020> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
enum { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00658 template <> struct TagToType<0x0008,0x0021> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
enum { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00665 template <> struct TagToType<0x0008,0x0022> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
enum { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00672 template <> struct TagToType<0x0008,0x0023> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
enum { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00679 template <> struct TagToType<0x0008,0x0024> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
enum { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00686 template <> struct TagToType<0x0008,0x0025> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
enum { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00693 template <> struct TagToType<0x0008,0x002a> {
static const char* GetVRString() { return "DT"; }
typedef VRToType<VR::DT>::Type Type;
enum { VRType = VR::DT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00700 template <> struct TagToType<0x0008,0x0030> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00707 template <> struct TagToType<0x0008,0x0031> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00714 template <> struct TagToType<0x0008,0x0032> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00721 template <> struct TagToType<0x0008,0x0033> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00728 template <> struct TagToType<0x0008,0x0034> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00735 template <> struct TagToType<0x0008,0x0035> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00742 template <> struct TagToType<0x0008,0x0040> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00749 template <> struct TagToType<0x0008,0x0041> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00756 template <> struct TagToType<0x0008,0x0042> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00763 template <> struct TagToType<0x0008,0x0050> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00770 template <> struct TagToType<0x0008,0x0051> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00777 template <> struct TagToType<0x0008,0x0052> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00784 template <> struct TagToType<0x0008,0x0054> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
enum { VRType = VR::AE };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
00791 template <> struct TagToType<0x0008,0x0056> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00798 template <> struct TagToType<0x0008,0x0058> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
00805 template <> struct TagToType<0x0008,0x0060> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00812 template <> struct TagToType<0x0008,0x0061> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
00819 template <> struct TagToType<0x0008,0x0062> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
00826 template <> struct TagToType<0x0008,0x0064> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00833 template <> struct TagToType<0x0008,0x0068> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00840 template <> struct TagToType<0x0008,0x0070> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00847 template <> struct TagToType<0x0008,0x0080> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00854 template <> struct TagToType<0x0008,0x0081> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
enum { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00861 template <> struct TagToType<0x0008,0x0082> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00868 template <> struct TagToType<0x0008,0x0090> {
static const char* GetVRString() { return "PN"; }
typedef VRToType<VR::PN>::Type Type;
enum { VRType = VR::PN };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00875 template <> struct TagToType<0x0008,0x0092> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
enum { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00882 template <> struct TagToType<0x0008,0x0094> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
00889 template <> struct TagToType<0x0008,0x0096> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00896 template <> struct TagToType<0x0008,0x0100> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00903 template <> struct TagToType<0x0008,0x0102> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00910 template <> struct TagToType<0x0008,0x0103> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00917 template <> struct TagToType<0x0008,0x0104> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00924 template <> struct TagToType<0x0008,0x0105> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00931 template <> struct TagToType<0x0008,0x0106> {
static const char* GetVRString() { return "DT"; }
typedef VRToType<VR::DT>::Type Type;
enum { VRType = VR::DT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00938 template <> struct TagToType<0x0008,0x0107> {
static const char* GetVRString() { return "DT"; }
typedef VRToType<VR::DT>::Type Type;
enum { VRType = VR::DT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00945 template <> struct TagToType<0x0008,0x010b> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00952 template <> struct TagToType<0x0008,0x010c> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00959 template <> struct TagToType<0x0008,0x010d> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00966 template <> struct TagToType<0x0008,0x010f> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00973 template <> struct TagToType<0x0008,0x0110> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00980 template <> struct TagToType<0x0008,0x0112> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00987 template <> struct TagToType<0x0008,0x0114> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
enum { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
00994 template <> struct TagToType<0x0008,0x0115> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
enum { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01001 template <> struct TagToType<0x0008,0x0116> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
enum { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01008 template <> struct TagToType<0x0008,0x0117> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01015 template <> struct TagToType<0x0008,0x0201> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01022 template <> struct TagToType<0x0008,0x1000> {
static const char* GetVRString() { return "AE"; }
typedef VRToType<VR::AE>::Type Type;
enum { VRType = VR::AE };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01029 template <> struct TagToType<0x0008,0x1010> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01036 template <> struct TagToType<0x0008,0x1030> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01043 template <> struct TagToType<0x0008,0x1032> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01050 template <> struct TagToType<0x0008,0x103e> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01057 template <> struct TagToType<0x0008,0x103f> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01064 template <> struct TagToType<0x0008,0x1040> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01071 template <> struct TagToType<0x0008,0x1048> {
static const char* GetVRString() { return "PN"; }
typedef VRToType<VR::PN>::Type Type;
enum { VRType = VR::PN };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01078 template <> struct TagToType<0x0008,0x1049> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01085 template <> struct TagToType<0x0008,0x1050> {
static const char* GetVRString() { return "PN"; }
typedef VRToType<VR::PN>::Type Type;
enum { VRType = VR::PN };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01092 template <> struct TagToType<0x0008,0x1052> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01099 template <> struct TagToType<0x0008,0x1060> {
static const char* GetVRString() { return "PN"; }
typedef VRToType<VR::PN>::Type Type;
enum { VRType = VR::PN };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01106 template <> struct TagToType<0x0008,0x1062> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01113 template <> struct TagToType<0x0008,0x1070> {
static const char* GetVRString() { return "PN"; }
typedef VRToType<VR::PN>::Type Type;
enum { VRType = VR::PN };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01120 template <> struct TagToType<0x0008,0x1072> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01127 template <> struct TagToType<0x0008,0x1080> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01134 template <> struct TagToType<0x0008,0x1084> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01141 template <> struct TagToType<0x0008,0x1090> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01148 template <> struct TagToType<0x0008,0x1100> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01155 template <> struct TagToType<0x0008,0x1110> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01162 template <> struct TagToType<0x0008,0x1111> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01169 template <> struct TagToType<0x0008,0x1115> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01176 template <> struct TagToType<0x0008,0x1120> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01183 template <> struct TagToType<0x0008,0x1125> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01190 template <> struct TagToType<0x0008,0x1130> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01197 template <> struct TagToType<0x0008,0x1134> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01204 template <> struct TagToType<0x0008,0x113a> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01211 template <> struct TagToType<0x0008,0x1140> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01218 template <> struct TagToType<0x0008,0x1145> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01225 template <> struct TagToType<0x0008,0x114a> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01232 template <> struct TagToType<0x0008,0x114b> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01239 template <> struct TagToType<0x0008,0x1150> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01246 template <> struct TagToType<0x0008,0x1155> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01253 template <> struct TagToType<0x0008,0x115a> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01260 template <> struct TagToType<0x0008,0x1160> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01267 template <> struct TagToType<0x0008,0x1161> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01274 template <> struct TagToType<0x0008,0x1162> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM3_3n };
static const char* GetVMString() { return "3-3n"; }
};
01281 template <> struct TagToType<0x0008,0x1163> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
01288 template <> struct TagToType<0x0008,0x1164> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01295 template <> struct TagToType<0x0008,0x1167> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01302 template <> struct TagToType<0x0008,0x1195> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01309 template <> struct TagToType<0x0008,0x1197> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01316 template <> struct TagToType<0x0008,0x1198> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01323 template <> struct TagToType<0x0008,0x1199> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01330 template <> struct TagToType<0x0008,0x1200> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01337 template <> struct TagToType<0x0008,0x1250> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01344 template <> struct TagToType<0x0008,0x2110> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01351 template <> struct TagToType<0x0008,0x2111> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
enum { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01358 template <> struct TagToType<0x0008,0x2112> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01365 template <> struct TagToType<0x0008,0x2120> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01372 template <> struct TagToType<0x0008,0x2122> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01379 template <> struct TagToType<0x0008,0x2124> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01386 template <> struct TagToType<0x0008,0x2127> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01393 template <> struct TagToType<0x0008,0x2128> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01400 template <> struct TagToType<0x0008,0x2129> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01407 template <> struct TagToType<0x0008,0x212a> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01414 template <> struct TagToType<0x0008,0x2130> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01421 template <> struct TagToType<0x0008,0x2132> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01428 template <> struct TagToType<0x0008,0x2133> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01435 template <> struct TagToType<0x0008,0x2134> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01442 template <> struct TagToType<0x0008,0x2135> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01449 template <> struct TagToType<0x0008,0x2142> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01456 template <> struct TagToType<0x0008,0x2143> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01463 template <> struct TagToType<0x0008,0x2144> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01470 template <> struct TagToType<0x0008,0x2200> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01477 template <> struct TagToType<0x0008,0x2204> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01484 template <> struct TagToType<0x0008,0x2208> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01491 template <> struct TagToType<0x0008,0x2218> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01498 template <> struct TagToType<0x0008,0x2220> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01505 template <> struct TagToType<0x0008,0x2228> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01512 template <> struct TagToType<0x0008,0x2229> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01519 template <> struct TagToType<0x0008,0x2230> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01526 template <> struct TagToType<0x0008,0x2240> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01533 template <> struct TagToType<0x0008,0x2242> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01540 template <> struct TagToType<0x0008,0x2244> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01547 template <> struct TagToType<0x0008,0x2246> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01554 template <> struct TagToType<0x0008,0x2251> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01561 template <> struct TagToType<0x0008,0x2253> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01568 template <> struct TagToType<0x0008,0x2255> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01575 template <> struct TagToType<0x0008,0x2256> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
enum { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01582 template <> struct TagToType<0x0008,0x2257> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01589 template <> struct TagToType<0x0008,0x2258> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
enum { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01596 template <> struct TagToType<0x0008,0x2259> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01603 template <> struct TagToType<0x0008,0x225a> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01610 template <> struct TagToType<0x0008,0x225c> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01617 template <> struct TagToType<0x0008,0x3001> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01624 template <> struct TagToType<0x0008,0x3010> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01631 template <> struct TagToType<0x0008,0x4000> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
enum { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01638 template <> struct TagToType<0x0008,0x9007> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM4 };
static const char* GetVMString() { return "4"; }
};
01645 template <> struct TagToType<0x0008,0x9092> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01652 template <> struct TagToType<0x0008,0x9121> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01659 template <> struct TagToType<0x0008,0x9123> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01666 template <> struct TagToType<0x0008,0x9124> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01673 template <> struct TagToType<0x0008,0x9154> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01680 template <> struct TagToType<0x0008,0x9205> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01687 template <> struct TagToType<0x0008,0x9206> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01694 template <> struct TagToType<0x0008,0x9207> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01701 template <> struct TagToType<0x0008,0x9208> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01708 template <> struct TagToType<0x0008,0x9209> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01715 template <> struct TagToType<0x0008,0x9215> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01722 template <> struct TagToType<0x0008,0x9237> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01729 template <> struct TagToType<0x0008,0x9410> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01736 template <> struct TagToType<0x0008,0x9458> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01743 template <> struct TagToType<0x0008,0x9459> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01750 template <> struct TagToType<0x0008,0x9460> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01757 template <> struct TagToType<0x0010,0x0010> {
static const char* GetVRString() { return "PN"; }
typedef VRToType<VR::PN>::Type Type;
enum { VRType = VR::PN };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01764 template <> struct TagToType<0x0010,0x0020> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01771 template <> struct TagToType<0x0010,0x0021> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01778 template <> struct TagToType<0x0010,0x0022> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01785 template <> struct TagToType<0x0010,0x0024> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01792 template <> struct TagToType<0x0010,0x0030> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
enum { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01799 template <> struct TagToType<0x0010,0x0032> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01806 template <> struct TagToType<0x0010,0x0040> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01813 template <> struct TagToType<0x0010,0x0050> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01820 template <> struct TagToType<0x0010,0x0101> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01827 template <> struct TagToType<0x0010,0x0102> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01834 template <> struct TagToType<0x0010,0x1000> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01841 template <> struct TagToType<0x0010,0x1001> {
static const char* GetVRString() { return "PN"; }
typedef VRToType<VR::PN>::Type Type;
enum { VRType = VR::PN };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01848 template <> struct TagToType<0x0010,0x1002> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01855 template <> struct TagToType<0x0010,0x1005> {
static const char* GetVRString() { return "PN"; }
typedef VRToType<VR::PN>::Type Type;
enum { VRType = VR::PN };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01862 template <> struct TagToType<0x0010,0x1010> {
static const char* GetVRString() { return "AS"; }
typedef VRToType<VR::AS>::Type Type;
enum { VRType = VR::AS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01869 template <> struct TagToType<0x0010,0x1020> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01876 template <> struct TagToType<0x0010,0x1030> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01883 template <> struct TagToType<0x0010,0x1040> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01890 template <> struct TagToType<0x0010,0x1050> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01897 template <> struct TagToType<0x0010,0x1060> {
static const char* GetVRString() { return "PN"; }
typedef VRToType<VR::PN>::Type Type;
enum { VRType = VR::PN };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01904 template <> struct TagToType<0x0010,0x1080> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01911 template <> struct TagToType<0x0010,0x1081> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01918 template <> struct TagToType<0x0010,0x1090> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01925 template <> struct TagToType<0x0010,0x2000> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01932 template <> struct TagToType<0x0010,0x2110> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01939 template <> struct TagToType<0x0010,0x2150> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01946 template <> struct TagToType<0x0010,0x2152> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01953 template <> struct TagToType<0x0010,0x2154> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
01960 template <> struct TagToType<0x0010,0x2160> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01967 template <> struct TagToType<0x0010,0x2180> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01974 template <> struct TagToType<0x0010,0x21a0> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01981 template <> struct TagToType<0x0010,0x21b0> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
enum { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01988 template <> struct TagToType<0x0010,0x21c0> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
01995 template <> struct TagToType<0x0010,0x21d0> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
enum { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02002 template <> struct TagToType<0x0010,0x21f0> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02009 template <> struct TagToType<0x0010,0x2201> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02016 template <> struct TagToType<0x0010,0x2202> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02023 template <> struct TagToType<0x0010,0x2203> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02030 template <> struct TagToType<0x0010,0x2210> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02037 template <> struct TagToType<0x0010,0x2292> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02044 template <> struct TagToType<0x0010,0x2293> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02051 template <> struct TagToType<0x0010,0x2294> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02058 template <> struct TagToType<0x0010,0x2295> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02065 template <> struct TagToType<0x0010,0x2296> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02072 template <> struct TagToType<0x0010,0x2297> {
static const char* GetVRString() { return "PN"; }
typedef VRToType<VR::PN>::Type Type;
enum { VRType = VR::PN };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02079 template <> struct TagToType<0x0010,0x2298> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02086 template <> struct TagToType<0x0010,0x2299> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02093 template <> struct TagToType<0x0010,0x4000> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
enum { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02100 template <> struct TagToType<0x0010,0x9431> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02107 template <> struct TagToType<0x0012,0x0010> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02114 template <> struct TagToType<0x0012,0x0020> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02121 template <> struct TagToType<0x0012,0x0021> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02128 template <> struct TagToType<0x0012,0x0030> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02135 template <> struct TagToType<0x0012,0x0031> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02142 template <> struct TagToType<0x0012,0x0040> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02149 template <> struct TagToType<0x0012,0x0042> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02156 template <> struct TagToType<0x0012,0x0050> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02163 template <> struct TagToType<0x0012,0x0051> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
enum { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02170 template <> struct TagToType<0x0012,0x0060> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02177 template <> struct TagToType<0x0012,0x0062> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02184 template <> struct TagToType<0x0012,0x0063> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
02191 template <> struct TagToType<0x0012,0x0064> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02198 template <> struct TagToType<0x0012,0x0071> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02205 template <> struct TagToType<0x0012,0x0072> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02212 template <> struct TagToType<0x0012,0x0081> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02219 template <> struct TagToType<0x0012,0x0082> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02226 template <> struct TagToType<0x0012,0x0083> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02233 template <> struct TagToType<0x0012,0x0084> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02240 template <> struct TagToType<0x0012,0x0085> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02247 template <> struct TagToType<0x0018,0x0010> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02254 template <> struct TagToType<0x0018,0x0012> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02261 template <> struct TagToType<0x0018,0x0014> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02268 template <> struct TagToType<0x0018,0x0015> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02275 template <> struct TagToType<0x0018,0x0020> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
02282 template <> struct TagToType<0x0018,0x0021> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
02289 template <> struct TagToType<0x0018,0x0022> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
02296 template <> struct TagToType<0x0018,0x0023> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02303 template <> struct TagToType<0x0018,0x0024> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02310 template <> struct TagToType<0x0018,0x0025> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02317 template <> struct TagToType<0x0018,0x0026> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02324 template <> struct TagToType<0x0018,0x0027> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02331 template <> struct TagToType<0x0018,0x0028> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02338 template <> struct TagToType<0x0018,0x0029> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02345 template <> struct TagToType<0x0018,0x002a> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02352 template <> struct TagToType<0x0018,0x0030> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
02359 template <> struct TagToType<0x0018,0x0031> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02366 template <> struct TagToType<0x0018,0x0032> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02373 template <> struct TagToType<0x0018,0x0033> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
02380 template <> struct TagToType<0x0018,0x0034> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02387 template <> struct TagToType<0x0018,0x0035> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02394 template <> struct TagToType<0x0018,0x0036> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02401 template <> struct TagToType<0x0018,0x0037> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02408 template <> struct TagToType<0x0018,0x0038> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02415 template <> struct TagToType<0x0018,0x0039> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02422 template <> struct TagToType<0x0018,0x003a> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
enum { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02429 template <> struct TagToType<0x0018,0x0040> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02436 template <> struct TagToType<0x0018,0x0042> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02443 template <> struct TagToType<0x0018,0x0050> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02450 template <> struct TagToType<0x0018,0x0060> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02457 template <> struct TagToType<0x0018,0x0070> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02464 template <> struct TagToType<0x0018,0x0071> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02471 template <> struct TagToType<0x0018,0x0072> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02478 template <> struct TagToType<0x0018,0x0073> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02485 template <> struct TagToType<0x0018,0x0074> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02492 template <> struct TagToType<0x0018,0x0075> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02499 template <> struct TagToType<0x0018,0x0080> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02506 template <> struct TagToType<0x0018,0x0081> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02513 template <> struct TagToType<0x0018,0x0082> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02520 template <> struct TagToType<0x0018,0x0083> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02527 template <> struct TagToType<0x0018,0x0084> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02534 template <> struct TagToType<0x0018,0x0085> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02541 template <> struct TagToType<0x0018,0x0086> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
02548 template <> struct TagToType<0x0018,0x0087> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02555 template <> struct TagToType<0x0018,0x0088> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02562 template <> struct TagToType<0x0018,0x0089> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02569 template <> struct TagToType<0x0018,0x0090> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02576 template <> struct TagToType<0x0018,0x0091> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02583 template <> struct TagToType<0x0018,0x0093> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02590 template <> struct TagToType<0x0018,0x0094> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02597 template <> struct TagToType<0x0018,0x0095> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02604 template <> struct TagToType<0x0018,0x1000> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02611 template <> struct TagToType<0x0018,0x1002> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02618 template <> struct TagToType<0x0018,0x1003> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02625 template <> struct TagToType<0x0018,0x1004> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02632 template <> struct TagToType<0x0018,0x1005> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02639 template <> struct TagToType<0x0018,0x1006> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02646 template <> struct TagToType<0x0018,0x1007> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02653 template <> struct TagToType<0x0018,0x1008> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02660 template <> struct TagToType<0x0018,0x1010> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02667 template <> struct TagToType<0x0018,0x1011> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02674 template <> struct TagToType<0x0018,0x1012> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
enum { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02681 template <> struct TagToType<0x0018,0x1014> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02688 template <> struct TagToType<0x0018,0x1016> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02695 template <> struct TagToType<0x0018,0x1017> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02702 template <> struct TagToType<0x0018,0x1018> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02709 template <> struct TagToType<0x0018,0x1019> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
02716 template <> struct TagToType<0x0018,0x101a> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
02723 template <> struct TagToType<0x0018,0x101b> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02730 template <> struct TagToType<0x0018,0x1020> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
02737 template <> struct TagToType<0x0018,0x1022> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02744 template <> struct TagToType<0x0018,0x1023> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02751 template <> struct TagToType<0x0018,0x1030> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02758 template <> struct TagToType<0x0018,0x1040> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02765 template <> struct TagToType<0x0018,0x1041> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02772 template <> struct TagToType<0x0018,0x1042> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02779 template <> struct TagToType<0x0018,0x1043> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02786 template <> struct TagToType<0x0018,0x1044> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02793 template <> struct TagToType<0x0018,0x1045> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02800 template <> struct TagToType<0x0018,0x1046> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
02807 template <> struct TagToType<0x0018,0x1047> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
02814 template <> struct TagToType<0x0018,0x1048> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02821 template <> struct TagToType<0x0018,0x1049> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02828 template <> struct TagToType<0x0018,0x1050> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02835 template <> struct TagToType<0x0018,0x1060> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02842 template <> struct TagToType<0x0018,0x1061> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02849 template <> struct TagToType<0x0018,0x1062> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02856 template <> struct TagToType<0x0018,0x1063> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02863 template <> struct TagToType<0x0018,0x1064> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02870 template <> struct TagToType<0x0018,0x1065> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
02877 template <> struct TagToType<0x0018,0x1066> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02884 template <> struct TagToType<0x0018,0x1067> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02891 template <> struct TagToType<0x0018,0x1068> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02898 template <> struct TagToType<0x0018,0x1069> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02905 template <> struct TagToType<0x0018,0x106a> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02912 template <> struct TagToType<0x0018,0x106c> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
02919 template <> struct TagToType<0x0018,0x106e> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02926 template <> struct TagToType<0x0018,0x1070> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02933 template <> struct TagToType<0x0018,0x1071> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02940 template <> struct TagToType<0x0018,0x1072> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02947 template <> struct TagToType<0x0018,0x1073> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02954 template <> struct TagToType<0x0018,0x1074> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02961 template <> struct TagToType<0x0018,0x1075> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02968 template <> struct TagToType<0x0018,0x1076> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02975 template <> struct TagToType<0x0018,0x1077> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02982 template <> struct TagToType<0x0018,0x1078> {
static const char* GetVRString() { return "DT"; }
typedef VRToType<VR::DT>::Type Type;
enum { VRType = VR::DT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02989 template <> struct TagToType<0x0018,0x1079> {
static const char* GetVRString() { return "DT"; }
typedef VRToType<VR::DT>::Type Type;
enum { VRType = VR::DT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
02996 template <> struct TagToType<0x0018,0x1080> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03003 template <> struct TagToType<0x0018,0x1081> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03010 template <> struct TagToType<0x0018,0x1082> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03017 template <> struct TagToType<0x0018,0x1083> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03024 template <> struct TagToType<0x0018,0x1084> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03031 template <> struct TagToType<0x0018,0x1085> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03038 template <> struct TagToType<0x0018,0x1086> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03045 template <> struct TagToType<0x0018,0x1088> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03052 template <> struct TagToType<0x0018,0x1090> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03059 template <> struct TagToType<0x0018,0x1094> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03066 template <> struct TagToType<0x0018,0x1100> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03073 template <> struct TagToType<0x0018,0x1110> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03080 template <> struct TagToType<0x0018,0x1111> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03087 template <> struct TagToType<0x0018,0x1114> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03094 template <> struct TagToType<0x0018,0x1120> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03101 template <> struct TagToType<0x0018,0x1121> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03108 template <> struct TagToType<0x0018,0x1130> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03115 template <> struct TagToType<0x0018,0x1131> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03122 template <> struct TagToType<0x0018,0x1134> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03129 template <> struct TagToType<0x0018,0x1135> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03136 template <> struct TagToType<0x0018,0x1136> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03143 template <> struct TagToType<0x0018,0x1137> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03150 template <> struct TagToType<0x0018,0x1138> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03157 template <> struct TagToType<0x0018,0x113a> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03164 template <> struct TagToType<0x0018,0x1140> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03171 template <> struct TagToType<0x0018,0x1141> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03178 template <> struct TagToType<0x0018,0x1142> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03185 template <> struct TagToType<0x0018,0x1143> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03192 template <> struct TagToType<0x0018,0x1144> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03199 template <> struct TagToType<0x0018,0x1145> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03206 template <> struct TagToType<0x0018,0x1146> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03213 template <> struct TagToType<0x0018,0x1147> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03220 template <> struct TagToType<0x0018,0x1149> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
03227 template <> struct TagToType<0x0018,0x1150> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03234 template <> struct TagToType<0x0018,0x1151> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03241 template <> struct TagToType<0x0018,0x1152> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03248 template <> struct TagToType<0x0018,0x1153> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03255 template <> struct TagToType<0x0018,0x1154> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03262 template <> struct TagToType<0x0018,0x1155> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03269 template <> struct TagToType<0x0018,0x1156> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03276 template <> struct TagToType<0x0018,0x115a> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03283 template <> struct TagToType<0x0018,0x115e> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03290 template <> struct TagToType<0x0018,0x1160> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03297 template <> struct TagToType<0x0018,0x1161> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03304 template <> struct TagToType<0x0018,0x1162> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03311 template <> struct TagToType<0x0018,0x1164> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
03318 template <> struct TagToType<0x0018,0x1166> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03325 template <> struct TagToType<0x0018,0x1170> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03332 template <> struct TagToType<0x0018,0x1180> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03339 template <> struct TagToType<0x0018,0x1181> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03346 template <> struct TagToType<0x0018,0x1182> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
03353 template <> struct TagToType<0x0018,0x1183> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
03360 template <> struct TagToType<0x0018,0x1184> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
03367 template <> struct TagToType<0x0018,0x1190> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03374 template <> struct TagToType<0x0018,0x1191> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03381 template <> struct TagToType<0x0018,0x11a0> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03388 template <> struct TagToType<0x0018,0x11a2> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03395 template <> struct TagToType<0x0018,0x1200> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
enum { VRType = VR::DA };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03402 template <> struct TagToType<0x0018,0x1201> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03409 template <> struct TagToType<0x0018,0x1210> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03416 template <> struct TagToType<0x0018,0x1240> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03423 template <> struct TagToType<0x0018,0x1242> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03430 template <> struct TagToType<0x0018,0x1243> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03437 template <> struct TagToType<0x0018,0x1244> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03444 template <> struct TagToType<0x0018,0x1250> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03451 template <> struct TagToType<0x0018,0x1251> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03458 template <> struct TagToType<0x0018,0x1260> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03465 template <> struct TagToType<0x0018,0x1261> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03472 template <> struct TagToType<0x0018,0x1300> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03479 template <> struct TagToType<0x0018,0x1301> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03486 template <> struct TagToType<0x0018,0x1302> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03493 template <> struct TagToType<0x0018,0x1310> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM4 };
static const char* GetVMString() { return "4"; }
};
03500 template <> struct TagToType<0x0018,0x1312> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03507 template <> struct TagToType<0x0018,0x1314> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03514 template <> struct TagToType<0x0018,0x1315> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03521 template <> struct TagToType<0x0018,0x1316> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03528 template <> struct TagToType<0x0018,0x1318> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03535 template <> struct TagToType<0x0018,0x1400> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03542 template <> struct TagToType<0x0018,0x1401> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03549 template <> struct TagToType<0x0018,0x1402> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03556 template <> struct TagToType<0x0018,0x1403> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03563 template <> struct TagToType<0x0018,0x1404> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03570 template <> struct TagToType<0x0018,0x1405> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03577 template <> struct TagToType<0x0018,0x1450> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03584 template <> struct TagToType<0x0018,0x1460> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03591 template <> struct TagToType<0x0018,0x1470> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03598 template <> struct TagToType<0x0018,0x1480> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03605 template <> struct TagToType<0x0018,0x1490> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03612 template <> struct TagToType<0x0018,0x1491> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03619 template <> struct TagToType<0x0018,0x1495> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03626 template <> struct TagToType<0x0018,0x1500> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03633 template <> struct TagToType<0x0018,0x1508> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03640 template <> struct TagToType<0x0018,0x1510> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03647 template <> struct TagToType<0x0018,0x1511> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03654 template <> struct TagToType<0x0018,0x1520> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03661 template <> struct TagToType<0x0018,0x1521> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03668 template <> struct TagToType<0x0018,0x1530> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03675 template <> struct TagToType<0x0018,0x1531> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03682 template <> struct TagToType<0x0018,0x1600> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_3 };
static const char* GetVMString() { return "1-3"; }
};
03689 template <> struct TagToType<0x0018,0x1602> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03696 template <> struct TagToType<0x0018,0x1604> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03703 template <> struct TagToType<0x0018,0x1606> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03710 template <> struct TagToType<0x0018,0x1608> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03717 template <> struct TagToType<0x0018,0x1610> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
03724 template <> struct TagToType<0x0018,0x1612> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03731 template <> struct TagToType<0x0018,0x1620> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM2_2n };
static const char* GetVMString() { return "2-2n"; }
};
03738 template <> struct TagToType<0x0018,0x1622> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03745 template <> struct TagToType<0x0018,0x1623> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03752 template <> struct TagToType<0x0018,0x1624> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM3 };
static const char* GetVMString() { return "3"; }
};
03759 template <> struct TagToType<0x0018,0x1700> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_3 };
static const char* GetVMString() { return "1-3"; }
};
03766 template <> struct TagToType<0x0018,0x1702> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03773 template <> struct TagToType<0x0018,0x1704> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03780 template <> struct TagToType<0x0018,0x1706> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03787 template <> struct TagToType<0x0018,0x1708> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03794 template <> struct TagToType<0x0018,0x1710> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
03801 template <> struct TagToType<0x0018,0x1712> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03808 template <> struct TagToType<0x0018,0x1720> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM2_2n };
static const char* GetVMString() { return "2-2n"; }
};
03815 template <> struct TagToType<0x0018,0x1800> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03822 template <> struct TagToType<0x0018,0x1801> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03829 template <> struct TagToType<0x0018,0x1802> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03836 template <> struct TagToType<0x0018,0x1803> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03843 template <> struct TagToType<0x0018,0x2001> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03850 template <> struct TagToType<0x0018,0x2002> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03857 template <> struct TagToType<0x0018,0x2003> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03864 template <> struct TagToType<0x0018,0x2004> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03871 template <> struct TagToType<0x0018,0x2005> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03878 template <> struct TagToType<0x0018,0x2006> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03885 template <> struct TagToType<0x0018,0x2010> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
03892 template <> struct TagToType<0x0018,0x2020> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03899 template <> struct TagToType<0x0018,0x2030> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03906 template <> struct TagToType<0x0018,0x3100> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03913 template <> struct TagToType<0x0018,0x3101> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03920 template <> struct TagToType<0x0018,0x3102> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03927 template <> struct TagToType<0x0018,0x3103> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03934 template <> struct TagToType<0x0018,0x3104> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03941 template <> struct TagToType<0x0018,0x3105> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03948 template <> struct TagToType<0x0018,0x4000> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
enum { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03955 template <> struct TagToType<0x0018,0x5000> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03962 template <> struct TagToType<0x0018,0x5010> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
03969 template <> struct TagToType<0x0018,0x5012> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03976 template <> struct TagToType<0x0018,0x5020> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03983 template <> struct TagToType<0x0018,0x5021> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03990 template <> struct TagToType<0x0018,0x5022> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
03997 template <> struct TagToType<0x0018,0x5024> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04004 template <> struct TagToType<0x0018,0x5026> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04011 template <> struct TagToType<0x0018,0x5027> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04018 template <> struct TagToType<0x0018,0x5028> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04025 template <> struct TagToType<0x0018,0x5029> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04032 template <> struct TagToType<0x0018,0x5030> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04039 template <> struct TagToType<0x0018,0x5040> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04046 template <> struct TagToType<0x0018,0x5050> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04053 template <> struct TagToType<0x0018,0x5100> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04060 template <> struct TagToType<0x0018,0x5101> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04067 template <> struct TagToType<0x0018,0x5104> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04074 template <> struct TagToType<0x0018,0x5210> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM6 };
static const char* GetVMString() { return "6"; }
};
04081 template <> struct TagToType<0x0018,0x5212> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM3 };
static const char* GetVMString() { return "3"; }
};
04088 template <> struct TagToType<0x0018,0x6000> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04095 template <> struct TagToType<0x0018,0x6011> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04102 template <> struct TagToType<0x0018,0x6012> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04109 template <> struct TagToType<0x0018,0x6014> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04116 template <> struct TagToType<0x0018,0x6016> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04123 template <> struct TagToType<0x0018,0x6018> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04130 template <> struct TagToType<0x0018,0x601a> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04137 template <> struct TagToType<0x0018,0x601c> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04144 template <> struct TagToType<0x0018,0x601e> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04151 template <> struct TagToType<0x0018,0x6020> {
static const char* GetVRString() { return "SL"; }
typedef VRToType<VR::SL>::Type Type;
enum { VRType = VR::SL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04158 template <> struct TagToType<0x0018,0x6022> {
static const char* GetVRString() { return "SL"; }
typedef VRToType<VR::SL>::Type Type;
enum { VRType = VR::SL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04165 template <> struct TagToType<0x0018,0x6024> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04172 template <> struct TagToType<0x0018,0x6026> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04179 template <> struct TagToType<0x0018,0x6028> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04186 template <> struct TagToType<0x0018,0x602a> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04193 template <> struct TagToType<0x0018,0x602c> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04200 template <> struct TagToType<0x0018,0x602e> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04207 template <> struct TagToType<0x0018,0x6030> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04214 template <> struct TagToType<0x0018,0x6031> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04221 template <> struct TagToType<0x0018,0x6032> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04228 template <> struct TagToType<0x0018,0x6034> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04235 template <> struct TagToType<0x0018,0x6036> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04242 template <> struct TagToType<0x0018,0x6038> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04249 template <> struct TagToType<0x0018,0x6039> {
static const char* GetVRString() { return "SL"; }
typedef VRToType<VR::SL>::Type Type;
enum { VRType = VR::SL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04256 template <> struct TagToType<0x0018,0x603a> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04263 template <> struct TagToType<0x0018,0x603b> {
static const char* GetVRString() { return "SL"; }
typedef VRToType<VR::SL>::Type Type;
enum { VRType = VR::SL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04270 template <> struct TagToType<0x0018,0x603c> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04277 template <> struct TagToType<0x0018,0x603d> {
static const char* GetVRString() { return "SL"; }
typedef VRToType<VR::SL>::Type Type;
enum { VRType = VR::SL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04284 template <> struct TagToType<0x0018,0x603e> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04291 template <> struct TagToType<0x0018,0x603f> {
static const char* GetVRString() { return "SL"; }
typedef VRToType<VR::SL>::Type Type;
enum { VRType = VR::SL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04298 template <> struct TagToType<0x0018,0x6040> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04305 template <> struct TagToType<0x0018,0x6041> {
static const char* GetVRString() { return "SL"; }
typedef VRToType<VR::SL>::Type Type;
enum { VRType = VR::SL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04312 template <> struct TagToType<0x0018,0x6042> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04319 template <> struct TagToType<0x0018,0x6043> {
static const char* GetVRString() { return "SL"; }
typedef VRToType<VR::SL>::Type Type;
enum { VRType = VR::SL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04326 template <> struct TagToType<0x0018,0x6044> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04333 template <> struct TagToType<0x0018,0x6046> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04340 template <> struct TagToType<0x0018,0x6048> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04347 template <> struct TagToType<0x0018,0x604a> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04354 template <> struct TagToType<0x0018,0x604c> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04361 template <> struct TagToType<0x0018,0x604e> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04368 template <> struct TagToType<0x0018,0x6050> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04375 template <> struct TagToType<0x0018,0x6052> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
04382 template <> struct TagToType<0x0018,0x6054> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
04389 template <> struct TagToType<0x0018,0x6056> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04396 template <> struct TagToType<0x0018,0x6058> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
04403 template <> struct TagToType<0x0018,0x605a> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
04410 template <> struct TagToType<0x0018,0x6060> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
04417 template <> struct TagToType<0x0018,0x7000> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04424 template <> struct TagToType<0x0018,0x7001> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04431 template <> struct TagToType<0x0018,0x7004> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04438 template <> struct TagToType<0x0018,0x7005> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04445 template <> struct TagToType<0x0018,0x7006> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
enum { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04452 template <> struct TagToType<0x0018,0x7008> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
enum { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04459 template <> struct TagToType<0x0018,0x700a> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04466 template <> struct TagToType<0x0018,0x700c> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
enum { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04473 template <> struct TagToType<0x0018,0x700e> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04480 template <> struct TagToType<0x0018,0x7010> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04487 template <> struct TagToType<0x0018,0x7011> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04494 template <> struct TagToType<0x0018,0x7012> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04501 template <> struct TagToType<0x0018,0x7014> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04508 template <> struct TagToType<0x0018,0x7016> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04515 template <> struct TagToType<0x0018,0x701a> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
04522 template <> struct TagToType<0x0018,0x7020> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
04529 template <> struct TagToType<0x0018,0x7022> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
04536 template <> struct TagToType<0x0018,0x7024> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04543 template <> struct TagToType<0x0018,0x7026> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
04550 template <> struct TagToType<0x0018,0x7028> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
04557 template <> struct TagToType<0x0018,0x702a> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04564 template <> struct TagToType<0x0018,0x702b> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04571 template <> struct TagToType<0x0018,0x7030> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
04578 template <> struct TagToType<0x0018,0x7032> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04585 template <> struct TagToType<0x0018,0x7034> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04592 template <> struct TagToType<0x0018,0x7040> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
enum { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04599 template <> struct TagToType<0x0018,0x7041> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
enum { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04606 template <> struct TagToType<0x0018,0x7042> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04613 template <> struct TagToType<0x0018,0x7044> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04620 template <> struct TagToType<0x0018,0x7046> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
04627 template <> struct TagToType<0x0018,0x7048> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04634 template <> struct TagToType<0x0018,0x704c> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04641 template <> struct TagToType<0x0018,0x7050> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
04648 template <> struct TagToType<0x0018,0x7052> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
04655 template <> struct TagToType<0x0018,0x7054> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
04662 template <> struct TagToType<0x0018,0x7056> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
04669 template <> struct TagToType<0x0018,0x7058> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
04676 template <> struct TagToType<0x0018,0x7060> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04683 template <> struct TagToType<0x0018,0x7062> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
enum { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04690 template <> struct TagToType<0x0018,0x7064> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04697 template <> struct TagToType<0x0018,0x7065> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04704 template <> struct TagToType<0x0018,0x8150> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04711 template <> struct TagToType<0x0018,0x8151> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04718 template <> struct TagToType<0x0018,0x9004> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04725 template <> struct TagToType<0x0018,0x9005> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04732 template <> struct TagToType<0x0018,0x9006> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04739 template <> struct TagToType<0x0018,0x9008> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04746 template <> struct TagToType<0x0018,0x9009> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04753 template <> struct TagToType<0x0018,0x9010> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04760 template <> struct TagToType<0x0018,0x9011> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04767 template <> struct TagToType<0x0018,0x9012> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04774 template <> struct TagToType<0x0018,0x9014> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04781 template <> struct TagToType<0x0018,0x9015> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04788 template <> struct TagToType<0x0018,0x9016> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04795 template <> struct TagToType<0x0018,0x9017> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04802 template <> struct TagToType<0x0018,0x9018> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04809 template <> struct TagToType<0x0018,0x9019> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04816 template <> struct TagToType<0x0018,0x9020> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04823 template <> struct TagToType<0x0018,0x9021> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04830 template <> struct TagToType<0x0018,0x9022> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04837 template <> struct TagToType<0x0018,0x9024> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04844 template <> struct TagToType<0x0018,0x9025> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04851 template <> struct TagToType<0x0018,0x9026> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04858 template <> struct TagToType<0x0018,0x9027> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04865 template <> struct TagToType<0x0018,0x9028> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04872 template <> struct TagToType<0x0018,0x9029> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04879 template <> struct TagToType<0x0018,0x9030> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04886 template <> struct TagToType<0x0018,0x9032> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04893 template <> struct TagToType<0x0018,0x9033> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04900 template <> struct TagToType<0x0018,0x9034> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04907 template <> struct TagToType<0x0018,0x9035> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04914 template <> struct TagToType<0x0018,0x9036> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04921 template <> struct TagToType<0x0018,0x9037> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04928 template <> struct TagToType<0x0018,0x9041> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04935 template <> struct TagToType<0x0018,0x9042> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04942 template <> struct TagToType<0x0018,0x9043> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04949 template <> struct TagToType<0x0018,0x9044> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04956 template <> struct TagToType<0x0018,0x9045> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04963 template <> struct TagToType<0x0018,0x9046> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04970 template <> struct TagToType<0x0018,0x9047> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04977 template <> struct TagToType<0x0018,0x9048> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04984 template <> struct TagToType<0x0018,0x9049> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04991 template <> struct TagToType<0x0018,0x9050> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
04998 template <> struct TagToType<0x0018,0x9051> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05005 template <> struct TagToType<0x0018,0x9052> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
05012 template <> struct TagToType<0x0018,0x9053> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
05019 template <> struct TagToType<0x0018,0x9054> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05026 template <> struct TagToType<0x0018,0x9058> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05033 template <> struct TagToType<0x0018,0x9059> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05040 template <> struct TagToType<0x0018,0x9060> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
05047 template <> struct TagToType<0x0018,0x9061> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
05054 template <> struct TagToType<0x0018,0x9062> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05061 template <> struct TagToType<0x0018,0x9063> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
05068 template <> struct TagToType<0x0018,0x9064> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05075 template <> struct TagToType<0x0018,0x9065> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
05082 template <> struct TagToType<0x0018,0x9066> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
05089 template <> struct TagToType<0x0018,0x9067> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05096 template <> struct TagToType<0x0018,0x9069> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05103 template <> struct TagToType<0x0018,0x9070> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05110 template <> struct TagToType<0x0018,0x9073> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05117 template <> struct TagToType<0x0018,0x9074> {
static const char* GetVRString() { return "DT"; }
typedef VRToType<VR::DT>::Type Type;
enum { VRType = VR::DT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05124 template <> struct TagToType<0x0018,0x9075> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05131 template <> struct TagToType<0x0018,0x9076> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05138 template <> struct TagToType<0x0018,0x9077> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05145 template <> struct TagToType<0x0018,0x9078> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05152 template <> struct TagToType<0x0018,0x9079> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
05159 template <> struct TagToType<0x0018,0x9080> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
enum { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05166 template <> struct TagToType<0x0018,0x9081> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05173 template <> struct TagToType<0x0018,0x9082> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05180 template <> struct TagToType<0x0018,0x9083> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05187 template <> struct TagToType<0x0018,0x9084> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05194 template <> struct TagToType<0x0018,0x9085> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05201 template <> struct TagToType<0x0018,0x9087> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05208 template <> struct TagToType<0x0018,0x9089> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM3 };
static const char* GetVMString() { return "3"; }
};
05215 template <> struct TagToType<0x0018,0x9090> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM3 };
static const char* GetVMString() { return "3"; }
};
05222 template <> struct TagToType<0x0018,0x9091> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05229 template <> struct TagToType<0x0018,0x9093> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05236 template <> struct TagToType<0x0018,0x9094> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05243 template <> struct TagToType<0x0018,0x9095> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05250 template <> struct TagToType<0x0018,0x9096> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05257 template <> struct TagToType<0x0018,0x9098> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
05264 template <> struct TagToType<0x0018,0x9100> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
05271 template <> struct TagToType<0x0018,0x9101> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05278 template <> struct TagToType<0x0018,0x9103> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05285 template <> struct TagToType<0x0018,0x9104> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05292 template <> struct TagToType<0x0018,0x9105> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM3 };
static const char* GetVMString() { return "3"; }
};
05299 template <> struct TagToType<0x0018,0x9106> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM3 };
static const char* GetVMString() { return "3"; }
};
05306 template <> struct TagToType<0x0018,0x9107> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05313 template <> struct TagToType<0x0018,0x9112> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05320 template <> struct TagToType<0x0018,0x9114> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05327 template <> struct TagToType<0x0018,0x9115> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05334 template <> struct TagToType<0x0018,0x9117> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05341 template <> struct TagToType<0x0018,0x9118> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05348 template <> struct TagToType<0x0018,0x9119> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05355 template <> struct TagToType<0x0018,0x9125> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05362 template <> struct TagToType<0x0018,0x9126> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05369 template <> struct TagToType<0x0018,0x9127> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05376 template <> struct TagToType<0x0018,0x9147> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05383 template <> struct TagToType<0x0018,0x9151> {
static const char* GetVRString() { return "DT"; }
typedef VRToType<VR::DT>::Type Type;
enum { VRType = VR::DT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05390 template <> struct TagToType<0x0018,0x9152> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05397 template <> struct TagToType<0x0018,0x9155> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05404 template <> struct TagToType<0x0018,0x9159> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05411 template <> struct TagToType<0x0018,0x9166> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05418 template <> struct TagToType<0x0018,0x9168> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05425 template <> struct TagToType<0x0018,0x9169> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05432 template <> struct TagToType<0x0018,0x9170> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05439 template <> struct TagToType<0x0018,0x9171> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05446 template <> struct TagToType<0x0018,0x9172> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05453 template <> struct TagToType<0x0018,0x9173> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05460 template <> struct TagToType<0x0018,0x9174> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05467 template <> struct TagToType<0x0018,0x9175> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05474 template <> struct TagToType<0x0018,0x9176> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05481 template <> struct TagToType<0x0018,0x9177> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05488 template <> struct TagToType<0x0018,0x9178> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05495 template <> struct TagToType<0x0018,0x9179> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05502 template <> struct TagToType<0x0018,0x9180> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05509 template <> struct TagToType<0x0018,0x9181> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05516 template <> struct TagToType<0x0018,0x9182> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05523 template <> struct TagToType<0x0018,0x9183> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05530 template <> struct TagToType<0x0018,0x9184> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05537 template <> struct TagToType<0x0018,0x9185> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
enum { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05544 template <> struct TagToType<0x0018,0x9186> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05551 template <> struct TagToType<0x0018,0x9195> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05558 template <> struct TagToType<0x0018,0x9196> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05565 template <> struct TagToType<0x0018,0x9197> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05572 template <> struct TagToType<0x0018,0x9198> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05579 template <> struct TagToType<0x0018,0x9199> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05586 template <> struct TagToType<0x0018,0x9200> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05593 template <> struct TagToType<0x0018,0x9214> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05600 template <> struct TagToType<0x0018,0x9217> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05607 template <> struct TagToType<0x0018,0x9218> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05614 template <> struct TagToType<0x0018,0x9219> {
static const char* GetVRString() { return "SS"; }
typedef VRToType<VR::SS>::Type Type;
enum { VRType = VR::SS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05621 template <> struct TagToType<0x0018,0x9220> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05628 template <> struct TagToType<0x0018,0x9226> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05635 template <> struct TagToType<0x0018,0x9227> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05642 template <> struct TagToType<0x0018,0x9231> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05649 template <> struct TagToType<0x0018,0x9232> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05656 template <> struct TagToType<0x0018,0x9234> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05663 template <> struct TagToType<0x0018,0x9236> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05670 template <> struct TagToType<0x0018,0x9239> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05677 template <> struct TagToType<0x0018,0x9240> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05684 template <> struct TagToType<0x0018,0x9241> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05691 template <> struct TagToType<0x0018,0x9295> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05698 template <> struct TagToType<0x0018,0x9296> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05705 template <> struct TagToType<0x0018,0x9301> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05712 template <> struct TagToType<0x0018,0x9302> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05719 template <> struct TagToType<0x0018,0x9303> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05726 template <> struct TagToType<0x0018,0x9304> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05733 template <> struct TagToType<0x0018,0x9305> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05740 template <> struct TagToType<0x0018,0x9306> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05747 template <> struct TagToType<0x0018,0x9307> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05754 template <> struct TagToType<0x0018,0x9308> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05761 template <> struct TagToType<0x0018,0x9309> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05768 template <> struct TagToType<0x0018,0x9310> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05775 template <> struct TagToType<0x0018,0x9311> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05782 template <> struct TagToType<0x0018,0x9312> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05789 template <> struct TagToType<0x0018,0x9313> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM3 };
static const char* GetVMString() { return "3"; }
};
05796 template <> struct TagToType<0x0018,0x9314> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05803 template <> struct TagToType<0x0018,0x9315> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05810 template <> struct TagToType<0x0018,0x9316> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05817 template <> struct TagToType<0x0018,0x9317> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
05824 template <> struct TagToType<0x0018,0x9318> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM3 };
static const char* GetVMString() { return "3"; }
};
05831 template <> struct TagToType<0x0018,0x9319> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05838 template <> struct TagToType<0x0018,0x9320> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05845 template <> struct TagToType<0x0018,0x9321> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05852 template <> struct TagToType<0x0018,0x9322> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
05859 template <> struct TagToType<0x0018,0x9323> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05866 template <> struct TagToType<0x0018,0x9324> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05873 template <> struct TagToType<0x0018,0x9325> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05880 template <> struct TagToType<0x0018,0x9326> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05887 template <> struct TagToType<0x0018,0x9327> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05894 template <> struct TagToType<0x0018,0x9328> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05901 template <> struct TagToType<0x0018,0x9329> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05908 template <> struct TagToType<0x0018,0x9330> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05915 template <> struct TagToType<0x0018,0x9332> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05922 template <> struct TagToType<0x0018,0x9333> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05929 template <> struct TagToType<0x0018,0x9334> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05936 template <> struct TagToType<0x0018,0x9335> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05943 template <> struct TagToType<0x0018,0x9337> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05950 template <> struct TagToType<0x0018,0x9338> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05957 template <> struct TagToType<0x0018,0x9340> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05964 template <> struct TagToType<0x0018,0x9341> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05971 template <> struct TagToType<0x0018,0x9342> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05978 template <> struct TagToType<0x0018,0x9343> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05985 template <> struct TagToType<0x0018,0x9344> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05992 template <> struct TagToType<0x0018,0x9345> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
05999 template <> struct TagToType<0x0018,0x9346> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06006 template <> struct TagToType<0x0018,0x9351> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06013 template <> struct TagToType<0x0018,0x9352> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM3 };
static const char* GetVMString() { return "3"; }
};
06020 template <> struct TagToType<0x0018,0x9353> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06027 template <> struct TagToType<0x0018,0x9360> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06034 template <> struct TagToType<0x0018,0x9401> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06041 template <> struct TagToType<0x0018,0x9402> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06048 template <> struct TagToType<0x0018,0x9403> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06055 template <> struct TagToType<0x0018,0x9404> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
06062 template <> struct TagToType<0x0018,0x9405> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06069 template <> struct TagToType<0x0018,0x9406> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06076 template <> struct TagToType<0x0018,0x9407> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06083 template <> struct TagToType<0x0018,0x9412> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06090 template <> struct TagToType<0x0018,0x9417> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06097 template <> struct TagToType<0x0018,0x9420> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06104 template <> struct TagToType<0x0018,0x9423> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06111 template <> struct TagToType<0x0018,0x9424> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
enum { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06118 template <> struct TagToType<0x0018,0x9425> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06125 template <> struct TagToType<0x0018,0x9426> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06132 template <> struct TagToType<0x0018,0x9427> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06139 template <> struct TagToType<0x0018,0x9428> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
06146 template <> struct TagToType<0x0018,0x9429> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
06153 template <> struct TagToType<0x0018,0x9430> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
06160 template <> struct TagToType<0x0018,0x9432> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06167 template <> struct TagToType<0x0018,0x9433> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06174 template <> struct TagToType<0x0018,0x9434> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06181 template <> struct TagToType<0x0018,0x9435> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06188 template <> struct TagToType<0x0018,0x9436> {
static const char* GetVRString() { return "SS"; }
typedef VRToType<VR::SS>::Type Type;
enum { VRType = VR::SS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06195 template <> struct TagToType<0x0018,0x9437> {
static const char* GetVRString() { return "SS"; }
typedef VRToType<VR::SS>::Type Type;
enum { VRType = VR::SS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06202 template <> struct TagToType<0x0018,0x9438> {
static const char* GetVRString() { return "SS"; }
typedef VRToType<VR::SS>::Type Type;
enum { VRType = VR::SS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06209 template <> struct TagToType<0x0018,0x9439> {
static const char* GetVRString() { return "SS"; }
typedef VRToType<VR::SS>::Type Type;
enum { VRType = VR::SS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06216 template <> struct TagToType<0x0018,0x9440> {
static const char* GetVRString() { return "SS"; }
typedef VRToType<VR::SS>::Type Type;
enum { VRType = VR::SS };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
06223 template <> struct TagToType<0x0018,0x9441> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06230 template <> struct TagToType<0x0018,0x9442> {
static const char* GetVRString() { return "SS"; }
typedef VRToType<VR::SS>::Type Type;
enum { VRType = VR::SS };
enum { VMType = VM::VM2_n };
static const char* GetVMString() { return "2-n"; }
};
06237 template <> struct TagToType<0x0018,0x9447> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06244 template <> struct TagToType<0x0018,0x9449> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06251 template <> struct TagToType<0x0018,0x9451> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06258 template <> struct TagToType<0x0018,0x9452> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06265 template <> struct TagToType<0x0018,0x9455> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06272 template <> struct TagToType<0x0018,0x9456> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06279 template <> struct TagToType<0x0018,0x9457> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06286 template <> struct TagToType<0x0018,0x9461> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1_2 };
static const char* GetVMString() { return "1-2"; }
};
06293 template <> struct TagToType<0x0018,0x9462> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06300 template <> struct TagToType<0x0018,0x9463> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06307 template <> struct TagToType<0x0018,0x9464> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06314 template <> struct TagToType<0x0018,0x9465> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06321 template <> struct TagToType<0x0018,0x9466> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06328 template <> struct TagToType<0x0018,0x9467> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06335 template <> struct TagToType<0x0018,0x9468> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06342 template <> struct TagToType<0x0018,0x9469> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06349 template <> struct TagToType<0x0018,0x9470> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06356 template <> struct TagToType<0x0018,0x9471> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06363 template <> struct TagToType<0x0018,0x9472> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06370 template <> struct TagToType<0x0018,0x9473> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06377 template <> struct TagToType<0x0018,0x9474> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06384 template <> struct TagToType<0x0018,0x9476> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06391 template <> struct TagToType<0x0018,0x9477> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06398 template <> struct TagToType<0x0018,0x9504> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06405 template <> struct TagToType<0x0018,0x9506> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06412 template <> struct TagToType<0x0018,0x9507> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06419 template <> struct TagToType<0x0018,0x9508> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06426 template <> struct TagToType<0x0018,0x9509> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06433 template <> struct TagToType<0x0018,0x9510> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06440 template <> struct TagToType<0x0018,0x9511> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06447 template <> struct TagToType<0x0018,0x9514> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06454 template <> struct TagToType<0x0018,0x9515> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06461 template <> struct TagToType<0x0018,0x9516> {
static const char* GetVRString() { return "DT"; }
typedef VRToType<VR::DT>::Type Type;
enum { VRType = VR::DT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06468 template <> struct TagToType<0x0018,0x9517> {
static const char* GetVRString() { return "DT"; }
typedef VRToType<VR::DT>::Type Type;
enum { VRType = VR::DT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06475 template <> struct TagToType<0x0018,0x9524> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06482 template <> struct TagToType<0x0018,0x9525> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06489 template <> struct TagToType<0x0018,0x9526> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06496 template <> struct TagToType<0x0018,0x9527> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06503 template <> struct TagToType<0x0018,0x9528> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06510 template <> struct TagToType<0x0018,0x9530> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06517 template <> struct TagToType<0x0018,0x9531> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06524 template <> struct TagToType<0x0018,0x9538> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06531 template <> struct TagToType<0x0018,0x9601> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06538 template <> struct TagToType<0x0018,0x9602> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06545 template <> struct TagToType<0x0018,0x9603> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06552 template <> struct TagToType<0x0018,0x9604> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06559 template <> struct TagToType<0x0018,0x9605> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06566 template <> struct TagToType<0x0018,0x9606> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06573 template <> struct TagToType<0x0018,0x9607> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06580 template <> struct TagToType<0x0018,0x9701> {
static const char* GetVRString() { return "DT"; }
typedef VRToType<VR::DT>::Type Type;
enum { VRType = VR::DT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06587 template <> struct TagToType<0x0018,0x9715> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06594 template <> struct TagToType<0x0018,0x9716> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06601 template <> struct TagToType<0x0018,0x9717> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06608 template <> struct TagToType<0x0018,0x9718> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06615 template <> struct TagToType<0x0018,0x9719> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06622 template <> struct TagToType<0x0018,0x9720> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06629 template <> struct TagToType<0x0018,0x9721> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06636 template <> struct TagToType<0x0018,0x9722> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06643 template <> struct TagToType<0x0018,0x9723> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06650 template <> struct TagToType<0x0018,0x9724> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06657 template <> struct TagToType<0x0018,0x9725> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06664 template <> struct TagToType<0x0018,0x9726> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06671 template <> struct TagToType<0x0018,0x9727> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06678 template <> struct TagToType<0x0018,0x9729> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06685 template <> struct TagToType<0x0018,0x9732> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06692 template <> struct TagToType<0x0018,0x9733> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06699 template <> struct TagToType<0x0018,0x9734> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06706 template <> struct TagToType<0x0018,0x9735> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06713 template <> struct TagToType<0x0018,0x9736> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06720 template <> struct TagToType<0x0018,0x9737> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06727 template <> struct TagToType<0x0018,0x9738> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06734 template <> struct TagToType<0x0018,0x9739> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06741 template <> struct TagToType<0x0018,0x9740> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06748 template <> struct TagToType<0x0018,0x9749> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06755 template <> struct TagToType<0x0018,0x9751> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06762 template <> struct TagToType<0x0018,0x9755> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06769 template <> struct TagToType<0x0018,0x9756> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06776 template <> struct TagToType<0x0018,0x9758> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06783 template <> struct TagToType<0x0018,0x9759> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06790 template <> struct TagToType<0x0018,0x9760> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06797 template <> struct TagToType<0x0018,0x9761> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06804 template <> struct TagToType<0x0018,0x9762> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06811 template <> struct TagToType<0x0018,0x9763> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06818 template <> struct TagToType<0x0018,0x9764> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06825 template <> struct TagToType<0x0018,0x9765> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06832 template <> struct TagToType<0x0018,0x9766> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06839 template <> struct TagToType<0x0018,0x9767> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06846 template <> struct TagToType<0x0018,0x9768> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06853 template <> struct TagToType<0x0018,0x9769> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06860 template <> struct TagToType<0x0018,0x9770> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06867 template <> struct TagToType<0x0018,0x9771> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06874 template <> struct TagToType<0x0018,0x9772> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06881 template <> struct TagToType<0x0018,0x9801> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
06888 template <> struct TagToType<0x0018,0x9803> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06895 template <> struct TagToType<0x0018,0x9804> {
static const char* GetVRString() { return "DT"; }
typedef VRToType<VR::DT>::Type Type;
enum { VRType = VR::DT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06902 template <> struct TagToType<0x0018,0x9805> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06909 template <> struct TagToType<0x0018,0x9806> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06916 template <> struct TagToType<0x0018,0x9807> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06923 template <> struct TagToType<0x0018,0x9808> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06930 template <> struct TagToType<0x0018,0x9809> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06937 template <> struct TagToType<0x0018,0x980b> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06944 template <> struct TagToType<0x0018,0x980c> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06951 template <> struct TagToType<0x0018,0x980d> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06958 template <> struct TagToType<0x0018,0x980e> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06965 template <> struct TagToType<0x0018,0x980f> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06972 template <> struct TagToType<0x0018,0xa001> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06979 template <> struct TagToType<0x0018,0xa002> {
static const char* GetVRString() { return "DT"; }
typedef VRToType<VR::DT>::Type Type;
enum { VRType = VR::DT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06986 template <> struct TagToType<0x0018,0xa003> {
static const char* GetVRString() { return "ST"; }
typedef VRToType<VR::ST>::Type Type;
enum { VRType = VR::ST };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
06993 template <> struct TagToType<0x0020,0x000d> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07000 template <> struct TagToType<0x0020,0x000e> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07007 template <> struct TagToType<0x0020,0x0010> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07014 template <> struct TagToType<0x0020,0x0011> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07021 template <> struct TagToType<0x0020,0x0012> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07028 template <> struct TagToType<0x0020,0x0013> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07035 template <> struct TagToType<0x0020,0x0014> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07042 template <> struct TagToType<0x0020,0x0015> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07049 template <> struct TagToType<0x0020,0x0016> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07056 template <> struct TagToType<0x0020,0x0017> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07063 template <> struct TagToType<0x0020,0x0018> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07070 template <> struct TagToType<0x0020,0x0019> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07077 template <> struct TagToType<0x0020,0x0020> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
07084 template <> struct TagToType<0x0020,0x0022> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07091 template <> struct TagToType<0x0020,0x0024> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07098 template <> struct TagToType<0x0020,0x0026> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07105 template <> struct TagToType<0x0020,0x0030> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM3 };
static const char* GetVMString() { return "3"; }
};
07112 template <> struct TagToType<0x0020,0x0032> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM3 };
static const char* GetVMString() { return "3"; }
};
07119 template <> struct TagToType<0x0020,0x0035> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM6 };
static const char* GetVMString() { return "6"; }
};
07126 template <> struct TagToType<0x0020,0x0037> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM6 };
static const char* GetVMString() { return "6"; }
};
07133 template <> struct TagToType<0x0020,0x0050> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07140 template <> struct TagToType<0x0020,0x0052> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07147 template <> struct TagToType<0x0020,0x0060> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07154 template <> struct TagToType<0x0020,0x0062> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07161 template <> struct TagToType<0x0020,0x0070> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07168 template <> struct TagToType<0x0020,0x0080> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
07175 template <> struct TagToType<0x0020,0x0100> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07182 template <> struct TagToType<0x0020,0x0105> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07189 template <> struct TagToType<0x0020,0x0110> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07196 template <> struct TagToType<0x0020,0x0200> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07203 template <> struct TagToType<0x0020,0x0242> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07210 template <> struct TagToType<0x0020,0x1000> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07217 template <> struct TagToType<0x0020,0x1001> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07224 template <> struct TagToType<0x0020,0x1002> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07231 template <> struct TagToType<0x0020,0x1003> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07238 template <> struct TagToType<0x0020,0x1004> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07245 template <> struct TagToType<0x0020,0x1005> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07252 template <> struct TagToType<0x0020,0x1020> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
07259 template <> struct TagToType<0x0020,0x1040> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07266 template <> struct TagToType<0x0020,0x1041> {
static const char* GetVRString() { return "DS"; }
typedef VRToType<VR::DS>::Type Type;
enum { VRType = VR::DS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07273 template <> struct TagToType<0x0020,0x1070> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
07280 template <> struct TagToType<0x0020,0x1200> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07287 template <> struct TagToType<0x0020,0x1202> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07294 template <> struct TagToType<0x0020,0x1204> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07301 template <> struct TagToType<0x0020,0x1206> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07308 template <> struct TagToType<0x0020,0x1208> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07315 template <> struct TagToType<0x0020,0x1209> {
static const char* GetVRString() { return "IS"; }
typedef VRToType<VR::IS>::Type Type;
enum { VRType = VR::IS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07322 template <> struct TagToType<0x0020,0x3401> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07329 template <> struct TagToType<0x0020,0x3402> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07336 template <> struct TagToType<0x0020,0x3403> {
static const char* GetVRString() { return "DA"; }
typedef VRToType<VR::DA>::Type Type;
enum { VRType = VR::DA };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07343 template <> struct TagToType<0x0020,0x3404> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07350 template <> struct TagToType<0x0020,0x3405> {
static const char* GetVRString() { return "TM"; }
typedef VRToType<VR::TM>::Type Type;
enum { VRType = VR::TM };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07357 template <> struct TagToType<0x0020,0x3406> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07364 template <> struct TagToType<0x0020,0x4000> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
enum { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07371 template <> struct TagToType<0x0020,0x5000> {
static const char* GetVRString() { return "AT"; }
typedef VRToType<VR::AT>::Type Type;
enum { VRType = VR::AT };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
07378 template <> struct TagToType<0x0020,0x5002> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
07385 template <> struct TagToType<0x0020,0x9056> {
static const char* GetVRString() { return "SH"; }
typedef VRToType<VR::SH>::Type Type;
enum { VRType = VR::SH };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07392 template <> struct TagToType<0x0020,0x9057> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07399 template <> struct TagToType<0x0020,0x9071> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07406 template <> struct TagToType<0x0020,0x9072> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07413 template <> struct TagToType<0x0020,0x9111> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07420 template <> struct TagToType<0x0020,0x9113> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07427 template <> struct TagToType<0x0020,0x9116> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07434 template <> struct TagToType<0x0020,0x9128> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07441 template <> struct TagToType<0x0020,0x9153> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07448 template <> struct TagToType<0x0020,0x9156> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07455 template <> struct TagToType<0x0020,0x9157> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
07462 template <> struct TagToType<0x0020,0x9158> {
static const char* GetVRString() { return "LT"; }
typedef VRToType<VR::LT>::Type Type;
enum { VRType = VR::LT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07469 template <> struct TagToType<0x0020,0x9161> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07476 template <> struct TagToType<0x0020,0x9162> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07483 template <> struct TagToType<0x0020,0x9163> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07490 template <> struct TagToType<0x0020,0x9164> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07497 template <> struct TagToType<0x0020,0x9165> {
static const char* GetVRString() { return "AT"; }
typedef VRToType<VR::AT>::Type Type;
enum { VRType = VR::AT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07504 template <> struct TagToType<0x0020,0x9167> {
static const char* GetVRString() { return "AT"; }
typedef VRToType<VR::AT>::Type Type;
enum { VRType = VR::AT };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07511 template <> struct TagToType<0x0020,0x9213> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07518 template <> struct TagToType<0x0020,0x9221> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07525 template <> struct TagToType<0x0020,0x9222> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07532 template <> struct TagToType<0x0020,0x9228> {
static const char* GetVRString() { return "UL"; }
typedef VRToType<VR::UL>::Type Type;
enum { VRType = VR::UL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07539 template <> struct TagToType<0x0020,0x9238> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07546 template <> struct TagToType<0x0020,0x9241> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07553 template <> struct TagToType<0x0020,0x9245> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07560 template <> struct TagToType<0x0020,0x9246> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07567 template <> struct TagToType<0x0020,0x9247> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07574 template <> struct TagToType<0x0020,0x9248> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07581 template <> struct TagToType<0x0020,0x9249> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07588 template <> struct TagToType<0x0020,0x9250> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07595 template <> struct TagToType<0x0020,0x9251> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07602 template <> struct TagToType<0x0020,0x9252> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07609 template <> struct TagToType<0x0020,0x9253> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07616 template <> struct TagToType<0x0020,0x9254> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07623 template <> struct TagToType<0x0020,0x9255> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07630 template <> struct TagToType<0x0020,0x9256> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07637 template <> struct TagToType<0x0020,0x9257> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07644 template <> struct TagToType<0x0020,0x9301> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM3 };
static const char* GetVMString() { return "3"; }
};
07651 template <> struct TagToType<0x0020,0x9302> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM6 };
static const char* GetVMString() { return "6"; }
};
07658 template <> struct TagToType<0x0020,0x9307> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07665 template <> struct TagToType<0x0020,0x9308> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM3 };
static const char* GetVMString() { return "3"; }
};
07672 template <> struct TagToType<0x0020,0x9309> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM16 };
static const char* GetVMString() { return "16"; }
};
07679 template <> struct TagToType<0x0020,0x930a> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM16 };
static const char* GetVMString() { return "16"; }
};
07686 template <> struct TagToType<0x0020,0x930c> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07693 template <> struct TagToType<0x0020,0x930d> {
static const char* GetVRString() { return "FD"; }
typedef VRToType<VR::FD>::Type Type;
enum { VRType = VR::FD };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07700 template <> struct TagToType<0x0020,0x930e> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07707 template <> struct TagToType<0x0020,0x930f> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07714 template <> struct TagToType<0x0020,0x9310> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07721 template <> struct TagToType<0x0020,0x9311> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07728 template <> struct TagToType<0x0020,0x9312> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07735 template <> struct TagToType<0x0020,0x9313> {
static const char* GetVRString() { return "UI"; }
typedef VRToType<VR::UI>::Type Type;
enum { VRType = VR::UI };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07742 template <> struct TagToType<0x0020,0x9421> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07749 template <> struct TagToType<0x0020,0x9450> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07756 template <> struct TagToType<0x0020,0x9453> {
static const char* GetVRString() { return "LO"; }
typedef VRToType<VR::LO>::Type Type;
enum { VRType = VR::LO };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07763 template <> struct TagToType<0x0020,0x9518> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1_n };
static const char* GetVMString() { return "1-n"; }
};
07770 template <> struct TagToType<0x0020,0x9529> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07777 template <> struct TagToType<0x0020,0x9536> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07784 template <> struct TagToType<0x0022,0x0001> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07791 template <> struct TagToType<0x0022,0x0002> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
07798 template <> struct TagToType<0x0022,0x0003> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07805 template <> struct TagToType<0x0022,0x0004> {
static const char* GetVRString() { return "US"; }
typedef VRToType<VR::US>::Type Type;
enum { VRType = VR::US };
enum { VMType = VM::VM2 };
static const char* GetVMString() { return "2"; }
};
07812 template <> struct TagToType<0x0022,0x0005> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07819 template <> struct TagToType<0x0022,0x0006> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07826 template <> struct TagToType<0x0022,0x0007> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07833 template <> struct TagToType<0x0022,0x0008> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07840 template <> struct TagToType<0x0022,0x0009> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07847 template <> struct TagToType<0x0022,0x000a> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07854 template <> struct TagToType<0x0022,0x000b> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07861 template <> struct TagToType<0x0022,0x000c> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07868 template <> struct TagToType<0x0022,0x000d> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07875 template <> struct TagToType<0x0022,0x000e> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07882 template <> struct TagToType<0x0022,0x0010> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07889 template <> struct TagToType<0x0022,0x0011> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07896 template <> struct TagToType<0x0022,0x0012> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07903 template <> struct TagToType<0x0022,0x0013> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07910 template <> struct TagToType<0x0022,0x0014> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07917 template <> struct TagToType<0x0022,0x0015> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07924 template <> struct TagToType<0x0022,0x0016> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07931 template <> struct TagToType<0x0022,0x0017> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07938 template <> struct TagToType<0x0022,0x0018> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07945 template <> struct TagToType<0x0022,0x0019> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07952 template <> struct TagToType<0x0022,0x001a> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07959 template <> struct TagToType<0x0022,0x001b> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07966 template <> struct TagToType<0x0022,0x001c> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07973 template <> struct TagToType<0x0022,0x001d> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07980 template <> struct TagToType<0x0022,0x0020> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07987 template <> struct TagToType<0x0022,0x0021> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
07994 template <> struct TagToType<0x0022,0x0022> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
08001 template <> struct TagToType<0x0022,0x0030> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
08008 template <> struct TagToType<0x0022,0x0031> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
08015 template <> struct TagToType<0x0022,0x0032> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM2_2n };
static const char* GetVMString() { return "2-2n"; }
};
08022 template <> struct TagToType<0x0022,0x0035> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
08029 template <> struct TagToType<0x0022,0x0036> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
08036 template <> struct TagToType<0x0022,0x0037> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
08043 template <> struct TagToType<0x0022,0x0038> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
08050 template <> struct TagToType<0x0022,0x0039> {
static const char* GetVRString() { return "CS"; }
typedef VRToType<VR::CS>::Type Type;
enum { VRType = VR::CS };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
08057 template <> struct TagToType<0x0022,0x0041> {
static const char* GetVRString() { return "FL"; }
typedef VRToType<VR::FL>::Type Type;
enum { VRType = VR::FL };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
08064 template <> struct TagToType<0x0022,0x0042> {
static const char* GetVRString() { return "SQ"; }
typedef VRToType<VR::SQ>::Type Type;
enum { VRType = VR::SQ };
enum { VMType = VM::VM1 };
static const char* GetVMString() { return "1"; }
};
08071 template <> struct TagToType<0x0022,0x0048> {
static