diff --git a/Doc/library/pickle.rst b/Doc/library/pickle.rst
index 33bd9c9..520c24b 100644
--- a/Doc/library/pickle.rst
+++ b/Doc/library/pickle.rst
@@ -468,8 +468,9 @@
 namespace to determine the object's module.
 
 When a tuple is returned, it must be between two and five elements long.
-Optional elements can either be omitted, or ``None`` can be provided  as their
-value.  The semantics of each element are:
+Optional elements can either be omitted, or ``None`` can be provided as their
+value.  The contents of this tuple are pickled as normal and used to
+reconstruct the object at unpickling time.  The semantics of each element are:
 
 * A callable object that will be called to create the initial version of the
   object.  The next element of the tuple will provide arguments for this callable,
diff --git a/Doc/whatsnew/2.6.rst b/Doc/whatsnew/2.6.rst
index 26f5169..2098508 100644
--- a/Doc/whatsnew/2.6.rst
+++ b/Doc/whatsnew/2.6.rst
@@ -156,15 +156,18 @@
 
 .. seealso::
 
-  http://bugs.python.org: The Python bug tracker.
+  http://bugs.python.org 
+    The Python bug tracker.
 
-  http://bugs.jython.org: The Jython bug tracker.
+  http://bugs.jython.org:
+    The Jython bug tracker.
 
-  http://roundup.sourceforge.net/: Roundup downloads and documentation.
+  http://roundup.sourceforge.net/
+    Roundup downloads and documentation.
 
 
-New Documentation Format: ReStructured Text
---------------------------------------------------
+New Documentation Format: ReStructured Text Using Sphinx
+-----------------------------------------------------------
 
 Since the Python project's inception around 1989, the documentation
 had been written using LaTeX.  At that time, most documentation was
@@ -191,16 +194,20 @@
 a markup commonly used in the Python community that supports
 custom extensions  and directives.   Sphinx concentrates 
 on HTML output, producing attractively styled 
-and modern HTML, but printed output is still supported through 
-conversion to LaTeX as an output format.
+and modern HTML, though printed output is still supported through 
+conversion to LaTeX.  Sphinx is a standalone package that
+can be used in documenting other projects.
 
 .. seealso::
 
-   `Docutils <http://docutils.sf.net>`__: The fundamental
-   reStructured Text parser and toolset.
+   :ref:`documenting-index`
+       Describes how to write for Python's documentation.
 
-   :ref:`documenting-index`: Describes how to write for 
-   Python's documentation.
+   `Sphinx <http://sphinx.pocoo.org/>`__
+     Documentation and code for the Sphinx toolchain.
+
+   `Docutils <http://docutils.sf.net>`__
+     The underlying reStructured Text parser and toolset.
 
 
 PEP 343: The 'with' statement
@@ -487,8 +494,7 @@
     .. seealso::
 
        :pep:`370` - XXX
-
-       PEP written by XXX; implemented by Christian Heimes.
+         PEP written by XXX; implemented by Christian Heimes.
 
   
 .. ======================================================================
@@ -633,9 +639,8 @@
 =====================================================
 
 The ``print`` statement becomes the :func:`print` function in Python 3.0.
-Making :func:`print` a function makes it easier to replace within a
-module by doing 'def print(...)' or importing a new 
-function from somewhere else. 
+Making :func:`print` a function makes it easier to change 
+by doing 'def print(...)' or importing a new function from somewhere else. 
 
 Python 2.6 has a ``__future__`` import that removes ``print`` as language 
 syntax, letting you use the functional form instead.  For example::
@@ -750,13 +755,50 @@
 PEP 3118: Revised Buffer Protocol
 =====================================================
 
-The buffer protocol is a C-level API that lets Python extensions 
-XXX
+The buffer protocol is a C-level API that lets Python types
+exchange pointers into their internal representations.  A 
+memory-mapped file can be viewed as a buffer of characters, for
+example, and this lets another module such as :mod:`re`
+treat memory-mapped files as a string of characters to be searched.
+
+The primary users of the buffer protocol are numeric-processing
+packages such as NumPy, which can expose the internal representation
+of arrays so that callers can write data directly into an array instead
+of going through a slower API.  This PEP updates the buffer protocol in light of experience 
+from NumPy development, adding a number of new features
+such as indicating the shape of an array, 
+locking memory .
+
+The most important new C API function is 
+``PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)``, which
+takes an object and a set of flags, and fills in the
+``Py_buffer`` structure with information 
+about the object's memory representation.  Objects
+can use this operation to lock memory in place 
+while an external caller could be modifying the contents,
+so there's a corresponding 
+``PyObject_ReleaseBuffer(PyObject *obj, Py_buffer *view)`` to
+indicate that the external caller is done.
+
+The **flags** argument to :cfunc:`PyObject_GetBuffer` specifies
+constraints upon the memory returned.  Some examples are:
+
+ * :const:`PyBUF_WRITABLE` indicates that the memory must be writable.
+ 
+ * :const:`PyBUF_LOCK` requests a read-only or exclusive lock on the memory.
+
+ * :const:`PyBUF_C_CONTIGUOUS` and :const:`PyBUF_F_CONTIGUOUS`
+   requests a C-contiguous (last dimension varies the fastest) or
+   Fortran-contiguous (first dimension varies the fastest) layout.
+
+.. XXX this feature is not in 2.6 docs yet
 
 .. seealso::
 
    :pep:`3118` - Revising the buffer protocol
-      PEP written by Travis Oliphant and Carl Banks.
+      PEP written by Travis Oliphant and Carl Banks; implemented by
+      Travis Oliphant.
+      
 
 .. ======================================================================
 
@@ -765,41 +807,142 @@
 PEP 3119: Abstract Base Classes
 =====================================================
 
-XXX write this -- this section is currently just brief notes.
+Some object-oriented languages such as Java support interfaces: declarations
+that a class has a given set of methods or supports a given access protocol.
+Abstract Base Classes (or ABCs) are an equivalent feature for Python. The ABC
+support consists of an :mod:`abc` module containing a metaclass called 
+:class:`ABCMeta`, special handling
+of this metaclass by the :func:`isinstance` and :func:`issubclass` built-ins,
+and a collection of basic ABCs that the Python developers think will be widely
+useful.
 
-How to identify a file object?
+Let's say you have a particular class and wish to know whether it supports 
+dictionary-style access.  The phrase "dictionary-style" is vague, however.
+It probably means that accessing items with ``obj[1]`` works.  
+Does it imply that setting items with ``obj[2] = value`` works?  
+Or that the object will have :meth:`keys`, :meth:`values`, and :meth:`items`
+methods?  What about the iterative variants  such as :meth:`iterkeys`?  :meth:`copy`
+and :meth:`update`?  Iterating over the object with :func:`iter`?
 
-ABCs are a collection of classes describing various interfaces.
-Classes can derive from an ABC to indicate they support that ABC's
-interface.  Concrete classes should obey the semantics specified by 
-an ABC, but Python can't check this; it's up to the implementor.
+Python 2.6 includes a number of different ABCs in the :mod:`collections`
+module.  :class:`Iterable` indicates that a class defines :meth:`__iter__`,
+and :class:`Container` means the class supports  ``x in y`` expressions
+by defining a :meth:`__contains__` method.  The basic dictionary interface of
+getting items, setting items, and 
+:meth:`keys`, :meth:`values`, and :meth:`items`, is defined by the
+:class:`MutableMapping` ABC.
 
-A metaclass lets you declare that an existing class or type
-derives from a particular ABC.  You can even 
+You can derive your own classes from a particular ABC
+to indicate they support that ABC's interface::
 
-class AppendableSequence:
-    __metaclass__ = ABCMeta
+    import collections
+  
+    class Storage(collections.MutableMapping):
+        ...
 
-AppendableSequence.register(list)
-assert issubclass(list, AppendableSequence)
-assert isinstance([], AppendableSequence)
 
-@abstractmethod decorator -- you can't instantiate classes w/
-an abstract method.
+Alternatively, you could write the class without deriving from 
+the desired ABC and instead register the class by
+calling the ABC's :meth:`register` method::
 
-::
+    import collections
+    
+    class Storage:
+        ...
+	
+    collections.MutableMapping.register(Storage)
+    
+For classes that you write, deriving from the ABC is probably clearer.
+The :meth:`register`  method is useful when you've written a new
+ABC that can describe an existing type or class, or if you want
+to declare that some third-party class implements an ABC.
+For example, if you defined a :class:`PrintableType` ABC,
+it's legal to do:
 
-    @abstractproperty decorator
+  # Register Python's types
+  PrintableType.register(int)
+  PrintableType.register(float)
+  PrintableType.register(str)
+
+Classes should obey the semantics specified by an ABC, but 
+Python can't check this; it's up to the class author to  
+understand the ABC's requirements and to implement the code accordingly.
+
+To check whether an object supports a particular interface, you can
+now write::
+
+    def func(d):
+	if not isinstance(d, collections.MutableMapping):
+	    raise ValueError("Mapping object expected, not %r" % d)        
+
+(Don't feel that you must now begin writing lots of checks as in the 
+above example.  Python has a strong tradition of duck-typing, where 
+explicit type-checking isn't done and code simply calls methods on 
+an object, trusting that those methods will be there and raising an
+exception if they aren't.  Be judicious in checking for ABCs
+and only do it where it helps.)
+
+You can write your own ABCs by using ``abc.ABCMeta`` as the
+metaclass in a class definition::
+
+  from abc import ABCMeta
+
+  class Drawable():
+      __metaclass__ = ABCMeta
+  
+      def draw(self, x, y, scale=1.0):
+	  pass
+
+      def draw_doubled(self, x, y):
+	  self.draw(x, y, scale=2.0)
+
+	
+  class Square(Drawable):
+      def draw(self, x, y, scale):
+          ...
+
+	  
+In the :class:`Drawable` ABC above, the :meth:`draw_doubled` method
+renders the object at twice its size and can be implemented in terms
+of other methods described in :class:`Drawable`.  Classes implementing
+this ABC therefore don't need to provide their own implementation 
+of :meth:`draw_doubled`, though they can do so.  An implementation
+of :meth:`draw` is necessary, though; the ABC can't provide 
+a useful generic implementation.  You 
+can apply the ``@abstractmethod`` decorator to methods such as 
+:meth:`draw` that must be implemented; Python will 
+then raise an exception for classes that 
+don't define the method::
+
+    class Drawable():
+	__metaclass__ = ABCMeta
+    
+	@abstractmethod
+	def draw(self, x, y, scale):
+	    pass
+
+Note that the exception is only raised when you actually 
+try to create an instance of a subclass without the method::
+
+    >>> s=Square()
+    Traceback (most recent call last):
+      File "<stdin>", line 1, in <module>
+    TypeError: Can't instantiate abstract class Square with abstract methods draw
+    >>> 
+
+Abstract data attributes can be declared using the ``@abstractproperty`` decorator::
+
     @abstractproperty
     def readonly(self):
        return self._x
 
+Subclasses must then define a :meth:`readonly` property 
 
 .. seealso::
 
    :pep:`3119` - Introducing Abstract Base Classes
       PEP written by Guido van Rossum and Talin.
-      Implemented by XXX.
+      Implemented by Guido van Rossum.
       Backported to 2.6 by Benjamin Aranguren, with Alex Martelli.
 
 .. ======================================================================
diff --git a/Tools/msi/merge.py b/Tools/msi/merge.py
new file mode 100644
index 0000000..aa26122
--- /dev/null
+++ b/Tools/msi/merge.py
@@ -0,0 +1,70 @@
+import msilib,os,win32com,tempfile
+PCBUILD="PCBuild"
+from config import *
+
+Win64 = "amd64" in PCBUILD
+
+mod_dir = os.path.join(os.environ["ProgramFiles"], "Common Files", "Merge Modules")
+if Win64:
+    modules = ["Microsoft_VC90_CRT_x86.msm", "policy_8_0_Microsoft_VC80_CRT_x86_x64.msm"]
+    msi = "python-%s.amd64.msi" % full_current_version
+else:
+    modules = ["Microsoft_VC90_CRT_x86.msm","policy_8_0_Microsoft_VC80_CRT_x86.msm"]
+    msi = "python-%s.msi" % full_current_version
+for i, n in enumerate(modules):
+    modules[i] = os.path.join(mod_dir, n)
+
+def merge(msi, feature, rootdir, modules):
+    cab_and_filecount = []
+    # Step 1: Merge databases, extract cabfiles
+    m = msilib.MakeMerge2()
+    m.OpenLog("merge.log")
+    print "Opened Log"
+    m.OpenDatabase(msi)
+    print "Opened DB"
+    for module in modules:
+        print module
+        m.OpenModule(module,0)
+        print "Opened Module",module
+        m.Merge(feature, rootdir)
+        print "Errors:"
+        for e in m.Errors:
+            print e.Type, e.ModuleTable, e.DatabaseTable
+            print "   Modkeys:",
+            for s in e.ModuleKeys: print s,
+            print
+            print "   DBKeys:",
+            for s in e.DatabaseKeys: print s,
+            print
+        cabname = tempfile.mktemp(suffix=".cab")
+        m.ExtractCAB(cabname)
+        cab_and_filecount.append((cabname, len(m.ModuleFiles)))
+        m.CloseModule()
+    m.CloseDatabase(True)
+    m.CloseLog()
+
+    # Step 2: Add CAB files
+    i = msilib.MakeInstaller()
+    db = i.OpenDatabase(msi, win32com.client.constants.msiOpenDatabaseModeTransact)
+
+    v = db.OpenView("SELECT LastSequence FROM Media")
+    v.Execute(None)
+    maxmedia = -1
+    while 1:
+        r = v.Fetch()
+        if not r: break
+        seq = r.IntegerData(1)
+        if seq > maxmedia:
+            maxmedia = seq
+    print "Start of Media", maxmedia
+
+    for cabname, count in cab_and_filecount:
+        stream = "merged%d" % maxmedia
+        msilib.add_data(db, "Media",
+                [(maxmedia+1, maxmedia+count, None, "#"+stream, None, None)])
+        msilib.add_stream(db, stream,  cabname)
+        os.unlink(cabname)
+        maxmedia += count
+    db.Commit()
+
+merge(msi, "SharedCRT", "TARGETDIR", modules)
diff --git a/Tools/msi/msi.py b/Tools/msi/msi.py
index 08b759c..6a228be 100644
--- a/Tools/msi/msi.py
+++ b/Tools/msi/msi.py
@@ -799,6 +799,12 @@
     default_feature = Feature(db, "DefaultFeature", "Python",
                               "Python Interpreter and Libraries",
                               1, directory = "TARGETDIR")
+    shared_crt = Feature(db, "SharedCRT", "MSVCRT", "C Run-Time (system-wide)", 0,
+                         level=0)
+    private_crt = Feature(db, "PrivateCRT", "MSVCRT", "C Run-Time (private)", 0,
+                          level=0)
+    add_data(db, "Condition", [("SharedCRT", 1, sys32cond),
+                               ("PrivateCRT", 1, "not "+sys32cond)])
     # We don't support advertisement of extensions
     ext_feature = Feature(db, "Extensions", "Register Extensions",
                           "Make this Python installation the default Python installation", 3,
@@ -899,7 +905,7 @@
     DLLs = PyDirectory(db, cab, root, srcdir + "/" + PCBUILD, "DLLs", "DLLS|DLLs")
     # XXX determine dependencies
     if MSVCR == "90":
-        root.start_component("msvcr90")
+        root.start_component("msvcr90", feature=private_crt)
         for file, kw in extract_msvcr90():
             root.add_file(file, **kw)
             if file.endswith("manifest"):
diff --git a/Tools/msi/schema.py b/Tools/msi/schema.py
index 7a3e797..d028a11 100644
--- a/Tools/msi/schema.py
+++ b/Tools/msi/schema.py
@@ -18,7 +18,7 @@
 ActionText.add_field(3,'Template',7936)
 
 AdminExecuteSequence = Table('AdminExecuteSequence')
-AdminExecuteSequence.add_field(1,'Action',11592)
+AdminExecuteSequence.add_field(1,'Action',0x2DFF)
 AdminExecuteSequence.add_field(2,'Condition',7679)
 AdminExecuteSequence.add_field(3,'Sequence',5378)
 
@@ -28,12 +28,12 @@
 Condition.add_field(3,'Condition',7679)
 
 AdminUISequence = Table('AdminUISequence')
-AdminUISequence.add_field(1,'Action',11592)
+AdminUISequence.add_field(1,'Action',0x2DFF)
 AdminUISequence.add_field(2,'Condition',7679)
 AdminUISequence.add_field(3,'Sequence',5378)
 
 AdvtExecuteSequence = Table('AdvtExecuteSequence')
-AdvtExecuteSequence.add_field(1,'Action',11592)
+AdvtExecuteSequence.add_field(1,'Action',0x2DFF)
 AdvtExecuteSequence.add_field(2,'Condition',7679)
 AdvtExecuteSequence.add_field(3,'Sequence',5378)
 
@@ -83,7 +83,7 @@
 Feature.add_field(4,'Description',8191)
 Feature.add_field(5,'Display',5378)
 Feature.add_field(6,'Level',1282)
-Feature.add_field(7,'Directory_',7496)
+Feature.add_field(7,'Directory_',0x1DFF)
 Feature.add_field(8,'Attributes',1282)
 
 Binary = Table('Binary')
@@ -91,15 +91,15 @@
 Binary.add_field(2,'Data',2304)
 
 BindImage = Table('BindImage')
-BindImage.add_field(1,'File_',11592)
+BindImage.add_field(1,'File_',0x2DFF)
 BindImage.add_field(2,'Path',7679)
 
 File = Table('File')
-File.add_field(1,'File',11592)
-File.add_field(2,'Component_',3400)
+File.add_field(1,'File',0x2DFF)
+File.add_field(2,'Component_',0xDFF)
 File.add_field(3,'FileName',4095)
 File.add_field(4,'FileSize',260)
-File.add_field(5,'Version',7496)
+File.add_field(5,'Version',0x1DFF)
 File.add_field(6,'Language',7444)
 File.add_field(7,'Attributes',5378)
 File.add_field(8,'Sequence',1282)
@@ -114,7 +114,7 @@
 Class = Table('Class')
 Class.add_field(1,'CLSID',11558)
 Class.add_field(2,'Context',11552)
-Class.add_field(3,'Component_',11592)
+Class.add_field(3,'Component_',0x2DFF)
 Class.add_field(4,'ProgId_Default',7679)
 Class.add_field(5,'Description',8191)
 Class.add_field(6,'AppId_',7462)
@@ -127,12 +127,12 @@
 Class.add_field(13,'Attributes',5378)
 
 Component = Table('Component')
-Component.add_field(1,'Component',11592)
+Component.add_field(1,'Component',0x2DFF)
 Component.add_field(2,'ComponentId',7462)
-Component.add_field(3,'Directory_',3400)
+Component.add_field(3,'Directory_',0xDFF)
 Component.add_field(4,'Attributes',1282)
 Component.add_field(5,'Condition',7679)
-Component.add_field(6,'KeyPath',7496)
+Component.add_field(6,'KeyPath',0x1DFF)
 
 Icon = Table('Icon')
 Icon.add_field(1,'Name',11592)
@@ -158,12 +158,12 @@
 CompLocator.add_field(3,'Type',5378)
 
 Complus = Table('Complus')
-Complus.add_field(1,'Component_',11592)
+Complus.add_field(1,'Component_',0x2DFF)
 Complus.add_field(2,'ExpType',13570)
 
 Directory = Table('Directory')
-Directory.add_field(1,'Directory',11592)
-Directory.add_field(2,'Directory_Parent',7496)
+Directory.add_field(1,'Directory',0x2DFF)
+Directory.add_field(2,'Directory_Parent',0x1DFF)
 Directory.add_field(3,'DefaultDir',4095)
 
 Control = Table('Control')
@@ -207,13 +207,13 @@
 ControlEvent.add_field(6,'Ordering',5378)
 
 CreateFolder = Table('CreateFolder')
-CreateFolder.add_field(1,'Directory_',11592)
-CreateFolder.add_field(2,'Component_',11592)
+CreateFolder.add_field(1,'Directory_',0x2DFF)
+CreateFolder.add_field(2,'Component_',0x2DFF)
 
 CustomAction = Table('CustomAction')
-CustomAction.add_field(1,'Action',11592)
+CustomAction.add_field(1,'Action',0x2DFF)
 CustomAction.add_field(2,'Type',1282)
-CustomAction.add_field(3,'Source',7496)
+CustomAction.add_field(3,'Source',0x1DFF)
 CustomAction.add_field(4,'Target',7679)
 
 DrLocator = Table('DrLocator')
@@ -224,8 +224,8 @@
 
 DuplicateFile = Table('DuplicateFile')
 DuplicateFile.add_field(1,'FileKey',11592)
-DuplicateFile.add_field(2,'Component_',3400)
-DuplicateFile.add_field(3,'File_',3400)
+DuplicateFile.add_field(2,'Component_',0xDFF)
+DuplicateFile.add_field(3,'File_',0xDFF)
 DuplicateFile.add_field(4,'DestName',8191)
 DuplicateFile.add_field(5,'DestFolder',7496)
 
@@ -233,7 +233,7 @@
 Environment.add_field(1,'Environment',11592)
 Environment.add_field(2,'Name',4095)
 Environment.add_field(3,'Value',8191)
-Environment.add_field(4,'Component_',3400)
+Environment.add_field(4,'Component_',0xDFF)
 
 Error = Table('Error')
 Error.add_field(1,'Error',9474)
@@ -247,7 +247,7 @@
 
 Extension = Table('Extension')
 Extension.add_field(1,'Extension',11775)
-Extension.add_field(2,'Component_',11592)
+Extension.add_field(2,'Component_',0x2DFF)
 Extension.add_field(3,'ProgId_',7679)
 Extension.add_field(4,'MIME_',7488)
 Extension.add_field(5,'Feature_',3366)
@@ -259,10 +259,10 @@
 
 FeatureComponents = Table('FeatureComponents')
 FeatureComponents.add_field(1,'Feature_',11558)
-FeatureComponents.add_field(2,'Component_',11592)
+FeatureComponents.add_field(2,'Component_',0x2DFF)
 
 FileSFPCatalog = Table('FileSFPCatalog')
-FileSFPCatalog.add_field(1,'File_',11592)
+FileSFPCatalog.add_field(1,'File_',0x2DFF)
 FileSFPCatalog.add_field(2,'SFPCatalog_',11775)
 
 SFPCatalog = Table('SFPCatalog')
@@ -271,7 +271,7 @@
 SFPCatalog.add_field(3,'Dependency',7424)
 
 Font = Table('Font')
-Font.add_field(1,'File_',11592)
+Font.add_field(1,'File_',0x2DFF)
 Font.add_field(2,'FontTitle',7552)
 
 IniFile = Table('IniFile')
@@ -282,7 +282,7 @@
 IniFile.add_field(5,'Key',3968)
 IniFile.add_field(6,'Value',4095)
 IniFile.add_field(7,'Action',1282)
-IniFile.add_field(8,'Component_',3400)
+IniFile.add_field(8,'Component_',0xDFF)
 
 IniLocator = Table('IniLocator')
 IniLocator.add_field(1,'Signature_',11592)
@@ -293,18 +293,18 @@
 IniLocator.add_field(6,'Type',5378)
 
 InstallExecuteSequence = Table('InstallExecuteSequence')
-InstallExecuteSequence.add_field(1,'Action',11592)
+InstallExecuteSequence.add_field(1,'Action',0x2DFF)
 InstallExecuteSequence.add_field(2,'Condition',7679)
 InstallExecuteSequence.add_field(3,'Sequence',5378)
 
 InstallUISequence = Table('InstallUISequence')
-InstallUISequence.add_field(1,'Action',11592)
+InstallUISequence.add_field(1,'Action',0x2DFF)
 InstallUISequence.add_field(2,'Condition',7679)
 InstallUISequence.add_field(3,'Sequence',5378)
 
 IsolatedComponent = Table('IsolatedComponent')
-IsolatedComponent.add_field(1,'Component_Shared',11592)
-IsolatedComponent.add_field(2,'Component_Application',11592)
+IsolatedComponent.add_field(1,'Component_Shared',0x2DFF)
+IsolatedComponent.add_field(2,'Component_Application',0x2DFF)
 
 LaunchCondition = Table('LaunchCondition')
 LaunchCondition.add_field(1,'Condition',11775)
@@ -340,7 +340,7 @@
 
 MoveFile = Table('MoveFile')
 MoveFile.add_field(1,'FileKey',11592)
-MoveFile.add_field(2,'Component_',3400)
+MoveFile.add_field(2,'Component_',0xDFF)
 MoveFile.add_field(3,'SourceName',8191)
 MoveFile.add_field(4,'DestName',8191)
 MoveFile.add_field(5,'SourceFolder',7496)
@@ -348,14 +348,14 @@
 MoveFile.add_field(7,'Options',1282)
 
 MsiAssembly = Table('MsiAssembly')
-MsiAssembly.add_field(1,'Component_',11592)
+MsiAssembly.add_field(1,'Component_',0x2DFF)
 MsiAssembly.add_field(2,'Feature_',3366)
-MsiAssembly.add_field(3,'File_Manifest',7496)
-MsiAssembly.add_field(4,'File_Application',7496)
+MsiAssembly.add_field(3,'File_Manifest',0x1DFF)
+MsiAssembly.add_field(4,'File_Application',0x1DFF)
 MsiAssembly.add_field(5,'Attributes',5378)
 
 MsiAssemblyName = Table('MsiAssemblyName')
-MsiAssemblyName.add_field(1,'Component_',11592)
+MsiAssemblyName.add_field(1,'Component_',0x2DFF)
 MsiAssemblyName.add_field(2,'Name',11775)
 MsiAssemblyName.add_field(3,'Value',3583)
 
@@ -370,7 +370,7 @@
 MsiDigitalSignature.add_field(4,'Hash',6400)
 
 MsiFileHash = Table('MsiFileHash')
-MsiFileHash.add_field(1,'File_',11592)
+MsiFileHash.add_field(1,'File_',0x2DFF)
 MsiFileHash.add_field(2,'Options',1282)
 MsiFileHash.add_field(3,'HashPart1',260)
 MsiFileHash.add_field(4,'HashPart2',260)
@@ -388,14 +388,14 @@
 
 ODBCDriver = Table('ODBCDriver')
 ODBCDriver.add_field(1,'Driver',11592)
-ODBCDriver.add_field(2,'Component_',3400)
+ODBCDriver.add_field(2,'Component_',0xDFF)
 ODBCDriver.add_field(3,'Description',3583)
-ODBCDriver.add_field(4,'File_',3400)
-ODBCDriver.add_field(5,'File_Setup',7496)
+ODBCDriver.add_field(4,'File_',0xDFF)
+ODBCDriver.add_field(5,'File_Setup',0x1DFF)
 
 ODBCDataSource = Table('ODBCDataSource')
-ODBCDataSource.add_field(1,'DataSource',11592)
-ODBCDataSource.add_field(2,'Component_',3400)
+ODBCDataSource.add_field(1,'DataSource',0x2DFF)
+ODBCDataSource.add_field(2,'Component_',0xDFF)
 ODBCDataSource.add_field(3,'Description',3583)
 ODBCDataSource.add_field(4,'DriverDescription',3583)
 ODBCDataSource.add_field(5,'Registration',1282)
@@ -407,10 +407,10 @@
 
 ODBCTranslator = Table('ODBCTranslator')
 ODBCTranslator.add_field(1,'Translator',11592)
-ODBCTranslator.add_field(2,'Component_',3400)
+ODBCTranslator.add_field(2,'Component_',0xDFF)
 ODBCTranslator.add_field(3,'Description',3583)
-ODBCTranslator.add_field(4,'File_',3400)
-ODBCTranslator.add_field(5,'File_Setup',7496)
+ODBCTranslator.add_field(4,'File_',0xDFF)
+ODBCTranslator.add_field(5,'File_Setup',0x1DFF)
 
 Patch = Table('Patch')
 Patch.add_field(1,'File_',11592)
@@ -427,7 +427,7 @@
 PublishComponent = Table('PublishComponent')
 PublishComponent.add_field(1,'ComponentId',11558)
 PublishComponent.add_field(2,'Qualifier',11775)
-PublishComponent.add_field(3,'Component_',11592)
+PublishComponent.add_field(3,'Component_',0x2DFF)
 PublishComponent.add_field(4,'AppData',8191)
 PublishComponent.add_field(5,'Feature_',3366)
 
@@ -443,12 +443,12 @@
 RadioButton.add_field(9,'Help',7986)
 
 Registry = Table('Registry')
-Registry.add_field(1,'Registry',11592)
+Registry.add_field(1,'Registry',0x2DFF)
 Registry.add_field(2,'Root',1282)
 Registry.add_field(3,'Key',4095)
 Registry.add_field(4,'Name',8191)
 Registry.add_field(5,'Value',7936)
-Registry.add_field(6,'Component_',3400)
+Registry.add_field(6,'Component_',0xDFF)
 
 RegLocator = Table('RegLocator')
 RegLocator.add_field(1,'Signature_',11592)
@@ -459,7 +459,7 @@
 
 RemoveFile = Table('RemoveFile')
 RemoveFile.add_field(1,'FileKey',11592)
-RemoveFile.add_field(2,'Component_',3400)
+RemoveFile.add_field(2,'Component_',0xDFF)
 RemoveFile.add_field(3,'FileName',8191)
 RemoveFile.add_field(4,'DirProperty',3400)
 RemoveFile.add_field(5,'InstallMode',1282)
@@ -472,24 +472,24 @@
 RemoveIniFile.add_field(5,'Key',3968)
 RemoveIniFile.add_field(6,'Value',8191)
 RemoveIniFile.add_field(7,'Action',1282)
-RemoveIniFile.add_field(8,'Component_',3400)
+RemoveIniFile.add_field(8,'Component_',0xDFF)
 
 RemoveRegistry = Table('RemoveRegistry')
 RemoveRegistry.add_field(1,'RemoveRegistry',11592)
 RemoveRegistry.add_field(2,'Root',1282)
 RemoveRegistry.add_field(3,'Key',4095)
 RemoveRegistry.add_field(4,'Name',8191)
-RemoveRegistry.add_field(5,'Component_',3400)
+RemoveRegistry.add_field(5,'Component_',0xDFF)
 
 ReserveCost = Table('ReserveCost')
 ReserveCost.add_field(1,'ReserveKey',11592)
-ReserveCost.add_field(2,'Component_',3400)
+ReserveCost.add_field(2,'Component_',0xDFF)
 ReserveCost.add_field(3,'ReserveFolder',7496)
 ReserveCost.add_field(4,'ReserveLocal',260)
 ReserveCost.add_field(5,'ReserveSource',260)
 
 SelfReg = Table('SelfReg')
-SelfReg.add_field(1,'File_',11592)
+SelfReg.add_field(1,'File_',0x2DFF)
 SelfReg.add_field(2,'Cost',5378)
 
 ServiceControl = Table('ServiceControl')
@@ -498,7 +498,7 @@
 ServiceControl.add_field(3,'Event',1282)
 ServiceControl.add_field(4,'Arguments',8191)
 ServiceControl.add_field(5,'Wait',5378)
-ServiceControl.add_field(6,'Component_',3400)
+ServiceControl.add_field(6,'Component_',0xDFF)
 
 ServiceInstall = Table('ServiceInstall')
 ServiceInstall.add_field(1,'ServiceInstall',11592)
@@ -512,14 +512,14 @@
 ServiceInstall.add_field(9,'StartName',7679)
 ServiceInstall.add_field(10,'Password',7679)
 ServiceInstall.add_field(11,'Arguments',7679)
-ServiceInstall.add_field(12,'Component_',3400)
+ServiceInstall.add_field(12,'Component_',0xDFF)
 ServiceInstall.add_field(13,'Description',8191)
 
 Shortcut = Table('Shortcut')
 Shortcut.add_field(1,'Shortcut',11592)
-Shortcut.add_field(2,'Directory_',3400)
+Shortcut.add_field(2,'Directory_',0xDFF)
 Shortcut.add_field(3,'Name',3968)
-Shortcut.add_field(4,'Component_',3400)
+Shortcut.add_field(4,'Component_',0xDFF)
 Shortcut.add_field(5,'Target',3400)
 Shortcut.add_field(6,'Arguments',7679)
 Shortcut.add_field(7,'Description',8191)
@@ -550,10 +550,10 @@
 TypeLib = Table('TypeLib')
 TypeLib.add_field(1,'LibID',11558)
 TypeLib.add_field(2,'Language',9474)
-TypeLib.add_field(3,'Component_',11592)
+TypeLib.add_field(3,'Component_',0x2DFF)
 TypeLib.add_field(4,'Version',4356)
 TypeLib.add_field(5,'Description',8064)
-TypeLib.add_field(6,'Directory_',7496)
+TypeLib.add_field(6,'Directory_',0x1DFF)
 TypeLib.add_field(7,'Feature_',3366)
 TypeLib.add_field(8,'Cost',4356)
 
