Cleanup some build files (#24539)

* Remove OsEnvironment, PackagesDir, and CoreCLRBinDir properties
* Replace usage of __BuildArch with BuildArch
* Simplify test timing out on ARM64

7 files changed, 14 insertions, 2095 deletions

diff --git a/cmake.definitions b/cmake.definitions
deleted file mode 100644
index e69de29bb2..0000000000
--- a/cmake.definitions
+++ /dev/null
diff --git a/dir.props b/dir.props
index 4da47073fc..51bb050ae8 100644
--- a/dir.props
+++ b/dir.props
@@ -8,14 +8,6 @@
     <LangVersion>8.0</LangVersion>
     <UseSharedCompilation>true</UseSharedCompilation>
   </PropertyGroup>
-  
-  <!--
-    $(OS) is set to Unix/Windows_NT. This comes from an environment variable on Windows and MSBuild on Unix.
-  -->
-  <PropertyGroup>
-    <OsEnvironment Condition="'$(OsEnvironment)'=='' and '$(OS)'=='OSX'">Unix</OsEnvironment>
-    <OsEnvironment Condition="'$(OsEnvironment)'==''">$(OS)</OsEnvironment>
-  </PropertyGroup>
 
   <!-- Set the kind of PDB to Portable -->
   <PropertyGroup>
@@ -52,10 +44,6 @@
     <!-- This name is used to create a GIT repository URL https://github.com/dotnet/$(GitHubRepositoryName) used to find source code for debugging -->
     <GitHubRepositoryName Condition="'$(GitHubRepositoryName)' == ''">coreclr</GitHubRepositoryName>
 
-    <PackagesDir>$(DotNetRestorePackagesPath)</PackagesDir>
-    <PackagesDir Condition="'$(PackagesDir)'=='' and '$(__PackagesDir)'!=''">$(__PackagesDir)\</PackagesDir>
-    <PackagesDir Condition="'$(PackagesDir)'==''">$(ProjectDir)\.packages\</PackagesDir>
-
     <RootBinDir>$(__RootBinDir)\</RootBinDir>
     <RootBinDir Condition="'$(__RootBinDir)'==''">$(ProjectDir)bin\</RootBinDir>
 
diff --git a/oacr.cfg b/oacr.cfg
deleted file mode 100644
index cdfd99a8c8..0000000000
--- a/oacr.cfg
+++ /dev/null
@@ -1 +0,0 @@
-OACR_CONFIG=ndp_clr
diff --git a/src/AUTOEXP.DAT b/src/AUTOEXP.DAT
deleted file mode 100644
index 8085712c35..0000000000
--- a/src/AUTOEXP.DAT
+++ /dev/null
@@ -1,2066 +0,0 @@
-;---------------------------------------------------------------
-; This comment block added by the CLR dev team.
-;
-; This is a custom autoexp.dat that causes VS2005 to nicely
-; pretty-print common CLR data types (MethodDesc, EEClass, etc.)
-; in the debugger watch window. For example, instead of
-; seeing
-;
-;     pString     {...}         
-;
-; you will see the more useful
-;
-;     pString     {0x<addr> "Hello" }
-;
-;
-;
-;
-; To use this file, replace the autoexp.dat file in your VS
-; installation with this one. This file is normally found under
-; this path:
-;
-;    C:\Program Files\Microsoft Visual Studio 8\Common7\Packages\Debugger
-;
-; If you have your own custom rules that you don't want messed
-; up or you're just healthily paranoid, you can cut and paste
-; the CLR-specific section only. The section begins with
-;
-;   ;---- [BEGIN] CLR-specific autoexps ---------------------------
-;
-; and ends with
-;
-;   ;---- [END] CLR-specific autoexps ---------------------------
-;
-; Note that this *must* go into the [AutoExpand] section of the file.
-; Don't just append to the end of the file or the debugger won't
-; see it.
-;
-; 
-;
-;---------------------------------------------------------------
-
-
-
-
-
-
-
-
-;---------------------------------------------------------------
-; AutoExp.Dat - templates for automatically expanding data
-; Licensed to the .NET Foundation under one or more agreements.
-; The .NET Foundation licenses this file to you under the MIT license.
-; See the LICENSE file in the project root for more information.
-;---------------------------------------------------------------
-;
-; While debugging, Data Tips and items in the Watch and Variable
-; windows are automatically expanded to show their most important
-; elements. The expansion follows the format given by the rules
-; in this file. You can add rules for your types or change the
-; predefined rules.
-;
-; For good examples, read the rules in this file.
-;
-; To find what the debugger considers the type of a variable to
-; be, add it to the Watch window and look at the Type column.
-;
-; An AutoExpand rule is a line with the name of a type, an equals 
-; sign, and text with replaceable parts in angle brackets. The 
-; part in angle brackets names a member of the type and an 
-; optional Watch format specifier.
-;
-; AutoExpand rules use the following syntax. The equals sign (=), 
-; angle brackets (<>), and comma are taken literally. Square
-; brackets ([]) indicate optional items.
-;
-; type=[text]<member[,format]>...
-;
-; type      Name of the type (may be followed by <*> for template
-;           types such as the ATL types listed below).
-;
-; text      Any text.Usually the name of the member to display, 
-;           or a shorthand name for the member.
-;
-; member    Name of a member to display.
-;
-; format    Watch format specifier. One of the following:
-;
-;   Letter  Description                 Sample         Display
-;   ------  --------------------------  ------------   -------------
-;   d,i     Signed decimal integer      0xF000F065,d   -268373915
-;   u       Unsigned decimal integer    0x0065,u       101
-;   o       Unsigned octal integer      0xF065,o       0170145
-;   x,X     Hexadecimal integer         61541,X        0X0000F065
-;   l,h     long or short prefix for    00406042,hx    0x0c22
-;             d, i, u, o, x, X
-;   f       Signed floating-point       3./2.,f        1.500000
-;   e       Signed scientific-notation  3./2.,e        1.500000e+000
-;   g       Shorter of e and f          3./2.,g        1.5
-;   c       Single character            0x0065,c       'e'
-;   s       Zero-terminated string      pVar,s         "Hello world"
-;   su      Unicode string              pVar,su        "Hello world"
-;
-; For details of other format specifiers see Help under:
-; "format specifiers/watch variable"
-;
-; The special format <,t> specifies the name of the most-derived 
-; type of the object. This is especially useful with pointers or
-; references to a base class.
-;
-; If there is no rule for a class, the base classes are checked for
-; a matching rule.
-;
-; There are some special entries allowed in the AutoExpand section:
-; $BUILTIN is used to display more complex types that need to do more
-; than just show a member variable or two.
-; $ADDIN allows external DLLs to be added to display even more complex
-; types via the EE Add-in API. The first argument is the DLL name, the
-; second argument is the name of the export from the DLL to use. For 
-; further information on this API see the sample called EEAddIn.
-;
-; WARNING: if hexadecimal mode is on in the watch window, all numbers here are
-; evaluated in hex, e.g. 42 becomes 0x42
-
-[AutoExpand]
-
-;---- [BEGIN] CLR-specific autoexps ---------------------------
-; 
-
-
-PEFile=<m_pDebugName,su>
-Module=<m_file->m_pDebugName, su>
-Assembly=<m_pManifestFile->m_pDebugName,su>
-ClassLoader=<m_pAssembly->m_pManifestFile->m_pDebugName,su>
-AssemblySpec=<m_pAssemblyName,s> v<m_context.usMajorVersion,d>.<m_context.usMinorVersion,d>.<m_context.usBuildNumber,d>.<m_context.usRevisionNumber,d> <m_CodeInfo.m_pszCodeBase,su>
-
-TypeHandle=<m_asMT->m_pEEClass->m_szDebugClassName,s>
-ParamTypeDesc=<m_TemplateMT->m_pEEClass->m_szDebugClassName, s>
-
-
-EEClass=<m_szDebugClassName,s>
-MethodTable=<m_pEEClass->m_szDebugClassName,s>
-MethodDesc=<m_pszDebugClassName,s>::<m_pszDebugMethodName,s> 
-ReflectMethod=<pMethod->m_pszDebugClassName,s>::<pMethod->m_pszDebugMethodName,s> 
-FieldDesc=<m_pMTOfEnclosingClass->m_pEEClass->m_szDebugClassName,s>::<m_debugName,s>
-
-Thread=<m_ThreadId,x>
-
-BaseObject=<m_pMethTab->m_pEEClass->m_szDebugClassName,s>
-Object=<m_pMethTab->m_pEEClass->m_szDebugClassName,s>
-StringObject=<m_Characters>
-OBJECTREF= <m_asObj->m_pMethTab->m_pEEClass->m_szDebugClassName,s>
-REF<StringObject>=<m_asString->m_Characters>
-REF<*>= <m_asObj->m_pMethTab->m_pEEClass->m_szDebugClassName,s>
-
-; SStrings are annoying because their internal buffer can be in either
-; unicode or ansi depending on the code path. Thus, this rule attempts
-; to print it both ways. We will do the ascii attempt first as it's
-; less likely to produce verbose garbage (usually, it'll print just the
-; first character.)
-;
-; So the typical output you'll see is...
-;
-;   {"A"/"ABCD"}              ; sbuffer is using unicode representation
-;   {"ABCD"/"<square boxes>"} ; sbuffer was using ansi representation
-;
-; The rule below also kicks in as desired for StackSString and InlineSString.
-
-SString =<m_buffer, s>|<m_buffer, su>
-
-
-HolderBase<*>=<m_value>
-
-NATIVE_BINDER_SPACE::IEntry=<_tag,su>
-HolderBase<NATIVE_BINDER_SPACE::IEntry *>=<m_value> <m_value->_tag,su>
-HolderBase<NATIVE_BINDER_SPACE::CILEntry *>=<m_value> <m_value->_tag,su>
-HolderBase<NATIVE_BINDER_SPACE::CNgenEntry *>=<m_value> <m_value->_tag,su>
-
-NATIVE_BINDER_SPACE::CILEntryBind=<_pILEntry->_tag,su>
-HolderBase<NATIVE_BINDER_SPACE::CILEntryBind *>=<m_value> <m_value->_pILEntry->_tag,su>
-
-NATIVE_BINDER_SPACE::CNgenEntryBind=<_pNgenEntry->_tag,su>
-HolderBase<NATIVE_BINDER_SPACE::CNgenEntryBind *>=<m_value> <m_value->_pNgenEntry->_tag,su>
-
-NATIVE_BINDER_SPACE::CDependencyEntry=<_pEntry->_tag,su>
-HolderBase<NATIVE_BINDER_SPACE::CDependencyEntry *>=<m_value> <m_value->_pEntry->_tag,su>
-
-CAssemblyName=<_rProp._rProp[3].asStr>
-HolderBase<CAssemblyName *>=<m_value->_rProp._rProp[3].asStr>
-HolderBase<IAssemblyName *>=<m_pAutoExpVisibleValue->_asCAssemblyName->_rProp._rProp[3].asStr>
-
-BindResult=<m_tag,su>
-HolderBase<BindResult *>=<m_value->m_tag,su>
-HolderBase<IBindResult *>=<m_pAutoExpVisibleValue->_asBindResult->m_tag,su>
-
-AssemblyLocation=<m_pwzAssemblyPath>
-HolderBase<AssemblyLocation *>=<m_value->m_pwzAssemblyPath>
-HolderBase<IAssemblyLocation *>=<m_pAutoExpVisibleValue->_asAssemblyLocation->m_pwzAssemblyPath>
-
-
-;---- [END] CLR-specific autoexps ---------------------------
-
-
-
-
-
-
-; from windef.h
-tagPOINT =x=<x> y=<y>
-tagRECT =top=<top> bottom=<bottom> left=<left> right=<right>
-
-; from winuser.h
-tagMSG =msg=<message,x> wp=<wParam,x> lp=<lParam,x>
-
-; intrinsics
-__m64 =<m64_i64,x>
-__m128=$BUILTIN(M128)
-__m128i=$BUILTIN(M128I)
-__m128d=$BUILTIN(M128D)
-
-; from afxwin.h
-CDC =hDC=<m_hDC> attrib=<m_hAttribDC>
-CPaintDC =<,t> hWnd=<m_hWnd>
-CPoint =x=<x> y=<y>
-CRect =top=<top> bottom=<bottom> left=<left> right=<right>
-CSize =cx=<cx> cy=<cy>
-CWnd =<,t> hWnd=<m_hWnd>
-CWinApp =<,t> <m_pszAppName,s>
-CWinThread =<,t> h=<m_hThread> proc=<m_pfnThreadProc>
-
-; from afxcoll.h
-CPtrList =cnt=<m_nCount>
-
-; from afxstat_.h
-CProcessLocalObject =<,t>
-CThreadLocalObject =<,t>
-
-; from afx.h
-CArchiveException =cause=<m_cause>
-CFile =hFile=<m_hFile> name=<m_strFileName.m_pchData,s>
-CFileException =cause=<m_cause> OS Error=m_lOsError
-CMemFile =pos=<m_nPosition> size=<m_nFileSize>
-CObject =<,t>
-CRuntimeClass =<m_lpszClassName,s>
-CStdioFile =FILE*=<m_pStream> name=<m_strFilename.m_pchData,s>
-CTimeSpan =time=<m_time>
-CTime =time=<m_time>
-
-; from afxcoll.h
-CByteArray =count=<m_nCount>
-CStringList =count=<m_nCount>
-; same for all CXXXArray classes
-; same for CXXXList
-; same for CMapXXToXX
-
-; various string classes from MFC & ATL
-
-_com_error=<m_hresult,hr>
-_bstr_t=<m_Data->m_wstr,su> (<m_Data->m_RefCount,u>)
-_com_ptr_t<*>=<m_pInterface>
-_LARGE_INTEGER=<QuadPart>
-_ULARGE_INTEGER=<QuadPart>
-ATL::CComPtr<*>=<p>
-
-ATL::CComQIPtr<*>=<p>
-
-tagVARIANT=$BUILTIN(VARIANT)
-VARIANT=$BUILTIN(VARIANT)
-_GUID=$BUILTIN(GUID)
-
-; see EEAddIn sample for how to use these
-;_SYSTEMTIME=$ADDIN(EEAddIn.dll,AddIn_SystemTime)
-;_FILETIME=$ADDIN(EEAddIn.dll,AddIn_FileTime)
-
-std::binder1st<*>= op=<op> value=<value>
-std::binder2nd<*>= op=<op> value=<value>
-std::less<*>=lessthan
-std::greater<*>=greaterthan
-
-[Visualizer]
-; This section contains visualizers for STL and ATL containers
-; DO NOT MODIFY
-
-
-
-ATL::CStringT<char,*>|CSimpleStringT<char,*>|ATL::CSimpleStringT<char,*>{
-	preview([$c.m_pszData,s])
-        stringview([$c.m_pszData,sb])
-}
-
-ATL::CStringT<wchar_t,*>|CSimpleStringT<wchar_t,*>|ATL::CSimpleStringT<wchar_t,*>|ATL::CStringT<unsigned short,*>|CSimpleStringT<unsigned short,*>|ATL::CSimpleStringT<unsigned short,*>{
-	preview([$c.m_pszData,su])
-        stringview([$c.m_pszData,sub])
-}
-
-ATL::CComBSTR{
-	preview([$c.m_str,su])
-        stringview([$c.m_str,sub])
-}
-
-
-;------------------------------------------------------------------------------
-;  std::vector<bool,*> specialization
-;------------------------------------------------------------------------------
-
-std::vector<bool,*>{
-	children
-	(
-		#array
-		(
-			expr : ($c._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)), 
-			size : ($c._Mysize)
-		)  : (bool)($e & 1)
-	)
-		
-    preview
-    ( 
-            #( 
-				"[", 
-				$e._Mysize , 
-				"](", 
-				#array
-				(
-					expr : ($c._Myvec._Myfirst[$i / _VBITS] >> ($i % _VBITS)), 
-					size : ($c._Mysize)
-				)  : (bool)($e & 1), ")")
-	)		
-}
-
-std::vector<bool,*>::iterator|std::vector<bool,*>::const_iterator|std::_Vb_iterator<*>|std::_Vb_const_iterator<*>{
-	preview
-	(
-		#( 
-			(bool) (((*$e._Myptr) >> $e._Myoff) & 1)   
-		)
-	)
-	
-	children
-	(
-		#( 
-			ptr: (bool) (((*$e._Myptr) >> $e._Myoff) & 1)   
-		)
-	)
-
-	
-}
-
-
-;------------------------------------------------------------------------------
-;  std::vector
-;------------------------------------------------------------------------------
-std::vector<*>{
-	children
-	(
-	    #array
-	    (
-			expr :	($c._Myfirst)[$i],  
-			size :	$c._Mylast-$c._Myfirst
-		)
-	)
-	
-    preview
-    ( 
-        #( 
-			"[", 
-            $e._Mylast - $e._Myfirst , 
-            "](", 
-            
-            #array
-            (
-				expr : 	($c._Myfirst)[$i],  
-				size : 	$c._Mylast-$c._Myfirst
-			), 
-			")"
-		)
-	)
-	
-
-}
-
-std::_Vector_iterator<*>|std::_Vector_const_iterator<*>{
-	preview 
-	(
-		#(*$e._Myptr)
-	)
-	
-	children
-	(
-		#(ptr: *$e._Myptr)
-	)
-}
-
-
-
-;------------------------------------------------------------------------------
-;  std::string/basic_string
-;------------------------------------------------------------------------------
-
-std::basic_string<char,*>{
-	preview
-	( 
-		#if(($e._Myres) < ($e._BUF_SIZE))
-		(
-			[$e._Bx._Buf,s]
-		)
-		#else
-		(
-			[$e._Bx._Ptr,s]
-		)
-	)
-	
-	stringview
-	(
-		#if(($e._Myres) < ($e._BUF_SIZE))
-		(
-			[$e._Bx._Buf,sb]
-		)
-		#else
-		(
-			[$e._Bx._Ptr,sb]
-		)
-	)
-	
-	children
-	(
-		#if(($e._Myres) < ($e._BUF_SIZE))
-		(
-			#([actual members]: [$e,!] , #array( expr: $e._Bx._Buf[$i], size: $e._Mysize))
-		)
-		#else
-		(
-			#([actual members]: [$e,!],  #array( expr: $e._Bx._Ptr[$i], size: $e._Mysize))
-		)	
-	)	
-
-}
-
-std::basic_string<unsigned short,*>|std::basic_string<wchar_t,*>{
-	preview
-	( 
-		#if(($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,su] )
-		#else ( [$e._Bx._Ptr,su] )
-	)
-	
-	stringview
-	( 
-		#if(($e._Myres) < ($e._BUF_SIZE)) ( [$e._Bx._Buf,sub] )
-		#else ( [$e._Bx._Ptr,sub] )
-	)
-	
-	children
-	(
-		#if(($e._Myres) < ($e._BUF_SIZE))
-		(
-			#([actual members]: [$e,!] , #array( expr: $e._Bx._Buf[$i], size: $e._Mysize))
-		)
-		#else
-		(
-			#([actual members]: [$e,!],  #array( expr: $e._Bx._Ptr[$i], size: $e._Mysize))
-		)	
-	)	
-}
-
-std::basic_string<*>::iterator|std::basic_string<*>::const_iterator|std::_String_iterator<*>|std::_String_const_iterator<*>{
-	preview
-	( 
-		#( $e._Myptr ) 
-	)
-
-	children
-	( 
-		#( ptr: $e._Myptr ) 
-	)
-}
-
-std::pair<*>{
-	preview
-	(
-		#( 
-			"(", 
-			$e.first, 
-			",", 
-			$e.second , 
-			")"
-		)
-	)
-}
-
-;------------------------------------------------------------------------------
-;  std::auto_ptr
-;------------------------------------------------------------------------------
-
-std::auto_ptr<*>{
-	preview
-	( 
-		#(	"auto_ptr ",
-			(*(($T1 *)$c._Myptr))
-		 )
-	)
-	children
-	( 
-		#( 
-			ptr: (*(($T1 *)$c._Myptr)) 
-		)
-	)
-}
-
-;------------------------------------------------------------------------------
-;  std::map
-;------------------------------------------------------------------------------
-
-std::map<*>{
-	children
-	(
-		#tree
-		(
-			head : $c._Myhead->_Parent, 
-		    skip : $c._Myhead, 
-		    size : $c._Mysize, 
-		    left : _Left, 
-		    right : _Right
-		) : $e._Myval
-	)
-		     
-	preview
-	(
-		#(
-			"[", 
-			$e._Mysize, 
-			"](", 
-
-			#tree
-			(
-				head : $c._Myhead->_Parent, 
-				skip : $c._Myhead, 
-				size : $c._Mysize, 
-				left : _Left, 
-				right : _Right
-			) : $e._Myval,
-			
-			")"
-		)
-	)		     
-}
-
-;------------------------------------------------------------------------------
-;  std::multi_map
-;------------------------------------------------------------------------------
-
-std::multimap<*>{
-	children
-	(
-		#tree
-		(
-			head : $c._Myhead->_Parent, 
-		    skip : $c._Myhead, 
-		    size : $c._Mysize, 
-		    left : _Left, 
-		    right : _Right
-		) : $e._Myval
-	)
-		     
-	preview
-	(
-		#(
-			"[", 
-			$e._Mysize, 
-			"](", 
-			
-			#tree
-			(	
-				head : $c._Myhead->_Parent, 
-				skip : $c._Myhead, 
-				size : $c._Mysize, 
-				left : _Left, 
-				right : _Right
-			) : $e._Myval,
-			
-			")"
-		)
-	)		     
-}
-
-
-;------------------------------------------------------------------------------
-;  std::list
-;------------------------------------------------------------------------------
-
-std::list<*>{
-
-	children
-	(
-		#list
-		(
-			head : $c._Myhead->_Next, 
-		    size : $c._Mysize, 
-		    next : _Next
-		) : $e._Myval
-	)
-		          
-	preview
-	(
-		#(
-			"[", 
-			$e._Mysize, 
-			"](", 
-		  
-			#list
-			(
-				head : $c._Myhead->_Next, 
-				size : $c._Mysize, 
-				next : _Next
-			) : $e._Myval,
-		 
-			")"
-		)
-	)			      
-}
-
-std::list<*>::iterator|std::list<*>::const_iterator|std::list<*>::_Iterator<1>|std::list<*>::_Const_iterator<1>{
-	preview
-	(
-		#($e._Ptr->_Myval)
-	)
-	
-	children
-	(
-		#(ptr: $e._Ptr->_Myval)
-	)
-
-}
-
-
-;------------------------------------------------------------------------------
-;  std::bitset  <bitset>
-;------------------------------------------------------------------------------
-
-std::bitset<*>{       
-	preview
-	(
-		#(
-		"[",
-			$c.digits,
-		"](",
-		#array
-		(	
-			expr : 	($c._Array[$i / $c._Bitsperword] >> ($i % $c._Bitsperword)),  
-			size : 	$c.digits
-		) : [($e & 1),d],
-		")"
-		)
-	)
-	children
-	(
-		#array
-		(	
-			expr : 	($c._Array[$i / $c._Bitsperword] >> ($i % $c._Bitsperword)),  
-			size : 	$c.digits
-		) : (bool)($e & 1))
-}
-
-std::bitset<*>::reference{
-    preview
-    (
-		#(
-			"bitset[", $e._Mypos, "] = ", 
-			(bool)(($e._Pbitset->_Array[$i / _Bitsperword] >> ($e._Mypos % _Bitsperword)) & 1) 
-		)
-    )
-}
-
-;------------------------------------------------------------------------------
-;  std::deque
-;------------------------------------------------------------------------------
-
-std::deque<*>{
-	children
-	(
-		#array
-		(
-			expr : $c._Map[ (($i + $c._Myoff) / $c._EEN_DS) % $c._Mapsize][($i + $c._Myoff) % $c._EEN_DS],  
-			size : $c._Mysize
-		)
-	)
-
-	preview
-	(
-		#(
-			"[", 
-			$e._Mysize, 
-			"](", 
-		  
-			#array
-			(
-				expr : $c._Map[ (($i + $c._Myoff) / $c._EEN_DS) % $c._Mapsize][($i + $c._Myoff) % $c._EEN_DS],  
-				size : $c._Mysize
-			),
-		 
-			")"
-		)
-	)		       
-}
-
-std::deque<*,*>::iterator|std::_Deque_iterator<*,*,*>|std::_Deque_const_iterator<*,*,*>{
-   preview
-   (
-	   #if( $e._Myoff >= ((std::deque<$T1,$T2 > *)$c._Mycont)->_Myoff + ((std::deque<$T1,$T2 > *)$c._Mycont)->_Mysize)
-	   (
-	   		#("<end>")
-	   )
-	   #else(
-			#(
-				"deque[", 
-				$e._Myoff - ((std::deque<$T1,$T2 > *)$c._Mycont)->_Myoff, 
-				"] = ",
-				((std::deque<$T1,$T2 > *)$c._Mycont)->_Map[ (($c._Myoff) / ((std::deque<$T1,$T2 > *)$c._Mycont)->_EEN_DS) % ((std::deque<$T1,$T2 > *)$c._Mycont)->_Mapsize][$c._Myoff % ((std::deque<$T1,$T2 > *)$c._Mycont)->_EEN_DS] 
-			)
-		)
-	)
-	children
-	(
-	   #if( ((std::deque<$T1,$T2 > *)$c._Mycont)->_Myoff + ((std::deque<$T1,$T2 > *)$c._Mycont)->_Mysize > $e._Myoff) 
-	   (
-			#(
-				ptr: ((std::deque<$T1,$T2 > *)$c._Mycont)->_Map[ ($c._Myoff / ((std::deque<$T1,$T2 > *)$c._Mycont)->_EEN_DS) % ((std::deque<$T1,$T2 > *)$c._Mycont)->_Mapsize][$c._Myoff % ((std::deque<$T1,$T2 > *)$c._Mycont)->_EEN_DS] 
-			)
-		)
-	)
-}
-
-;------------------------------------------------------------------------------
-;  std::queue
-;------------------------------------------------------------------------------
-
-std::queue<*>{
-	children
-	(
-		#array
-		(
-			expr : $c.c._Map[ (($i + $c.c._Myoff) / $c.c._EEN_DS) % $c.c._Mapsize][($i + $c.c._Myoff) % $c.c._EEN_DS],  
-			size : $c.c._Mysize
-		)
-	)
-		   
- preview
-	(
-		#(
-			"[", 
-			$e.c._Mysize, 
-			"](", 
-		  
-			#array
-			(
-				expr : $c.c._Map[ (($i + $c.c._Myoff) / $c.c._EEN_DS) % $c.c._Mapsize][($i + $c.c._Myoff) % $c.c._EEN_DS],  
-				size : $c.c._Mysize
-			),
-		 
-			")"
-		)
-	)			   
-}
-
-
-;------------------------------------------------------------------------------
-;  std::priority_queue
-;------------------------------------------------------------------------------
-
-std::priority_queue<*>{
-	preview
-	( 
-		$e.c 
-	)
-}
-
-;------------------------------------------------------------------------------
-;  std::set
-;------------------------------------------------------------------------------
-
-std::set<*>{
-    preview
-    ( 
-		#( 
-			"[", 
-            $e._Mysize , 
-            "](", 
-            
-            #tree
-            (
-				head : $c._Myhead->_Parent, 
-				skip : $c._Myhead, 
-				left : _Left, 
-				right : _Right,
-				size  : $c._Mysize
-			) : $e._Myval, 
-			
-			")"
-		)
-	)
-			   
-	children
-	(
-		#tree
-		(
-			head : $c._Myhead->_Parent, 
-			skip : $c._Myhead, 
-			left : _Left, 
-			right : _Right,
-			size  : $c._Mysize
-		) : $e._Myval
-	)
-}
-
-;------------------------------------------------------------------------------
-;  std::multi_set
-;------------------------------------------------------------------------------
-
-std::multiset<*>{
-    preview
-    (
-		#( 
-			"[", 
-            $e._Mysize , 
-            "](", 
-            
-            #tree
-            (
-				head : $c._Myhead->_Parent, 
-				skip : $c._Myhead, 
-				left : _Left, 
-				right : _Right,
-				size  : $c._Mysize
-			) : $e._Myval, 
-			
-			")"
-		)
-	)
-			   
-	children
-	(
-		#tree
-		(
-			head : $c._Myhead->_Parent, 
-			skip : $c._Myhead, 
-			left : _Left, 
-			right : _Right,
-			size  : $c._Mysize
-		) : $e._Myval
-	)
-}
-
-
-;------------------------------------------------------------------------------
-;  std::_Tree (shared my map/multimap/set/multiset)
-;------------------------------------------------------------------------------
-
-std::_Tree<*>::iterator|std::_Tree<*>::const_iterator{
-	preview
-	(
-		#($e._Ptr->_Myval)
-	)
-	
-	children
-	(
-		#(ptr: $e._Ptr->_Myval)
-	)
-
-	
-}
-
-
-;------------------------------------------------------------------------------
-;  std::stack
-;------------------------------------------------------------------------------
-
-std::stack<*>{
-	children
-	(
-		#array
-		(
-			expr : $c.c._Map[ (($i + $c.c._Myoff) / $c.c._EEN_DS) % $c.c._Mapsize][($i + $c.c._Myoff) % $c.c._EEN_DS],  
-			size : $c.c._Mysize
-		)
-	)
-           
-    preview
-    (
-		#( 
-			"[", 
-            $e.c._Mysize , 
-            "](", 
-            
-            #array
-            (
-				expr : $c.c._Map[ (($i + $c.c._Myoff) / $c.c._EEN_DS) % $c.c._Mapsize][($i + $c.c._Myoff) % $c.c._EEN_DS],  
-				size : $c.c._Mysize
-			), 
-			
-			")"
-		)
-	)           
-}
-
-;------------------------------------------------------------------------------
-;  stdext::hash_map
-;  stdext::hash_multimap
-;  stdext::hash_set
-;  stdext::hash_multiset
-;------------------------------------------------------------------------------
-
-stdext::hash_map<*>|stdext::hash_multimap<*>|stdext::hash_set<*>|stdext::hash_multiset<*>{
-	
-	preview
-	(
-		#(
-			"[", 
-			$e._List._Mysize, 
-			"](", 
-		 
-			#list
-			(
-				head : $c._List._Myhead->_Next, 
-          	    size : $c._List._Mysize,
-				next : _Next
-			) : $e._Myval,
-			
-			")"
-		)
-	)	
-
-	children
-	(
-    
-		#list
-		(
-			head : $c._List._Myhead->_Next, 
-			size : $c._List._Mysize, 
-			next : _Next
-		) : $e._Myval
-	)
-}
-
-;------------------------------------------------------------------------------
-;  std::complex
-;------------------------------------------------------------------------------
-
-std::complex<*>{
-	children
-	(
-		#(
-			real: $e._Val[0],
-			imaginary: $e._Val[1]
-		)
-	)
-	preview
-	(
-		#if($e._Val[1] != 0)
-		(										
-			#if ($e._Val[0] != 0)				
-			(									; Real and Imaginary components 
-				#if ($e._Val[1] >= 0)
-				(
-					#($e._Val[0],"+i*", $e._Val[1])
-				)
-				#else
-				(
-					#($e._Val[0],"-i*", -$e._Val[1])							  
-				)
-			)
-			#else
-			(									; Purely imaginary
-				#if ($e._Val[1] >= 0.0)
-				(
-					#("i*", $e._Val[1])
-				)
-				#else
-				(
-					#("-i*", -$e._Val[1])						
-				)
-			)
-		)
-		#else
-		(										; Purely real
-			$e._Val[0]		
-		)
-	)
-}
-
-;------------------------------------------------------------------------------
-;  std::valarray
-;------------------------------------------------------------------------------
-
-std::valarray<*>{
-    preview
-    ( 
-		#( 
-			"[", 
-            $e._Mysize , 
-            "](", 
-            
-            #array
-            (
-				expr : 	($c._Myptr)[$i],  
-				size : 	$c._Mysize
-			), 
-			
-			")"
-		)
-	)
-	
-	children
-	(
-		#array
-		(
-			expr :	($c._Myptr)[$i],  
-			size :	$c._Mysize
-		)
-	)
-}
-
-;------------------------------------------------------------------------------
-;  PROPVARIANT
-;------------------------------------------------------------------------------
-
-; Visualizers for VT_VECTOR C arrays
-tagCAC|tagCAUB|tagCAI|tagCAUI|tagCAL|tagCAUL|tagCAFLT|tagCADBL|tagCACY|tagCADATE|tagCABSTR|tagCABSTRBLOB|tagCABOOL|tagCASCODE|tagCAPROPVARIANT|tagCAH|tagCAUH|tagCALPSTR|tagCALPWSTR|tagCAFILETIME|tagCACLIPDATA|tagCACLSID{
-	preview(
-		#( 
-			"[", 
-            $e.cElems , 
-            "](", 
-            
-            #array
-            (
-				expr : 	($c.pElems)[$i],  
-				size : 	$c.cElems
-			), 			
-			")"
-		)
-	)
-
-	children
-	(
-		#array
-		(
-			expr :	($c.pElems)[$i],  
-			size :	$c.cElems
-		)
-	)	
-	
-}
-
-; Visualizers for SAFE ARRAY
-tagSAFEARRAY|SAFEARRAY{
-	preview(		
-			#if ($c.fFeatures & 0x0080)		; FADF_HAVEVARTYPE 
-			(
-				;
-				;	Switch on the variant type field - which is stored 4 bytes
-				;	before the beginning of the SAFEARRAY type
-				;
-				#switch( ((unsigned *)&($c))[-1] )						
-					#case 0x2							; VT_I2 | VT_ARRAY
-					(
-						#(
-							"safearray of I2 = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((signed short *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)	
-					
-					#case 0x3							; VT_I4 | VT_ARRAY
-					(
-						#(
-							"safearray of I4 = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((signed int *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)	
-					
-					#case 0x4							; VT_R4 | VT_ARRAY
-					(
-						#(
-							"safearray of R4 = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((float *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)	
-					
-					#case 0x5							; VT_R8 | VT_ARRAY
-					(
-						#(
-							"safearray of R8 = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((double *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)	
-					
-					#case 0x6							; VT_CY | VT_ARRAY
-					(
-						#(
-							"safearray of CY = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((CY *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)
-					
-					#case 0x7							; VT_DATE | VT_ARRAY
-					(
-						#(
-							"safearray of DATE = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((DATE *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)		
-					
-					#case 0x8							; VT_BSTR | VT_ARRAY
-					(
-						#(
-							"safearray of BSTR = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((wchar_t **)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)	
-
-					#case 0xa							; VT_ERROR | VT_ARRAY
-					(
-						#(
-							"safearray of ERROR = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((long *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)
-					
-					#case 0xb							; VT_BOOL | VT_ARRAY
-					(
-						#(
-							"safearray of BOOL = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((short *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)		
-					
-					#case 0xc							; VT_VARIANT | VT_ARRAY
-					(
-						#(
-							"safearray of VARIANT = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((tagVARIANT *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)	
-					
-					#case 0x10							; VT_I1 | VT_ARRAY
-					(
-						#(
-							"safearray of I1 = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((signed char *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)		
-					
-					#case 0x11							; VT_UI1 | VT_ARRAY
-					(
-						#(
-							"safearray of UI1 = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((unsigned char *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)		
-					
-					#case 0x12							; VT_UI2 | VT_ARRAY
-					(
-						#(
-							"safearray of UI2 = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((unsigned short *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)	
-					
-					#case 0x13							; VT_UI4 | VT_ARRAY
-					(
-						#(
-							"safearray of UI4 = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((unsigned int *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)	
-					
-					#case 0x14							; VT_I8 | VT_ARRAY
-					(
-						#(
-							"safearray of I8 = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((signed __int64 *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)	
-					
-					#case 0x15							; VT_UI8 | VT_ARRAY
-					(
-						#(
-							"safearray of UI8 = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((unsigned __int64 *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)	
-					
-					#case 0x16							; VT_INT | VT_ARRAY
-					(
-						#(
-							"safearray of INT = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((int *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)																																																																																
-					
-					#case 0x17							; VT_UINT | VT_ARRAY
-					(
-						#(
-							"safearray of UINT = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((unsigned *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)	
-					
-					#case 0x1e							; VT_LPSTR | VT_ARRAY
-					(
-						#(
-							"safearray of LPSTR = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((char **)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)	
-
-					#case 0x1f							; VT_LPWSTR | VT_ARRAY
-					(
-						#(
-							"safearray of LPWSTR = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((wchar_t **)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)	
-					
-					#case 0x40							; VT_FILETIME | VT_ARRAY
-					(
-						#(
-							"safearray of FILETIME = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((FILETIME *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)	
-					
-					#case 0x47							; VT_CLIPDATA | VT_ARRAY
-					(
-						#(
-							"safearray of CLIPDATA = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((CLIPDATA *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)	
-					
-					#case 0x48							; VT_CLSID | VT_ARRAY
-					(
-						#(
-							"safearray of CLSID = [",	
-																
-							; output the rank array
-							#array(	expr: $c.rgsabound[$i].cElements, size: $c.cDims),		
-							
-							"](", 
-							
-							; output the data elements
-							#array( 
-									expr: ((CLSID *)$c.pvData)[$i], 
-									size: $c.rgsabound[$r].cElements, 
-									rank: $c.cDims, 
-									base: $c.rgsabound[$r].lLbound 
-								  ), 
-							")"
-						)
-					)																															
-			)
-			#elif ($c.fFeatures & 0x0100)		; FADF_BSTR 
-			(
-				#("safearray of BSTR = ",#array(expr: $c.rgsabound[$i].cElements, size: $c.cDims) : #("[",$e,"]"), "(", #array(expr: ((wchar_t * *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound ), ")")
-			)
-			#elif ($c.fFeatures & 0x0200)		; FADF_UNKNOWN
-			(
-				#("safearray of IUnknown* = ",#array(expr: $c.rgsabound[$i].cElements, size: $c.cDims) : #("[",$e,"]"), "(", #array(expr: ((IUnknown *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound ), ")")
-			)	
-			#elif ($c.fFeatures & 0x0400)		; FADF_DISPATCH
-			(
-				#("safearray of IDispatch* = ",#array(expr: $c.rgsabound[$i].cElements, size: $c.cDims) : #("[",$e,"]"), "(", #array(expr: ((IDispatch*)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound ), ")")
-			)
-			#elif ($c.fFeatures & 0x0800)		; FADF_VARIANT
-			(
-				#("safearray of VARIANT = ",#array(expr: $c.rgsabound[$i].cElements, size: $c.cDims) : #("[",$e,"]"), "(", #array(expr: ((tagVARIANT *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound ), ")")
-			)
-	)
-	children(
-		#(									;[actual members]: [$c,!],
-			#if ($c.fFeatures & 0x0080)		; FADF_HAVEVARTYPE 
-			(
-				#switch( ((unsigned *)&($c))[-1] )	; for some reason the VT field is before the SAFEARRAY struct
-					#case 2							; VT_I2|VT_ARRAY
-					( 
-						#array(
-								expr: ((signed short *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound 
-							  )
-					)				
-					
-					#case 3							; VT_I4|VT_ARRAY
-					( 
-						#array(
-								expr: ((signed int   *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound 
-							   )
-					)		
-							
-					#case 4							; VT_R4|VT_ARRAY
-					( 
-						#array(
-								expr: ((float *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements,
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound 
-							   )
-					)		
-							
-					#case 5							; VT_R8|VT_ARRAY
-					( 
-						#array(
-								expr: ((double  *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound 
-							  )
-					)		
-							
-					#case 0x10						; VT_I1|VT_ARRAY
-					( 
-						#array(
-								expr: ((signed char *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound 
-							   )
-					)	
-								
-					#case 0x11						; VT_UI1|VT_ARRAY
-					( 
-						#array(
-								expr: ((unsigned char *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound 
-							  )
-					)		
-							
-					#case 0x12						; VT_UI2|VT_ARRAY
-					( 
-						#array(
-								expr: ((unsigned short *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound 
-							   )
-					)		
-							
-					#case 0x13						; VT_UI4|VT_ARRAY
-					( 
-						#array(
-								expr: ((unsigned int *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							   )	
-					)
-								
-					#case 0x14						; VT_I8|VT_ARRAY
-					( 
-						#array(
-								expr: ((signed __int64 *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							   )				
-					)							 
-					#case 0x15						; VT_UI8|VT_ARRAY
-					( 
-						#array(
-								expr: ((unsigned __int64 *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							  )				
-					)
-					
-					#case 0x1e						; VT_LPSTR|VT_ARRAY
-					( 
-						#array(
-								expr: ((char * *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							  )			
-					)
-					
-					#case 0x1f						; VT_LPWSTR|VT_ARRAY
-					( 
-						#array(
-								expr: ((wchar_t **)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							  )		
-					)
-					
-					#case 0xc						; VT_VARIANT|VT_ARRAY
-					( 
-						#array(
-								expr: ((tagVARIANT *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							  )			
-					
-					)
-					
-					#case 0xb						; VT_BOOL|VT_ARRAY
-					(					
-						#array(
-								expr: ((short *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							  )			
-					)
-					
-					#case 0xa						; VT_ERROR|VT_ARRAY
-					( 
-						#array(
-								expr: ((long *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							  )			
-					)
-					
-					#case 6							; VT_CY|VT_ARRAY
-					( 
-						#array(
-								expr: ((CY *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							  )				
-					)
-					
-					#case 7							; VT_DATE|VT_ARRAY
-					( 
-						#array(
-								expr: ((DATE *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							  )			
-					)
-					
-					#case 0x40						; VT_FILETIME|VT_ARRAY
-					( 
-						#array(
-								expr: ((FILETIME *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							  )		
-					)
-					
-					#case 0x48						; VT_CLSID|VT_ARRAY
-					( 
-						#array(
-								expr: ((CLSID *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							  )			
-					)
-					
-					#case 0x47						; VT_CF|VT_ARRAY
-					( 
-						#array(
-								expr: ((CLIPDATA *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							  )				
-					)
-					
-					#case 8							; VT_BSTR|VT_ARRAY
-					( 
-						#array(
-								expr: ((wchar_t * *)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							  )			
-					)
-					
-					#case 0x16						; VT_INT|VT_ARRAY
-					( 
-						#array(
-								expr: ((int *)$c.pvData)[$i],
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							  )				
-					)
-					
-					#case 0x17						; VT_UINT|VT_ARRAY		
-					( 
-						#array(
-								expr: ((unsigned int*)$c.pvData)[$i], 
-								size: $c.rgsabound[$r].cElements, 
-								rank: $c.cDims, 
-								base: $c.rgsabound[$r].lLbound
-							  )	
-					)			
-					
-					#default
-					(
-						#([actual members]: [$e,!])
-					)
-					#except
-					(
-						#([actual members]: [$e,!])
-					)
-			)
-			#elif ($c.fFeatures & 0x0100)		; FADF_BSTR 
-			(
-				#array(expr: ((wchar_t * *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound )	
-			)
-			#elif ($c.fFeatures & 0x0200)		; FADF_UNKNOWN
-			(
-				#array(expr: ((IUnknown *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound )	
-			)	
-			#elif ($c.fFeatures & 0x0400)		; FADF_DISPATCH
-			(
-				#array(expr: ((IDispatch *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound )	
-			)
-			#elif ($c.fFeatures & 0x0800)		; FADF_VARIANT
-			(
-				#array(expr: ((tagVARIANT *)$c.pvData)[$i], size: $c.rgsabound[$r].cElements, rank: $c.cDims, base: $c.rgsabound[$r].lLbound )	
-			)
-		)
-	)
-}
-
-tagPROPVARIANT|tagVARIANT|PROPVARIANT|VARIANT{
-	preview(
-			#switch ($e.vt)
-				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-				;;      Base Types                                          ;;
-				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-				#case 0 ( #("Empty") )										; VT_EMPTY
-				#case 1 ( #("NULL") )										; VT_NULL
-				#case 2 ( #("I2 = ", $e.iVal) )								; VT_I2
-				#case 3 ( #("I4 = ", $e.lVal) )								; VT_I4
-				#case 4 ( #("R4 = ", $e.fltVal) )							; VT_R4
-				#case 5 ( #("R8 = ", $e.dblVal) )							; VT_R8
-				#case 6 ( #("CY = ", $e.cyVal) )							; VT_CY
-				#case 7 ( #("DATE =  ", $e.date) )							; VT_DATE
-				#case 8 ( #("BSTR = ", $e.bstrVal) )						; VT_BSTR
-				#case 9 ( #("DISPATCH =  ", $e.pdispVal) )					; VT_DISPATCH
-				#case 10 ( #("ERROR =  ", $e.scode) )						; VT_ERROR
-				#case 0xB ( #("BOOL =  ", $e.boolVal) )						; VT_BOOL
-				#case 0xC ( #("VARIANT ") )									; VT_VARIANT
-				#case 0xD ( #("UNKNOWN =  ", $e.punkVal) )					; VT_UNKNOWN
-				#case 0xE ( #("DECIMAL = ", $e.hVal) )						; VT_DECIMAL
-				#case 0x10 ( #("I1 =  ", $e.cVal) )							; VT_I1
-				#case 0x11 ( #("UI1 =  ", $e.bVal) )							; VT_UI1
-				#case 0x12 ( #("UI2 =  ", $e.uiVal) )							; VT_UI2
-				#case 0x13 ( #("UI4 =  ", $e.ulVal) )							; VT_UI4
-				#case 0x14 ( #("I8 =  ", $e.hVal) )							; VT_I8
-				#case 0x15 ( #("UI8 =  ", $e.uhVal) )							; VT_UI8
-				#case 0x16 ( #("INT =  ", $e.intVal) )						; VT_INT
-				#case 0x17 ( #("UINT = ", $e.uintVal) )						; VT_UINT
-				#case 0x18 ( #("VOID ") )										; VT_VOID
-				#case 0x19 ( #("HRESULT ") )									; VT_HRESULT
-				#case 0x1A ( #("PTR ") )										; VT_PTR
-				#case 0x1B ( #("SAFEARRAY ") )								; VT_SAFEARRAY
-				#case 0x1C ( #("CARRAY ") )									; VT_CARRAY
-				#case 0x1D ( #("USERDEFINED ") )								; VT_USERDEFINED
-				#case 0x1E ( #("LPSTR =  ", $e.pszVal) )						; VT_LPSTR
-				#case 0x1F ( #("LPWSTR =  ", $e.pwszVal) )					; VT_LPWSTR
-				#case 0x24 ( #("RECORD  ") )									; VT_RECORD
-				#case 0x26 ( #("UINT_PTR ") )									; VT_UINT_PTR
-				#case 0x40 ( #("FILETIME =  ", $e.filetime) )					; VT_FILETIME
-				#case 0x42 ( #("STREAM =  ", $e.pStream) )					; VT_STREAM
-				#case 0x43 ( #("STORAGE = ", $e.pStorage) )					; VT_STORAGE
-				#case 0x44 ( #("STREAMED_OBJECT =  ", $e.pStream) )			; VT_STREAMED_OBJECT
-				#case 0x45 ( #("STORED_OBJECT =  ", $e.pStorage) )			; VT_STORED_OBJECT
-				#case 0x46 ( #("BLOB_OBJECT = ", $e.blob ) )					; VT_BLOB_OBJECT
-				#case 0x47 ( #("CF =  ", $e.pclipdata) )						; VT_CF
-				#case 0x48 ( #("CLSID = ", $e.puuid) )						; VT_CLSID
-				#case 0x49 ( #("VERSIONED_STREAM = ", $e.pVersionedStream) )	; VT_VERSIONED_STREAM
-				
-				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-				;;   Vector types                                           ;;
-				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-				#case 0x1002 ( #("vector of I2 = ", $e.cai) )					; VT_I2|VT_VECTOR
-				#case 0x1003 ( #("vector of I4 = ", $e.cal) )					; VT_I4|VT_VECTOR
-				#case 0x1004 ( #("vector of R4 = ", $e.caflt) )				; VT_R4|VT_VECTOR
-				#case 0x1005 ( #("vector of R8 = ", $e.cadbl) )				; VT_R8|VT_VECTOR
-				#case 0x1010 ( #("vector of I1 =  ", $e.cac) )				; VT_I1|VT_VECTOR
-				#case 0x1011 ( #("vector of UI1 =  ", $e.caub) )				; VT_UI1|VT_VECTOR
-				#case 0x1012 ( #("vector of UI2 =  ", $e.caui) )				; VT_UI2|VT_VECTOR
-				#case 0x1013 ( #("vector of UI4 =  ", $e.caul) )				; VT_UI4|VT_VECTOR
-				#case 0x1014 ( #("vector of I8 =  ", $e.cah) )				; VT_I8|VT_VECTOR
-				#case 0x1015 ( #("vector of UI8 =  ", $e.cauh) )				; VT_UI8|VT_VECTOR
-				#case 0x101E ( #("vector of LPSTR =  ", $e.calpstr) )			; VT_LPSTR|VT_VECTOR
-				#case 0x101F ( #("vector of LPWSTR =  ", $e.calpwstr) )		; VT_LPWSTR|VT_VECTOR
-				#case 0x100C ( #("vector of VARIANT ", $e.capropvar) )		; VT_VARIANT|VT_VECTOR
-				#case 0x100B ( #("vector of BOOL =  ", $e.cabool) )		    ; VT_BOOL|VT_VECTOR
-				#case 0x100A ( #("vector of ERROR =  ", $e.cascode) )			; VT_ERROR|VT_VECTOR
-				#case 0x1006 ( #("vector of CY = ", $e.cacy) )				; VT_CY|VT_VECTOR
-				#case 0x1007 ( #("vector of DATE =  ", $e.cadate) )			; VT_DATE|VT_VECTOR
-				#case 0x1040 ( #("vector of FILETIME =  ", $e.cafiletime) )	; VT_FILETIME|VT_VECTOR
-				#case 0x1048 ( #("vector of CLSID = ", $e.cauuid) )			; VT_CLSID|VT_VECTOR
-				#case 0x1047 ( #("vector of CF =  ", $e.caclipdata) )			; VT_CF|VT_VECTOR
-				#case 0x1008 ( #("vector of BSTR = ", $e.cabstr) )			; VT_BSTR|VT_VECTOR
-		
-				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-				;;   Byref Types                                            ;;
-				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-				#case 0x4016 ( #("byref of INT =  ", $e.pintVal) )				; VT_INT|VT_BYREF
-				#case 0x4017 ( #("byref of UINT = ", $e.puintVal) )				; VT_UINT|VT_BYREF
-				#case 0x4002 ( #("byref of I2 = ", $e.piVal) )					; VT_I2|VT_BYREF
-				#case 0x4003 ( #("byref of I4 = ", $e.plVal) )					; VT_I4|VT_BYREF
-				#case 0x4004 ( #("byref of R4 = ", $e.pfltVal) )					; VT_R4|VT_BYREF
-				#case 0x4005 ( #("byref of R8 = ", $e.pdblVal) )					; VT_R8|VT_BYREF
-				#case 0x4010 ( #("byref of I1 =  ", $e.pcVal) )					; VT_I1|VT_BYREF
-				#case 0x4011 ( #("byref of UI1 =  ", $e.pbVal) )					; VT_UI1|VT_BYREF
-				#case 0x4012 ( #("byref of UI2 =  ", $e.puiVal) )				; VT_UI2|VT_BYREF
-				#case 0x4013 ( #("byref of UI4 =  ", $e.pulVal) )				; VT_UI4|VT_BYREF
-				#case 0x400C ( #("byref of VARIANT ", $e.pvarVal) )				; VT_VARIANT|VT_BYREF
-				#case 0x400B ( #("byref of BOOL =  ", $e.pboolVal) )				; VT_BOOL|VT_BYREF
-				#case 0x400A ( #("byref of ERROR =  ", $e.pscode) )				; VT_ERROR|VT_BYREF
-				#case 0x4006 ( #("byref of CY = ", $e.pcyVal) )					; VT_CY|VT_BYREF
-				#case 0x4007 ( #("byref of DATE =  ", $e.pdate) )				; VT_DATE|VT_BYREF
-				#case 0x4008 ( #("byref of BSTR = ", $e.pbstrVal) )				; VT_BSTR|VT_BYREF
-				#case 0x400E ( #("byref of DECIMAL = ", $e.pdecVal) )			; VT_DECIMAL|VT_BYREF
-				#case 0x400D ( #("byref of UNKNOWN =  ", $e.ppunkVal) )			; VT_UNKNOWN|VT_BYREF
-				#case 0x4009 ( #("byref of DISPATCH =  ", $e.ppdispVal) )		; VT_DISPATCH|VT_BYREF
-				#case 0x6000 ( #("byref of ARRAY =  ", $e.pparray) )				; VT_ARRAY|VT_BYREF
-							
-				#default 
-				( 
-					#if ($e.vt & 0x2000)
-					(
-						$e.parray
-					)
-					#else
-					(
-						#("Unknown vt type = ", $e.vt) 
-					)
-				)
-	)
-	
-	
-	children(
-			#(vt: $e.vt, 
-			#switch ($e.vt)
-				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-				;;      Base Types                                          ;;
-				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-				#case 0x2 ( #(I2  : $e.iVal) )								; VT_I2
-				#case 0x3 ( #(I4  : $e.lVal) )								; VT_I4
-				#case 0x4 ( #(R4  : $e.fltVal) )								; VT_R4
-				#case 0x5 ( #(R8  : $e.dblVal) )								; VT_R8
-				#case 0x6 ( #(CY  : $e.cyVal) )								; VT_CY
-				#case 0x7 ( #(DATE   : $e.date) )								; VT_DATE
-				#case 0x8 ( #(BSTR  : $e.bstrVal) )							; VT_BSTR
-				#case 0x9 ( #(DISPATCH   : $e.pdispVal) )						; VT_DISPATCH
-				#case 0xA ( #(ERROR   : $e.scode) )							; VT_ERROR
-				#case 0xB ( #(BOOL   : $e.boolVal) )							; VT_BOOL
-				#case 0xD ( #(UNKNOWN   : $e.punkVal) )						; VT_UNKNOWN
-				#case 0xE ( #(DECIMAL  : $e.hVal) )							; VT_DECIMAL
-				#case 0x10 ( #(I1   : $e.cVal) )								; VT_I1
-				#case 0x11 ( #(UI1   : $e.bVal) )								; VT_UI1
-				#case 0x12 ( #(UI2   : $e.uiVal) )							; VT_UI2
-				#case 0x13 ( #(UI4   : $e.ulVal) )							; VT_UI4
-				#case 0x14 ( #(I8   : $e.hVal) )								; VT_I8
-				#case 0x15 ( #(UI8   : $e.uhVal) )							; VT_UI8
-				#case 0x16 ( #(INT   : $e.intVal) )							; VT_INT
-				#case 0x17 ( #(UINT  : $e.uintVal) )							; VT_UINT
-				#case 0x1E ( #(LPSTR   : $e.pszVal) )							; VT_LPSTR
-				#case 0x1F ( #(LPWSTR   : $e.pwszVal) )						; VT_LPWSTR
-				#case 0x40 ( #(FILETIME   : $e.filetime) )					; VT_FILETIME
-				#case 0x42 ( #(STREAM   : $e.pStream) )						; VT_STREAM
-				#case 0x43 ( #(STORAGE  : $e.pStorage) )						; VT_STORAGE
-				#case 0x44 ( #(STREAMED_OBJECT   : $e.pStream) )				; VT_STREAMED_OBJECT
-				#case 0x45 ( #(STORED_OBJECT   : $e.pStorage) )				; VT_STORED_OBJECT
-				#case 0x46 ( #(BLOB_OBJECT  : $e.blob ) )						; VT_BLOB_OBJECT
-				#case 0x47 ( #(CF   : $e.pclipdata) )							; VT_CF
-				#case 0x48 ( #(CLSID  : $e.puuid) )							; VT_CLSID
-				#case 0x49 ( #(VERSIONED_STREAM  : $e.pVersionedStream) )		; VT_VERSIONED_STREAM
-				
-				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-				;;   Vector types                                           ;;
-				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-				#case 0x1002 ( #(vector of I2  : $e.cai) )					; VT_I2|VT_VECTOR
-				#case 0x1003 ( #(vector of I4  : $e.cal) )					; VT_I4|VT_VECTOR
-				#case 0x1004 ( #(vector of R4  : $e.caflt) )					; VT_R4|VT_VECTOR
-				#case 0x1005 ( #(vector of R8  : $e.cadbl) )					; VT_R8|VT_VECTOR
-				#case 0x1010 ( #(vector of I1   : $e.cac) )					; VT_I1|VT_VECTOR
-				#case 0x1011 ( #(vector of UI1   : $e.caub) )					; VT_UI1|VT_VECTOR
-				#case 0x1012 ( #(vector of UI2   : $e.caui) )					; VT_UI2|VT_VECTOR
-				#case 0x1013 ( #(vector of UI4   : $e.caul) )					; VT_UI4|VT_VECTOR
-				#case 0x1014 ( #(vector of I8   : $e.cah) )					; VT_I8|VT_VECTOR
-				#case 0x1015 ( #(vector of UI8   : $e.cauh) )					; VT_UI8|VT_VECTOR
-				#case 0x101E ( #(vector of LPSTR   : $e.calpstr) )			; VT_LPSTR|VT_VECTOR
-				#case 0x101F ( #(vector of LPWSTR   : $e.calpwstr) )			; VT_LPWSTR|VT_VECTOR
-				#case 0x100C ( #(vector of VARIANT : $e.capropvar) )			; VT_VARIANT|VT_VECTOR
-				#case 0x100B ( #(vector of BOOL   : $e.cabool) )				; VT_BOOL|VT_VECTOR
-				#case 0x100A ( #(vector of ERROR   : $e.cascode) )			; VT_ERROR|VT_VECTOR
-				#case 0x1006 ( #(vector of CY  : $e.cacy) )					; VT_CY|VT_VECTOR
-				#case 0x1007 ( #(vector of DATE   : $e.cadate) )				; VT_DATE|VT_VECTOR
-				#case 0x1040 ( #(vector of FILETIME   : $e.cafiletime) )		; VT_FILETIME|VT_VECTOR
-				#case 0x1048 ( #(vector of CLSID  : $e.cauuid) )				; VT_CLSID|VT_VECTOR
-				#case 0x1047 ( #(vector of CF   : $e.caclipdata) )			; VT_CF|VT_VECTOR
-				#case 0x1008 ( #(vector of BSTR  : $e.cabstr) )				; VT_BSTR|VT_VECTOR
-
-				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-				;;   Byref Types                                            ;;
-				;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-				#case 0x4016 ( #(byref of INT   : $e.pintVal) )				; VT_INT|VT_BYREF
-				#case 0x4017 ( #(byref of UINT  : $e.puintVal) )				; VT_UINT|VT_BYREF
-				#case 0x4002 ( #(byref of I2  : $e.piVal) )					; VT_I2|VT_BYREF
-				#case 0x4003 ( #(byref of I4  : $e.plVal) )					; VT_I4|VT_BYREF
-				#case 0x4004 ( #(byref of R4  : $e.pfltVal) )				; VT_R4|VT_BYREF
-				#case 0x4005 ( #(byref of R8  : $e.pdblVal) )				; VT_R8|VT_BYREF
-				#case 0x4010 ( #(byref of I1   : $e.pcVal) )					; VT_I1|VT_BYREF
-				#case 0x4011 ( #(byref of UI1   : $e.pbVal) )				; VT_UI1|VT_BYREF
-				#case 0x4012 ( #(byref of UI2   : $e.puiVal) )				; VT_UI2|VT_BYREF
-				#case 0x4013 ( #(byref of UI4   : $e.pulVal) )				; VT_UI4|VT_BYREF
-				#case 0x400C ( #(byref of VARIANT : $e.pvarVal) )			; VT_VARIANT|VT_BYREF
-				#case 0x400B ( #(byref of BOOL   : $e.pboolVal) )			; VT_BOOL|VT_BYREF
-				#case 0x400A ( #(byref of ERROR   : $e.pscode) )				; VT_ERROR|VT_BYREF
-				#case 0x4006 ( #(byref of CY  : $e.pcyVal) )					; VT_CY|VT_BYREF
-				#case 0x4007 ( #(byref of DATE   : $e.pdate) )				; VT_DATE|VT_BYREF
-				#case 0x4008 ( #(byref of BSTR  : $e.pbstrVal) )				; VT_BSTR|VT_BYREF
-				#case 0x400E ( #(byref of DECIMAL  : $e.pdecVal) )			; VT_DECIMAL|VT_BYREF
-				#case 0x400D ( #(byref of UNKNOWN   : $e.ppunkVal) )			; VT_UNKNOWN|VT_BYREF
-				#case 0x4009 ( #(byref of DISPATCH   : $e.ppdispVal) )		; VT_DISPATCH|VT_BYREF
-				#case 0x6000 ( #(byref of ARRAY   : $e.pparray) )			; VT_ARRAY|VT_BYREF
-				
-				; the following are either empty or invalid vt values for a variant
-				; #case 0 ( #(Empty :) )										; VT_EMPTY
-				; #case 0x1 ( #(NULL :) )										; VT_NULL
-				; #case 0xC ( #(VARIANT :) )									; VT_VARIANT
-				; #case 0x18 ( #(VOID :) )										; VT_VOID
-				; #case 0x19 ( #(HRESULT :) )									; VT_HRESULT
-				; #case 0x1A ( #(PTR :) )										; VT_PTR
-				; #case 0x1B ( #(SAFEARRAY :) )									; VT_SAFEARRAY
-				; #case 0x1C ( #(CARRAY :) )									; VT_CARRAY
-				; #case 0x1D ( #(USERDEFINED :) )								; VT_USERDEFINED
-				; #case 0x24 ( #(RECORD  :) )									; VT_RECORD
-				; #case 0x26 ( #(UINT_PTR :) )									; VT_UINT_PTR
-							
-				#default 
-				( 
-					#if ($e.vt & 0x2000 )
-					(
-						#(safearray: $e.parray)
-					)
-					#else
-					(
-						#(
-							[raw members]: [$e,!]	; unformatted data members
-						)
-					)
-				)							
-				#except 
-				( 
-					#(
-						[raw members]: [$e,!]	; unformatted data members
-					)
-				)							
-	))
-}
-
-; This section lets you define your own errors for the HRESULT display.
-; You need to list the error code in unsigned decimal, followed by the message.
-; Changes will take effect the next time you redisplay the variable.
-[hresult]
-;1234=my custom error code
-
-
-
diff --git a/src/build.proj b/src/build.proj
index c4e9d4d011..419d1d5908 100644
--- a/src/build.proj
+++ b/src/build.proj
@@ -32,7 +32,7 @@
 
   <PropertyGroup>
     <RunEnforcePGO Condition="$(__EnforcePgo) == '1'">true</RunEnforcePGO>
-    <RunEnforcePGO Condition="$(__BuildArch) == 'arm' OR $(__BuildArch) == 'arm64'">false</RunEnforcePGO>
+    <RunEnforcePGO Condition="$(BuildArch) == 'arm' OR $(BuildArch) == 'arm64'">false</RunEnforcePGO>
   </PropertyGroup>
 
   <Target Name="EnforcePGO" Condition="$(RunEnforcePGO) == 'true'" AfterTargets="Build">
diff --git a/tests/dir.props b/tests/dir.props
index 9da3cb3791..296a29a4d7 100644
--- a/tests/dir.props
+++ b/tests/dir.props
@@ -1,13 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <!--
-    $(OS) is set to Unix/Windows_NT. This comes from an environment variable on Windows and MSBuild on Unix.
-  -->
-  <PropertyGroup>
-    <OsEnvironment Condition="'$(OsEnvironment)'=='' and '$(OS)'=='OSX'">Unix</OsEnvironment>
-    <OsEnvironment Condition="'$(OsEnvironment)'==''">$(OS)</OsEnvironment>
-  </PropertyGroup>
-  
   <Import Project="dir.sdkbuild.props" Condition="'$(UsingMicrosoftNETSdk)' == 'true'"  />
 
   <PropertyGroup>
@@ -62,8 +54,6 @@
     <BinDir>$(__BinDir)\</BinDir>
     <BinDir Condition="'$(__BinDir)'==''">$(RootBinDir)Product\$(BuildOS).$(BuildArch).$(BuildType)\</BinDir>
 
-    <CoreCLRBinDir>$(RootBinDir)Product\$(__BuildOS).$(__BuildArch).$(__BuildType)\</CoreCLRBinDir>
-
     <AltJitArch>$(__AltJitArch)</AltJitArch>
   </PropertyGroup>
 
diff --git a/tests/src/JIT/Methodical/tailcall/Desktop/thread-race.cs b/tests/src/JIT/Methodical/tailcall/Desktop/thread-race.cs
index 9746d34790..97acf33231 100644
--- a/tests/src/JIT/Methodical/tailcall/Desktop/thread-race.cs
+++ b/tests/src/JIT/Methodical/tailcall/Desktop/thread-race.cs
@@ -4,16 +4,24 @@
 
 using System;
 using System.Threading;
-using System.Runtime.CompilerServices;
 
 internal class Repro
 {
     private static volatile bool s_threadsCompleted;
     private static volatile Mutex s_myMutex;
     private static volatile int[] s_threadSum;
+    private const int FibSeriesMax = 35;
+    private const int FibSeriesMin = 20;
 
     public static int Main()
     {
+        // Compute the expected value for a single thread
+        int expectedSingle = 0;
+        for (int i = FibSeriesMin; i <= FibSeriesMax; i++)
+        {
+            expectedSingle += fib(0, i);
+        }
+
         ThreadStart ts = new ThreadStart(FibThread);
         Thread t1 = new Thread(ts);
         Thread t2 = new Thread(ts);
@@ -42,9 +50,9 @@ internal class Repro
 
         threadValue = (s_threadSum[0] + s_threadSum[1] + s_threadSum[2]);
 
-        if (((long)54018518 * 3) != threadValue)
+        if (((long)expectedSingle * 3) != threadValue)
         {
-            Console.WriteLine("FALSE: {0} != {1}", ((long)439201 * 3), threadValue);
+            Console.WriteLine("FALSE: {0} != {1}", ((long)expectedSingle * 3), threadValue);
             return 0;
         }
         else
@@ -57,9 +65,9 @@ internal class Repro
     public static void FibThread()
     {
         int sum = 0;
-        const int length = 35;
+        const int length = FibSeriesMax;
 
-        for (int i = 0; i <= length; i++)
+        for (int i = FibSeriesMin; i <= length; i++)
         {
             sum += fib(0, i);
             Console.WriteLine("" + i + ": " + sum);