[Gdcm-hackers] gdcm-git:Grassroots DICOM branch master updated. a1ea33e467a4a065d844327d7a6bd8b1e9ef4c1d

[Mathieu M. <ma...@us...>]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Grassroots DICOM".

The branch, master has been updated
       via  a1ea33e467a4a065d844327d7a6bd8b1e9ef4c1d (commit)
      from  b83745f9fe969d16382533303a94eae3b5020a74 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
https://sourceforge.net/p/gdcm/gdcm/ci/a1ea33e467a4a065d844327d7a6bd8b1e9ef4c1d/

commit a1ea33e467a4a065d844327d7a6bd8b1e9ef4c1d
Author: Mathieu Malaterre <mat...@gm...>
Date:   Thu Apr 25 13:00:17 2019 +0200

    Update xslt script to handle recent changes
    
    Need to update xsl to handle long long and also new Vr: US_OW.
    
    Run the script to generate new elements.

diff --git a/Source/DataDictionary/TagToType.xsl b/Source/DataDictionary/TagToType.xsl
index b82d9a1a2..1f248c7ee 100644
--- a/Source/DataDictionary/TagToType.xsl
+++ b/Source/DataDictionary/TagToType.xsl
@@ -47,14 +47,14 @@ namespace gdcm {
 // default template: the compiler should only pick it up when the element is private:
 template &lt;uint16_t group,uint16_t element&gt; struct TagToType {
 //GDCM_STATIC_ASSERT( group % 2 );
-enum { VRType = VR::VRALL };
+enum : long long { VRType = VR::VRALL };
 enum { VMType = VM::VM1_n };
 };
 // template for group length:
 template &lt;uint16_t group&gt; struct TagToType&lt;group,0x0000&gt; {
 static const char* GetVRString() { return "UL"; }
 typedef VRToType&lt;VR::UL&gt;::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
@@ -64,7 +64,7 @@ static const char* GetVMString() { return "1"; }
       <xsl:sort select="@element" data-type="text" order="ascending"/>
       <xsl:variable name="group" select="translate(@group,'x','0')"/>
       <xsl:variable name="element" select="translate(@element,'x','0')"/>
-      <xsl:if test="contains(@element,'x') = true and contains(@element,'xx') = false and @vr != '' and @vr != 'US_SS' and @vr != 'US_SS_OW' and @vr != 'OB_OW'">
+      <xsl:if test="contains(@element,'x') = true and contains(@element,'xx') = false and @vr != '' and @vr != 'US_OW' and @vr != 'US_SS' and @vr != 'US_SS_OW' and @vr != 'OB_OW'">
 <xsl:variable name="classname">
         <xsl:text>TagToType&lt;0x</xsl:text>
         <xsl:value-of select="$group"/>
@@ -85,7 +85,7 @@ static const char* GetVMString() { return "1"; }
         <xsl:text>&gt;::Type Type;</xsl:text>
         <xsl:text>
 </xsl:text>
-        <xsl:text>enum { VRType = VR::</xsl:text>
+        <xsl:text>enum : long long { VRType = VR::</xsl:text>
         <xsl:value-of select="@vr"/>
         <xsl:text> };</xsl:text>
         <xsl:text>
diff --git a/Source/DataDictionary/gdcmTagToType.h b/Source/DataDictionary/gdcmTagToType.h
index 4a416c426..39de60773 100644
--- a/Source/DataDictionary/gdcmTagToType.h
+++ b/Source/DataDictionary/gdcmTagToType.h
@@ -416,6 +416,20 @@ enum : long long { VRType = VR::AE };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0002,0x0017> {
+static const char* GetVRString() { return "AE"; }
+typedef VRToType<VR::AE>::Type Type;
+enum : long long { VRType = VR::AE };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0002,0x0018> {
+static const char* GetVRString() { return "AE"; }
+typedef VRToType<VR::AE>::Type Type;
+enum : long long { VRType = VR::AE };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0002,0x0100> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
@@ -619,6 +633,13 @@ enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0008,0x0015> {
+static const char* GetVRString() { return "DT"; }
+typedef VRToType<VR::DT>::Type Type;
+enum : long long { VRType = VR::DT };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0008,0x0016> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
@@ -780,6 +801,13 @@ enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0008,0x0053> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0008,0x0054> {
 static const char* GetVRString() { return "AE"; }
 typedef VRToType<VR::AE>::Type Type;
@@ -787,6 +815,13 @@ enum : long long { VRType = VR::AE };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
+template <> struct TagToType<0x0008,0x0055> {
+static const char* GetVRString() { return "AE"; }
+typedef VRToType<VR::AE>::Type Type;
+enum : long long { VRType = VR::AE };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0008,0x0056> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
@@ -892,6 +927,20 @@ enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0008,0x009c> {
+static const char* GetVRString() { return "PN"; }
+typedef VRToType<VR::PN>::Type Type;
+enum : long long { VRType = VR::PN };
+enum { VMType = VM::VM1_n };
+static const char* GetVMString() { return "1-n"; }
+};
+template <> struct TagToType<0x0008,0x009d> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0008,0x0100> {
 static const char* GetVRString() { return "SH"; }
 typedef VRToType<VR::SH>::Type Type;
@@ -899,6 +948,13 @@ enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0008,0x0101> {
+static const char* GetVRString() { return "LO"; }
+typedef VRToType<VR::LO>::Type Type;
+enum : long long { VRType = VR::LO };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0008,0x0102> {
 static const char* GetVRString() { return "SH"; }
 typedef VRToType<VR::SH>::Type Type;
@@ -941,6 +997,13 @@ enum : long long { VRType = VR::DT };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0008,0x0108> {
+static const char* GetVRString() { return "LT"; }
+typedef VRToType<VR::LT>::Type Type;
+enum : long long { VRType = VR::LT };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0008,0x010b> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
@@ -1011,6 +1074,55 @@ enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0008,0x0118> {
+static const char* GetVRString() { return "UI"; }
+typedef VRToType<VR::UI>::Type Type;
+enum : long long { VRType = VR::UI };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0119> {
+static const char* GetVRString() { return "UC"; }
+typedef VRToType<VR::UC>::Type Type;
+enum : long long { VRType = VR::UC };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0120> {
+static const char* GetVRString() { return "UR"; }
+typedef VRToType<VR::UR>::Type Type;
+enum : long long { VRType = VR::UR };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0121> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0122> {
+static const char* GetVRString() { return "LO"; }
+typedef VRToType<VR::LO>::Type Type;
+enum : long long { VRType = VR::LO };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0123> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0124> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0008,0x0201> {
 static const char* GetVRString() { return "SH"; }
 typedef VRToType<VR::SH>::Type Type;
@@ -1018,6 +1130,146 @@ enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0008,0x0220> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0221> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0222> {
+static const char* GetVRString() { return "LO"; }
+typedef VRToType<VR::LO>::Type Type;
+enum : long long { VRType = VR::LO };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0300> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0301> {
+static const char* GetVRString() { return "US"; }
+typedef VRToType<VR::US>::Type Type;
+enum : long long { VRType = VR::US };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0302> {
+static const char* GetVRString() { return "LO"; }
+typedef VRToType<VR::LO>::Type Type;
+enum : long long { VRType = VR::LO };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0303> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0304> {
+static const char* GetVRString() { return "US"; }
+typedef VRToType<VR::US>::Type Type;
+enum : long long { VRType = VR::US };
+enum { VMType = VM::VM1_n };
+static const char* GetVMString() { return "1-n"; }
+};
+template <> struct TagToType<0x0008,0x0305> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0306> {
+static const char* GetVRString() { return "US"; }
+typedef VRToType<VR::US>::Type Type;
+enum : long long { VRType = VR::US };
+enum { VMType = VM::VM1_n };
+static const char* GetVMString() { return "1-n"; }
+};
+template <> struct TagToType<0x0008,0x0307> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0308> {
+static const char* GetVRString() { return "US"; }
+typedef VRToType<VR::US>::Type Type;
+enum : long long { VRType = VR::US };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0309> {
+static const char* GetVRString() { return "UL"; }
+typedef VRToType<VR::UL>::Type Type;
+enum : long long { VRType = VR::UL };
+enum { VMType = VM::VM1_3 };
+static const char* GetVMString() { return "1-3"; }
+};
+template <> struct TagToType<0x0008,0x030a> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x030b> {
+static const char* GetVRString() { return "UL"; }
+typedef VRToType<VR::UL>::Type Type;
+enum : long long { VRType = VR::UL };
+enum { VMType = VM::VM1_2 };
+static const char* GetVMString() { return "1-2"; }
+};
+template <> struct TagToType<0x0008,0x030c> {
+static const char* GetVRString() { return "UC"; }
+typedef VRToType<VR::UC>::Type Type;
+enum : long long { VRType = VR::UC };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x030d> {
+static const char* GetVRString() { return "UC"; }
+typedef VRToType<VR::UC>::Type Type;
+enum : long long { VRType = VR::UC };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x030e> {
+static const char* GetVRString() { return "UT"; }
+typedef VRToType<VR::UT>::Type Type;
+enum : long long { VRType = VR::UT };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x030f> {
+static const char* GetVRString() { return "UT"; }
+typedef VRToType<VR::UT>::Type Type;
+enum : long long { VRType = VR::UT };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x0310> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0008,0x1000> {
 static const char* GetVRString() { return "AE"; }
 typedef VRToType<VR::AE>::Type Type;
@@ -1298,6 +1550,13 @@ enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0008,0x1190> {
+static const char* GetVRString() { return "UR"; }
+typedef VRToType<VR::UR>::Type Type;
+enum : long long { VRType = VR::UR };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0008,0x1195> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
@@ -1305,6 +1564,13 @@ enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0008,0x1196> {
+static const char* GetVRString() { return "US"; }
+typedef VRToType<VR::US>::Type Type;
+enum : long long { VRType = VR::US };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0008,0x1197> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
@@ -1326,6 +1592,13 @@ enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0008,0x119a> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0008,0x1200> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
@@ -1624,6 +1897,20 @@ template <> struct TagToType<0x0008,0x3010> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
 enum : long long { VRType = VR::UI };
+enum { VMType = VM::VM1_n };
+static const char* GetVMString() { return "1-n"; }
+};
+template <> struct TagToType<0x0008,0x3011> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0008,0x3012> {
+static const char* GetVRString() { return "UI"; }
+typedef VRToType<VR::UI>::Type Type;
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
@@ -1788,6 +2075,27 @@ enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0010,0x0026> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x0027> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x0028> {
+static const char* GetVRString() { return "US"; }
+typedef VRToType<VR::US>::Type Type;
+enum : long long { VRType = VR::US };
+enum { VMType = VM::VM3 };
+static const char* GetVMString() { return "3"; }
+};
 template <> struct TagToType<0x0010,0x0030> {
 static const char* GetVRString() { return "DA"; }
 typedef VRToType<VR::DA>::Type Type;
@@ -1802,10 +2110,31 @@ enum : long long { VRType = VR::TM };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0010,0x0040> {
-static const char* GetVRString() { return "CS"; }
-typedef VRToType<VR::CS>::Type Type;
-enum : long long { VRType = VR::CS };
+template <> struct TagToType<0x0010,0x0033> {
+static const char* GetVRString() { return "LO"; }
+typedef VRToType<VR::LO>::Type Type;
+enum : long long { VRType = VR::LO };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x0034> {
+static const char* GetVRString() { return "LO"; }
+typedef VRToType<VR::LO>::Type Type;
+enum : long long { VRType = VR::LO };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x0035> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x0040> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
@@ -1830,6 +2159,76 @@ enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0010,0x0200> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x0201> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x0212> {
+static const char* GetVRString() { return "UC"; }
+typedef VRToType<VR::UC>::Type Type;
+enum : long long { VRType = VR::UC };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x0213> {
+static const char* GetVRString() { return "LO"; }
+typedef VRToType<VR::LO>::Type Type;
+enum : long long { VRType = VR::LO };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x0214> {
+static const char* GetVRString() { return "LO"; }
+typedef VRToType<VR::LO>::Type Type;
+enum : long long { VRType = VR::LO };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x0215> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x0216> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x0217> {
+static const char* GetVRString() { return "LO"; }
+typedef VRToType<VR::LO>::Type Type;
+enum : long long { VRType = VR::LO };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x0218> {
+static const char* GetVRString() { return "UT"; }
+typedef VRToType<VR::UT>::Type Type;
+enum : long long { VRType = VR::UT };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x0219> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0010,0x1000> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
@@ -1879,6 +2278,27 @@ enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0010,0x1022> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x1023> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0010,0x1024> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0010,0x1030> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
@@ -1928,6 +2348,13 @@ enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0010,0x1100> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0010,0x2000> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
@@ -1963,6 +2390,13 @@ enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
+template <> struct TagToType<0x0010,0x2155> {
+static const char* GetVRString() { return "LT"; }
+typedef VRToType<VR::LT>::Type Type;
+enum : long long { VRType = VR::LT };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0010,0x2160> {
 static const char* GetVRString() { return "SH"; }
 typedef VRToType<VR::SH>::Type Type;
@@ -2250,33 +2684,47 @@ enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0012,0x0086> {
+static const char* GetVRString() { return "DA"; }
+typedef VRToType<VR::DA>::Type Type;
+enum : long long { VRType = VR::DA };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0012,0x0087> {
+static const char* GetVRString() { return "DA"; }
+typedef VRToType<VR::DA>::Type Type;
+enum : long long { VRType = VR::DA };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0014,0x0023> {
 static const char* GetVRString() { return "ST"; }
 typedef VRToType<VR::ST>::Type Type;
 enum : long long { VRType = VR::ST };
-enum { VMType = VM::VM1_n };
-static const char* GetVMString() { return "1-n"; }
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0014,0x0024> {
 static const char* GetVRString() { return "ST"; }
 typedef VRToType<VR::ST>::Type Type;
 enum : long long { VRType = VR::ST };
-enum { VMType = VM::VM1_n };
-static const char* GetVMString() { return "1-n"; }
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0014,0x0025> {
 static const char* GetVRString() { return "ST"; }
 typedef VRToType<VR::ST>::Type Type;
 enum : long long { VRType = VR::ST };
-enum { VMType = VM::VM1_n };
-static const char* GetVMString() { return "1-n"; }
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0014,0x0028> {
 static const char* GetVRString() { return "ST"; }
 typedef VRToType<VR::ST>::Type Type;
 enum : long long { VRType = VR::ST };
-enum { VMType = VM::VM1_n };
-static const char* GetVMString() { return "1-n"; }
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0014,0x0030> {
 static const char* GetVRString() { return "DS"; }
@@ -2303,22 +2751,22 @@ template <> struct TagToType<0x0014,0x0042> {
 static const char* GetVRString() { return "ST"; }
 typedef VRToType<VR::ST>::Type Type;
 enum : long long { VRType = VR::ST };
-enum { VMType = VM::VM1_n };
-static const char* GetVMString() { return "1-n"; }
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0014,0x0044> {
 static const char* GetVRString() { return "ST"; }
 typedef VRToType<VR::ST>::Type Type;
 enum : long long { VRType = VR::ST };
-enum { VMType = VM::VM1_n };
-static const char* GetVMString() { return "1-n"; }
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0014,0x0045> {
 static const char* GetVRString() { return "ST"; }
 typedef VRToType<VR::ST>::Type Type;
 enum : long long { VRType = VR::ST };
-enum { VMType = VM::VM1_n };
-static const char* GetVMString() { return "1-n"; }
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0014,0x0046> {
 static const char* GetVRString() { return "LT"; }
@@ -2355,6 +2803,69 @@ enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0014,0x0100> {
+static const char* GetVRString() { return "LO"; }
+typedef VRToType<VR::LO>::Type Type;
+enum : long long { VRType = VR::LO };
+enum { VMType = VM::VM1_n };
+static const char* GetVMString() { return "1-n"; }
+};
+template <> struct TagToType<0x0014,0x0101> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0014,0x0102> {
+static const char* GetVRString() { return "DA"; }
+typedef VRToType<VR::DA>::Type Type;
+enum : long long { VRType = VR::DA };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0014,0x0103> {
+static const char* GetVRString() { return "TM"; }
+typedef VRToType<VR::TM>::Type Type;
+enum : long long { VRType = VR::TM };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0014,0x0104> {
+static const char* GetVRString() { return "PN"; }
+typedef VRToType<VR::PN>::Type Type;
+enum : long long { VRType = VR::PN };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0014,0x0105> {
+static const char* GetVRString() { return "ST"; }
+typedef VRToType<VR::ST>::Type Type;
+enum : long long { VRType = VR::ST };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0014,0x0106> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0014,0x0107> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
+enum { VMType = VM::VM1_n };
+static const char* GetVMString() { return "1-n"; }
+};
+template <> struct TagToType<0x0014,0x0108> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
+enum { VMType = VM::VM1_n };
+static const char* GetVMString() { return "1-n"; }
+};
 template <> struct TagToType<0x0014,0x1010> {
 static const char* GetVRString() { return "ST"; }
 typedef VRToType<VR::ST>::Type Type;
@@ -2845,6 +3356,13 @@ enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
+template <> struct TagToType<0x0014,0x401d> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
 template <> struct TagToType<0x0014,0x4020> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
@@ -3104,14388 +3622,16992 @@ enum : long long { VRType = VR::DA };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
-template <> struct TagToType<0x0014,0x5002> {
-static const char* GetVRString() { return "IS"; }
-typedef VRToType<VR::IS>::Type Type;
-enum : long long { VRType = VR::IS };
+template <> struct TagToType<0x0014,0x4080> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0014,0x5004> {
-static const char* GetVRString() { return "IS"; }
-typedef VRToType<VR::IS>::Type Type;
-enum : long long { VRType = VR::IS };
+template <> struct TagToType<0x0014,0x4081> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0010> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
+template <> struct TagToType<0x0014,0x4082> {
+static const char* GetVRString() { return "LT"; }
+typedef VRToType<VR::LT>::Type Type;
+enum : long long { VRType = VR::LT };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0012> {
+template <> struct TagToType<0x0014,0x4083> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
 enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0014> {
+template <> struct TagToType<0x0014,0x4084> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0014,0x4085> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0014,0x4086> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
 enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0015> {
-static const char* GetVRString() { return "CS"; }
-typedef VRToType<VR::CS>::Type Type;
-enum : long long { VRType = VR::CS };
+template <> struct TagToType<0x0014,0x4087> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0020> {
-static const char* GetVRString() { return "CS"; }
-typedef VRToType<VR::CS>::Type Type;
-enum : long long { VRType = VR::CS };
-enum { VMType = VM::VM1_n };
-static const char* GetVMString() { return "1-n"; }
-};
-template <> struct TagToType<0x0018,0x0021> {
-static const char* GetVRString() { return "CS"; }
-typedef VRToType<VR::CS>::Type Type;
-enum : long long { VRType = VR::CS };
-enum { VMType = VM::VM1_n };
-static const char* GetVMString() { return "1-n"; }
-};
-template <> struct TagToType<0x0018,0x0022> {
-static const char* GetVRString() { return "CS"; }
-typedef VRToType<VR::CS>::Type Type;
-enum : long long { VRType = VR::CS };
-enum { VMType = VM::VM1_n };
-static const char* GetVMString() { return "1-n"; }
-};
-template <> struct TagToType<0x0018,0x0023> {
-static const char* GetVRString() { return "CS"; }
-typedef VRToType<VR::CS>::Type Type;
-enum : long long { VRType = VR::CS };
+template <> struct TagToType<0x0014,0x4088> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0024> {
-static const char* GetVRString() { return "SH"; }
-typedef VRToType<VR::SH>::Type Type;
-enum : long long { VRType = VR::SH };
+template <> struct TagToType<0x0014,0x4089> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0025> {
-static const char* GetVRString() { return "CS"; }
-typedef VRToType<VR::CS>::Type Type;
-enum : long long { VRType = VR::CS };
+template <> struct TagToType<0x0014,0x408b> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0026> {
-static const char* GetVRString() { return "SQ"; }
-typedef VRToType<VR::SQ>::Type Type;
-enum : long long { VRType = VR::SQ };
+template <> struct TagToType<0x0014,0x408c> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0027> {
-static const char* GetVRString() { return "TM"; }
-typedef VRToType<VR::TM>::Type Type;
-enum : long long { VRType = VR::TM };
+template <> struct TagToType<0x0014,0x408d> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0028> {
+template <> struct TagToType<0x0014,0x408e> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0029> {
+template <> struct TagToType<0x0014,0x4091> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
 enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x002a> {
+template <> struct TagToType<0x0014,0x4092> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0014,0x409a> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
 enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0030> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
-enum { VMType = VM::VM1_n };
-static const char* GetVMString() { return "1-n"; }
-};
-template <> struct TagToType<0x0018,0x0031> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
+template <> struct TagToType<0x0014,0x409b> {
+static const char* GetVRString() { return "ST"; }
+typedef VRToType<VR::ST>::Type Type;
+enum : long long { VRType = VR::ST };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0032> {
+template <> struct TagToType<0x0014,0x409c> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0033> {
+template <> struct TagToType<0x0014,0x409d> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
-enum { VMType = VM::VM1_n };
-static const char* GetVMString() { return "1-n"; }
-};
-template <> struct TagToType<0x0018,0x0034> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0035> {
-static const char* GetVRString() { return "TM"; }
-typedef VRToType<VR::TM>::Type Type;
-enum : long long { VRType = VR::TM };
-enum { VMType = VM::VM1 };
-static const char* GetVMString() { return "1"; }
-};
-template <> struct TagToType<0x0018,0x0036> {
-static const char* GetVRString() { return "SQ"; }
-typedef VRToType<VR::SQ>::Type Type;
-enum : long long { VRType = VR::SQ };
+template <> struct TagToType<0x0014,0x409f> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0037> {
-static const char* GetVRString() { return "CS"; }
-typedef VRToType<VR::CS>::Type Type;
-enum : long long { VRType = VR::CS };
+template <> struct TagToType<0x0014,0x40a0> {
+static const char* GetVRString() { return "LO"; }
+typedef VRToType<VR::LO>::Type Type;
+enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0038> {
-static const char* GetVRString() { return "CS"; }
-typedef VRToType<VR::CS>::Type Type;
-enum : long long { VRType = VR::CS };
+template <> struct TagToType<0x0014,0x40a1> {
+static const char* GetVRString() { return "LO"; }
+typedef VRToType<VR::LO>::Type Type;
+enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0039> {
-static const char* GetVRString() { return "CS"; }
-typedef VRToType<VR::CS>::Type Type;
-enum : long long { VRType = VR::CS };
+template <> struct TagToType<0x0014,0x40a2> {
+static const char* GetVRString() { return "LO"; }
+typedef VRToType<VR::LO>::Type Type;
+enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x003a> {
-static const char* GetVRString() { return "ST"; }
-typedef VRToType<VR::ST>::Type Type;
-enum : long long { VRType = VR::ST };
+template <> struct TagToType<0x0014,0x5002> {
+static const char* GetVRString() { return "IS"; }
+typedef VRToType<VR::IS>::Type Type;
+enum : long long { VRType = VR::IS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0040> {
+template <> struct TagToType<0x0014,0x5004> {
 static const char* GetVRString() { return "IS"; }
 typedef VRToType<VR::IS>::Type Type;
 enum : long long { VRType = VR::IS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0042> {
-static const char* GetVRString() { return "CS"; }
-typedef VRToType<VR::CS>::Type Type;
-enum : long long { VRType = VR::CS };
+template <> struct TagToType<0x0014,0x5100> {
+static const char* GetVRString() { return "US"; }
+typedef VRToType<VR::US>::Type Type;
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0050> {
+template <> struct TagToType<0x0014,0x5101> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0060> {
+template <> struct TagToType<0x0014,0x5102> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0070> {
-static const char* GetVRString() { return "IS"; }
-typedef VRToType<VR::IS>::Type Type;
-enum : long long { VRType = VR::IS };
+template <> struct TagToType<0x0014,0x5103> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0071> {
+template <> struct TagToType<0x0014,0x5104> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0014,0x5105> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
 enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0072> {
+template <> struct TagToType<0x0014,0x5106> {
+static const char* GetVRString() { return "SH"; }
+typedef VRToType<VR::SH>::Type Type;
+enum : long long { VRType = VR::SH };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0014,0x5107> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0073> {
+template <> struct TagToType<0x0014,0x5108> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0014,0x5109> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
 enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0074> {
-static const char* GetVRString() { return "IS"; }
-typedef VRToType<VR::IS>::Type Type;
-enum : long long { VRType = VR::IS };
+template <> struct TagToType<0x0014,0x510a> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0075> {
-static const char* GetVRString() { return "IS"; }
-typedef VRToType<VR::IS>::Type Type;
-enum : long long { VRType = VR::IS };
+template <> struct TagToType<0x0014,0x510b> {
+static const char* GetVRString() { return "SH"; }
+typedef VRToType<VR::SH>::Type Type;
+enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0080> {
+template <> struct TagToType<0x0014,0x510c> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0081> {
+template <> struct TagToType<0x0014,0x510d> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0082> {
+template <> struct TagToType<0x0014,0x510e> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0083> {
+template <> struct TagToType<0x0014,0x510f> {
+static const char* GetVRString() { return "SH"; }
+typedef VRToType<VR::SH>::Type Type;
+enum : long long { VRType = VR::SH };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0014,0x5110> {
+static const char* GetVRString() { return "SH"; }
+typedef VRToType<VR::SH>::Type Type;
+enum : long long { VRType = VR::SH };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0014,0x5111> {
+static const char* GetVRString() { return "LO"; }
+typedef VRToType<VR::LO>::Type Type;
+enum : long long { VRType = VR::LO };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0014,0x5112> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0084> {
+template <> struct TagToType<0x0014,0x5113> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0085> {
-static const char* GetVRString() { return "SH"; }
-typedef VRToType<VR::SH>::Type Type;
-enum : long long { VRType = VR::SH };
+template <> struct TagToType<0x0014,0x5114> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0086> {
-static const char* GetVRString() { return "IS"; }
-typedef VRToType<VR::IS>::Type Type;
-enum : long long { VRType = VR::IS };
-enum { VMType = VM::VM1_n };
-static const char* GetVMString() { return "1-n"; }
-};
-template <> struct TagToType<0x0018,0x0087> {
+template <> struct TagToType<0x0014,0x5115> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0088> {
+template <> struct TagToType<0x0014,0x5116> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0089> {
-static const char* GetVRString() { return "IS"; }
-typedef VRToType<VR::IS>::Type Type;
-enum : long long { VRType = VR::IS };
+template <> struct TagToType<0x0014,0x5117> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0090> {
+template <> struct TagToType<0x0014,0x5118> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0091> {
-static const char* GetVRString() { return "IS"; }
-typedef VRToType<VR::IS>::Type Type;
-enum : long long { VRType = VR::IS };
+template <> struct TagToType<0x0014,0x5119> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0093> {
+template <> struct TagToType<0x0014,0x511a> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0094> {
+template <> struct TagToType<0x0014,0x511b> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x0095> {
+template <> struct TagToType<0x0014,0x511c> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
 enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1000> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
+template <> struct TagToType<0x0014,0x511d> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1002> {
-static const char* GetVRString() { return "UI"; }
-typedef VRToType<VR::UI>::Type Type;
-enum : long long { VRType = VR::UI };
+template <> struct TagToType<0x0014,0x511e> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1003> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
+template <> struct TagToType<0x0014,0x511f> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1004> {
+template <> struct TagToType<0x0018,0x0010> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
 enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1005> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
+template <> struct TagToType<0x0018,0x0012> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1006> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
+template <> struct TagToType<0x0018,0x0013> {
+static const char* GetVRString() { return "FL"; }
+typedef VRToType<VR::FL>::Type Type;
+enum : long long { VRType = VR::FL };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1007> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
+template <> struct TagToType<0x0018,0x0014> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1008> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
+template <> struct TagToType<0x0018,0x0015> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1010> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
+template <> struct TagToType<0x0018,0x0020> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
+enum { VMType = VM::VM1_n };
+static const char* GetVMString() { return "1-n"; }
+};
+template <> struct TagToType<0x0018,0x0021> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
+enum { VMType = VM::VM1_n };
+static const char* GetVMString() { return "1-n"; }
+};
+template <> struct TagToType<0x0018,0x0022> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
+enum { VMType = VM::VM1_n };
+static const char* GetVMString() { return "1-n"; }
+};
+template <> struct TagToType<0x0018,0x0023> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1011> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
+template <> struct TagToType<0x0018,0x0024> {
+static const char* GetVRString() { return "SH"; }
+typedef VRToType<VR::SH>::Type Type;
+enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1012> {
-static const char* GetVRString() { return "DA"; }
-typedef VRToType<VR::DA>::Type Type;
-enum : long long { VRType = VR::DA };
+template <> struct TagToType<0x0018,0x0025> {
+static const char* GetVRString() { return "CS"; }
+typedef VRToType<VR::CS>::Type Type;
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1014> {
+template <> struct TagToType<0x0018,0x0026> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
+};
+template <> struct TagToType<0x0018,0x0027> {
 static const char* GetVRString() { return "TM"; }
 typedef VRToType<VR::TM>::Type Type;
 enum : long long { VRType = VR::TM };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1016> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
+template <> struct TagToType<0x0018,0x0028> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1017> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
+template <> struct TagToType<0x0018,0x0029> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1018> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
+template <> struct TagToType<0x0018,0x002a> {
+static const char* GetVRString() { return "SQ"; }
+typedef VRToType<VR::SQ>::Type Type;
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1019> {
+template <> struct TagToType<0x0018,0x0030> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
 enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
-template <> struct TagToType<0x0018,0x101a> {
+template <> struct TagToType<0x0018,0x0031> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
 enum : long long { VRType = VR::LO };
-enum { VMType = VM::VM1_n };
-static const char* GetVMString() { return "1-n"; }
+enum { VMType = VM::VM1 };
+static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x101b> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Type;
-enum : long long { VRType = VR::LO };
+template <> struct TagToType<0x0018,0x0032> {
+static const char* GetVRString() { return "DS"; }
+typedef VRToType<VR::DS>::Type Type;
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
-template <> struct TagToType<0x0018,0x1020> {
-static const char* GetVRString() { return "LO"; }
-typedef VRToType<VR::LO>::Type Typ...
 
[truncated message content]