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

[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  28508b82afad3bb270428afff701f788e7ff6a6b (commit)
       via  5aeeeb180526d558b3d1efcc6a50dadcfbb2e02f (commit)
      from  a1d26a5c9edf4269176f957ffada1deec9de37ba (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/28508b82afad3bb270428afff701f788e7ff6a6b/

commit 28508b82afad3bb270428afff701f788e7ff6a6b
Author: Mihail Isakov <mih...@gm...>
Date:   Thu Apr 25 12:18:03 2019 +0200

    Set an explicit underlying type for VRType
    
    Using a sed expression for now:
    
    $ sed -i -e 's/enum { VRType/enum : long long { VRType/g'

diff --git a/Source/DataDictionary/gdcmTagToType.h b/Source/DataDictionary/gdcmTagToType.h
index 175ad8502..4a416c426 100644
--- a/Source/DataDictionary/gdcmTagToType.h
+++ b/Source/DataDictionary/gdcmTagToType.h
@@ -27,25193 +27,25193 @@ namespace gdcm {
 // default template: the compiler should only pick it up when the element is private:
 template <uint16_t group,uint16_t element> 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 <uint16_t group> struct TagToType<group,0x0000> {
 static const char* GetVRString() { return "UL"; }
 typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0000> {
 static const char* GetVRString() { return "UL"; }
 typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0001> {
 static const char* GetVRString() { return "UL"; }
 typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0002> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0003> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0010> {
 static const char* GetVRString() { return "SH"; }
 typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0100> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0110> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0120> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0200> {
 static const char* GetVRString() { return "AE"; }
 typedef VRToType<VR::AE>::Type Type;
-enum { VRType = VR::AE };
+enum : long long { VRType = VR::AE };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0300> {
 static const char* GetVRString() { return "AE"; }
 typedef VRToType<VR::AE>::Type Type;
-enum { VRType = VR::AE };
+enum : long long { VRType = VR::AE };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0400> {
 static const char* GetVRString() { return "AE"; }
 typedef VRToType<VR::AE>::Type Type;
-enum { VRType = VR::AE };
+enum : long long { VRType = VR::AE };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0600> {
 static const char* GetVRString() { return "AE"; }
 typedef VRToType<VR::AE>::Type Type;
-enum { VRType = VR::AE };
+enum : long long { VRType = VR::AE };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0700> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0800> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0850> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0860> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0900> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0901> {
 static const char* GetVRString() { return "AT"; }
 typedef VRToType<VR::AT>::Type Type;
-enum { VRType = VR::AT };
+enum : long long { VRType = VR::AT };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0000,0x0902> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x0903> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x1000> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x1001> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x1002> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x1005> {
 static const char* GetVRString() { return "AT"; }
 typedef VRToType<VR::AT>::Type Type;
-enum { VRType = VR::AT };
+enum : long long { VRType = VR::AT };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0000,0x1008> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x1020> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x1021> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x1022> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x1023> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x1030> {
 static const char* GetVRString() { return "AE"; }
 typedef VRToType<VR::AE>::Type Type;
-enum { VRType = VR::AE };
+enum : long long { VRType = VR::AE };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x1031> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x4000> {
 static const char* GetVRString() { return "LT"; }
 typedef VRToType<VR::LT>::Type Type;
-enum { VRType = VR::LT };
+enum : long long { VRType = VR::LT };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x4010> {
 static const char* GetVRString() { return "LT"; }
 typedef VRToType<VR::LT>::Type Type;
-enum { VRType = VR::LT };
+enum : long long { VRType = VR::LT };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x5010> {
 static const char* GetVRString() { return "SH"; }
 typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x5020> {
 static const char* GetVRString() { return "SH"; }
 typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x5110> {
 static const char* GetVRString() { return "LT"; }
 typedef VRToType<VR::LT>::Type Type;
-enum { VRType = VR::LT };
+enum : long long { VRType = VR::LT };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x5120> {
 static const char* GetVRString() { return "LT"; }
 typedef VRToType<VR::LT>::Type Type;
-enum { VRType = VR::LT };
+enum : long long { VRType = VR::LT };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x5130> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x5140> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x5150> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x5160> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x5170> {
 static const char* GetVRString() { return "IS"; }
 typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x5180> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x5190> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x51a0> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0000,0x51b0> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0002,0x0000> {
 static const char* GetVRString() { return "UL"; }
 typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0002,0x0001> {
 static const char* GetVRString() { return "OB"; }
 typedef VRToType<VR::OB>::Type Type;
-enum { VRType = VR::OB };
+enum : long long { VRType = VR::OB };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0002,0x0002> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0002,0x0003> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0002,0x0010> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0002,0x0012> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0002,0x0013> {
 static const char* GetVRString() { return "SH"; }
 typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0002,0x0016> {
 static const char* GetVRString() { return "AE"; }
 typedef VRToType<VR::AE>::Type Type;
-enum { VRType = VR::AE };
+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;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0002,0x0102> {
 static const char* GetVRString() { return "OB"; }
 typedef VRToType<VR::OB>::Type Type;
-enum { VRType = VR::OB };
+enum : long long { VRType = VR::OB };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x1130> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x1141> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1_8 };
 static const char* GetVMString() { return "1-8"; }
 };
 template <> struct TagToType<0x0004,0x1142> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x1200> {
 static const char* GetVRString() { return "UL"; }
 typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x1202> {
 static const char* GetVRString() { return "UL"; }
 typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x1212> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x1220> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x1400> {
 static const char* GetVRString() { return "UL"; }
 typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x1410> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x1420> {
 static const char* GetVRString() { return "UL"; }
 typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x1430> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x1432> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x1500> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1_8 };
 static const char* GetVMString() { return "1-8"; }
 };
 template <> struct TagToType<0x0004,0x1504> {
 static const char* GetVRString() { return "UL"; }
 typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x1510> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x1511> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x1512> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0004,0x151a> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0004,0x1600> {
 static const char* GetVRString() { return "UL"; }
 typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0001> {
 static const char* GetVRString() { return "UL"; }
 typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0005> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x0006> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0008> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM2_n };
 static const char* GetVMString() { return "2-n"; }
 };
 template <> struct TagToType<0x0008,0x0010> {
 static const char* GetVRString() { return "SH"; }
 typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0012> {
 static const char* GetVRString() { return "DA"; }
 typedef VRToType<VR::DA>::Type Type;
-enum { VRType = VR::DA };
+enum : long long { VRType = VR::DA };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0013> {
 static const char* GetVRString() { return "TM"; }
 typedef VRToType<VR::TM>::Type Type;
-enum { VRType = VR::TM };
+enum : long long { VRType = VR::TM };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0014> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 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;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0018> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x001a> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x001b> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0020> {
 static const char* GetVRString() { return "DA"; }
 typedef VRToType<VR::DA>::Type Type;
-enum { VRType = VR::DA };
+enum : long long { VRType = VR::DA };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0021> {
 static const char* GetVRString() { return "DA"; }
 typedef VRToType<VR::DA>::Type Type;
-enum { VRType = VR::DA };
+enum : long long { VRType = VR::DA };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0022> {
 static const char* GetVRString() { return "DA"; }
 typedef VRToType<VR::DA>::Type Type;
-enum { VRType = VR::DA };
+enum : long long { VRType = VR::DA };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0023> {
 static const char* GetVRString() { return "DA"; }
 typedef VRToType<VR::DA>::Type Type;
-enum { VRType = VR::DA };
+enum : long long { VRType = VR::DA };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0024> {
 static const char* GetVRString() { return "DA"; }
 typedef VRToType<VR::DA>::Type Type;
-enum { VRType = VR::DA };
+enum : long long { VRType = VR::DA };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0025> {
 static const char* GetVRString() { return "DA"; }
 typedef VRToType<VR::DA>::Type Type;
-enum { VRType = VR::DA };
+enum : long long { VRType = VR::DA };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x002a> {
 static const char* GetVRString() { return "DT"; }
 typedef VRToType<VR::DT>::Type Type;
-enum { VRType = VR::DT };
+enum : long long { VRType = VR::DT };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0030> {
 static const char* GetVRString() { return "TM"; }
 typedef VRToType<VR::TM>::Type Type;
-enum { VRType = VR::TM };
+enum : long long { VRType = VR::TM };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0031> {
 static const char* GetVRString() { return "TM"; }
 typedef VRToType<VR::TM>::Type Type;
-enum { VRType = VR::TM };
+enum : long long { VRType = VR::TM };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0032> {
 static const char* GetVRString() { return "TM"; }
 typedef VRToType<VR::TM>::Type Type;
-enum { VRType = VR::TM };
+enum : long long { VRType = VR::TM };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0033> {
 static const char* GetVRString() { return "TM"; }
 typedef VRToType<VR::TM>::Type Type;
-enum { VRType = VR::TM };
+enum : long long { VRType = VR::TM };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0034> {
 static const char* GetVRString() { return "TM"; }
 typedef VRToType<VR::TM>::Type Type;
-enum { VRType = VR::TM };
+enum : long long { VRType = VR::TM };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0035> {
 static const char* GetVRString() { return "TM"; }
 typedef VRToType<VR::TM>::Type Type;
-enum { VRType = VR::TM };
+enum : long long { VRType = VR::TM };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0040> {
 static const char* GetVRString() { return "US"; }
 typedef VRToType<VR::US>::Type Type;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0041> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0042> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0050> {
 static const char* GetVRString() { return "SH"; }
 typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0051> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0052> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+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;
-enum { VRType = VR::AE };
+enum : long long { VRType = VR::AE };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x0056> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0058> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x0060> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0061> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x0062> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x0064> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0068> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0070> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0080> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0081> {
 static const char* GetVRString() { return "ST"; }
 typedef VRToType<VR::ST>::Type Type;
-enum { VRType = VR::ST };
+enum : long long { VRType = VR::ST };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0082> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0090> {
 static const char* GetVRString() { return "PN"; }
 typedef VRToType<VR::PN>::Type Type;
-enum { VRType = VR::PN };
+enum : long long { VRType = VR::PN };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0092> {
 static const char* GetVRString() { return "ST"; }
 typedef VRToType<VR::ST>::Type Type;
-enum { VRType = VR::ST };
+enum : long long { VRType = VR::ST };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0094> {
 static const char* GetVRString() { return "SH"; }
 typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x0096> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+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;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
 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;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0103> {
 static const char* GetVRString() { return "SH"; }
 typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0104> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0105> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0106> {
 static const char* GetVRString() { return "DT"; }
 typedef VRToType<VR::DT>::Type Type;
-enum { VRType = VR::DT };
+enum : long long { VRType = VR::DT };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0107> {
 static const char* GetVRString() { return "DT"; }
 typedef VRToType<VR::DT>::Type Type;
-enum { VRType = VR::DT };
+enum : long long { VRType = VR::DT };
 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;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x010c> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x010d> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x010f> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0110> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0112> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0114> {
 static const char* GetVRString() { return "ST"; }
 typedef VRToType<VR::ST>::Type Type;
-enum { VRType = VR::ST };
+enum : long long { VRType = VR::ST };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0115> {
 static const char* GetVRString() { return "ST"; }
 typedef VRToType<VR::ST>::Type Type;
-enum { VRType = VR::ST };
+enum : long long { VRType = VR::ST };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0116> {
 static const char* GetVRString() { return "ST"; }
 typedef VRToType<VR::ST>::Type Type;
-enum { VRType = VR::ST };
+enum : long long { VRType = VR::ST };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x0117> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 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;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
 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;
-enum { VRType = VR::AE };
+enum : long long { VRType = VR::AE };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1010> {
 static const char* GetVRString() { return "SH"; }
 typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1030> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1032> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x103e> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x103f> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1040> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1048> {
 static const char* GetVRString() { return "PN"; }
 typedef VRToType<VR::PN>::Type Type;
-enum { VRType = VR::PN };
+enum : long long { VRType = VR::PN };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x1049> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1050> {
 static const char* GetVRString() { return "PN"; }
 typedef VRToType<VR::PN>::Type Type;
-enum { VRType = VR::PN };
+enum : long long { VRType = VR::PN };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x1052> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1060> {
 static const char* GetVRString() { return "PN"; }
 typedef VRToType<VR::PN>::Type Type;
-enum { VRType = VR::PN };
+enum : long long { VRType = VR::PN };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x1062> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1070> {
 static const char* GetVRString() { return "PN"; }
 typedef VRToType<VR::PN>::Type Type;
-enum { VRType = VR::PN };
+enum : long long { VRType = VR::PN };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x1072> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1080> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x1084> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1090> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1100> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1110> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1111> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1115> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1120> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1125> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1130> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1134> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x113a> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1140> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1145> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x114a> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x114b> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1150> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1155> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x115a> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x1160> {
 static const char* GetVRString() { return "IS"; }
 typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x1161> {
 static const char* GetVRString() { return "UL"; }
 typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x1162> {
 static const char* GetVRString() { return "UL"; }
 typedef VRToType<VR::UL>::Type Type;
-enum { VRType = VR::UL };
+enum : long long { VRType = VR::UL };
 enum { VMType = VM::VM3_3n };
 static const char* GetVMString() { return "3-3n"; }
 };
 template <> struct TagToType<0x0008,0x1163> {
 static const char* GetVRString() { return "FD"; }
 typedef VRToType<VR::FD>::Type Type;
-enum { VRType = VR::FD };
+enum : long long { VRType = VR::FD };
 enum { VMType = VM::VM2 };
 static const char* GetVMString() { return "2"; }
 };
 template <> struct TagToType<0x0008,0x1164> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1167> {
 static const char* GetVRString() { return "UI"; }
 typedef VRToType<VR::UI>::Type Type;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 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;
-enum { VRType = VR::UI };
+enum : long long { VRType = VR::UI };
 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;
-enum { VRType = VR::US };
+enum : long long { VRType = VR::US };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1198> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1199> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+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;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x1250> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2110> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2111> {
 static const char* GetVRString() { return "ST"; }
 typedef VRToType<VR::ST>::Type Type;
-enum { VRType = VR::ST };
+enum : long long { VRType = VR::ST };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2112> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2120> {
 static const char* GetVRString() { return "SH"; }
 typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2122> {
 static const char* GetVRString() { return "IS"; }
 typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2124> {
 static const char* GetVRString() { return "IS"; }
 typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2127> {
 static const char* GetVRString() { return "SH"; }
 typedef VRToType<VR::SH>::Type Type;
-enum { VRType = VR::SH };
+enum : long long { VRType = VR::SH };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2128> {
 static const char* GetVRString() { return "IS"; }
 typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2129> {
 static const char* GetVRString() { return "IS"; }
 typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x212a> {
 static const char* GetVRString() { return "IS"; }
 typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2130> {
 static const char* GetVRString() { return "DS"; }
 typedef VRToType<VR::DS>::Type Type;
-enum { VRType = VR::DS };
+enum : long long { VRType = VR::DS };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x2132> {
 static const char* GetVRString() { return "LO"; }
 typedef VRToType<VR::LO>::Type Type;
-enum { VRType = VR::LO };
+enum : long long { VRType = VR::LO };
 enum { VMType = VM::VM1_n };
 static const char* GetVMString() { return "1-n"; }
 };
 template <> struct TagToType<0x0008,0x2133> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2134> {
 static const char* GetVRString() { return "FD"; }
 typedef VRToType<VR::FD>::Type Type;
-enum { VRType = VR::FD };
+enum : long long { VRType = VR::FD };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2135> {
 static const char* GetVRString() { return "SQ"; }
 typedef VRToType<VR::SQ>::Type Type;
-enum { VRType = VR::SQ };
+enum : long long { VRType = VR::SQ };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2142> {
 static const char* GetVRString() { return "IS"; }
 typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2143> {
 static const char* GetVRString() { return "IS"; }
 typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2144> {
 static const char* GetVRString() { return "IS"; }
 typedef VRToType<VR::IS>::Type Type;
-enum { VRType = VR::IS };
+enum : long long { VRType = VR::IS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2200> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2204> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 static const char* GetVMString() { return "1"; }
 };
 template <> struct TagToType<0x0008,0x2208> {
 static const char* GetVRString() { return "CS"; }
 typedef VRToType<VR::CS>::Type Type;
-enum { VRType = VR::CS };
+enum : long long { VRType = VR::CS };
 enum { VMType = VM::VM1 };
 stat...
 
[truncated message content]