--- a
+++ b/trunk/cforge/packages/IronPython-2.7.7/Platforms/Net45/IronPython.xml
@@ -0,0 +1,7643 @@
+<?xml version="1.0"?>
+<doc>
+    <assembly>
+        <name>IronPython</name>
+    </assembly>
+    <members>
+        <member name="T:IronPython.Compiler.Ast.SerializedScopeStatement">
+            <summary>
+            Fake ScopeStatement for FunctionCode's to hold on to after we have deserialized pre-compiled code.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.Ast.CollectableCompilationMode">
+            <summary>
+            A global allocator that puts all of the globals into an array access.  The array is an
+            array of PythonGlobal objects.  We then just close over the array for any inner functions.
+            
+            Once compiled a RuntimeScriptCode is produced which is closed over the entire execution
+            environment.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.Ast.UncollectableCompilationMode">
+            <summary>
+            Implements globals which are backed by a static type, followed by an array if the static types' slots become full.  The global
+            variables are stored in static fields on a type for fast access.  The type also includes fields for constants and call sites
+            so they can be accessed much fasetr.
+            
+            We don't generate any code into the type though - DynamicMethod's are much faster for code gen then normal ref emit.
+            </summary>
+            <summary>
+            Implements globals which are backed by a static type, followed by an array if the static types' slots become full.  The global
+            variables are stored in static fields on a type for fast access.  The type also includes fields for constants and call sites
+            so they can be accessed much fasetr.
+            
+            We don't generate any code into the type though - DynamicMethod's are much faster for code gen then normal ref emit.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.StorageData.ContextStorageType(System.Int32)">
+            <summary>Ensures the underlying array is long enough to accomodate the given index</summary>
+            <returns>The context storage type corresponding to the given index</returns>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.StorageData.ConstantStorageType(System.Int32)">
+            <summary>Ensures the underlying array is long enough to accomodate the given index</summary>
+            <returns>The constant storage type corresponding to the given index</returns>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.StorageData.GlobalStorageType(System.Int32)">
+            <summary>Ensures the underlying array is long enough to accomodate the given index</summary>
+            <returns>The global storage type corresponding to the given index</returns>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.SiteStorage`1.SiteStorageType(System.Int32)">
+            <summary>Ensures the underlying array is long enough to accomodate the given index</summary>
+            <returns>The site storage type corresponding to the given index</returns>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.ClassDefinition.GetParentClosureTuple">
+            <summary>
+            Gets the closure tuple from our parent context.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.FunctionDefinition.GetParentClosureTuple">
+            <summary>
+            Pulls the closure tuple from our function/generator which is flowed into each function call.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.FunctionDefinition.MakeFunctionExpression">
+            <summary>
+            Returns an expression which creates the function object.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.FunctionDefinition.EnsureFunctionLambda">
+            <summary>
+            Creates the LambdaExpression which is the actual function body.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.FunctionDefinition.CreateFunctionLambda">
+            <summary>
+            Creates the LambdaExpression which implements the body of the function.
+            
+            The functions signature is either "object Function(PythonFunction, ...)"
+            where there is one object parameter for each user defined parameter or
+            object Function(PythonFunction, object[]) for functions which take more
+            than PythonCallTargets.MaxArgs arguments.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.FunctionDefinition.GetDelegateType(IronPython.Compiler.Ast.Parameter[],System.Boolean,System.Delegate@)">
+            <summary>
+            Determines delegate type for the Python function
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.Ast.FunctionDefinition.ArbitraryGlobalsVisitor">
+            <summary>
+            Rewrites the tree for performing lookups against globals instead of being bound
+            against the optimized scope. This is used if the user creates a function using public
+            PythonFunction ctor.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.Ast.ComprehensionScope">
+            <summary>
+            Scope for the comprehension.  Because scopes are usually statements and comprehensions are expressions
+            this doesn't actually show up in the AST hierarchy and instead hangs off the comprehension expression.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.Ast.LookupCompilationMode">
+            <summary>
+            Provides globals for when we need to lookup into a dictionary for each global access.
+            
+            This is the slowest form of globals and is only used when we need to run against an
+            arbitrary dictionary given to us by a user.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.Node.CanThrow">
+            <summary>
+            Returns true if the node can throw, false otherwise.  Used to determine
+            whether or not we need to update the current dynamic stack info.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.Node.AddFrame(System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression)">
+            <summary>
+            Creates a method frame for tracking purposes and enforces recursion
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.Node.RemoveFrame(System.Linq.Expressions.Expression)">
+            <summary>
+            Removes the frames from generated code for when we're compiling the tracing delegate
+            which will track the frames it's self.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.Node.LineNumberUpdated">
+            <summary>
+            A temporary variable to track if the current line number has been emitted via the fault update block.
+            
+            For example consider:
+            
+            try:
+                raise Exception()
+            except Exception, e:
+                # do something here
+                raise
+                
+            At "do something here" we need to have already emitted the line number, when we re-raise we shouldn't add it 
+            again.  If we handled the exception then we should have set the bool back to false.
+            
+            We also sometimes directly check _lineNoUpdated to avoid creating this unless we have nested exceptions.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.Node.LineNumberExpression">
+            <summary>
+            A temporary variable to track the current line number
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.Ast.Parameter">
+            <summary>
+            Parameter base class
+            </summary>
+        </member>
+        <member name="F:IronPython.Compiler.Ast.Parameter._name">
+            <summary>
+            Position of the parameter: 0-based index
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.Parameter.Name">
+            <summary>
+            Parameter name
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.Ast.PythonAst">
+            <summary>
+            Top-level ast for all Python code.  Typically represents a module but could also
+            be exec or eval code.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.PythonAst.#ctor(System.Boolean,IronPython.Runtime.ModuleOptions,System.Boolean,Microsoft.Scripting.Runtime.CompilerContext)">
+            <summary>
+            Creates a new PythonAst without a body.  ParsingFinished should be called afterwards to set
+            the body.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.PythonAst.ParsingFinished(System.Int32[],IronPython.Compiler.Ast.Statement,IronPython.Runtime.ModuleOptions)">
+            <summary>
+            Called when parsing is complete, the body is built, the line mapping and language features are known.
+            
+            This is used in conjunction with the constructor which does not take a body.  It enables creating
+            the outer most PythonAst first so that nodes can always have a global parent.  This lets an un-bound
+            tree to still provide it's line information immediately after parsing.  When we set the location
+            of each node during construction we also set the global parent.  When we name bind the global 
+            parent gets replaced with the real parent ScopeStatement.
+            </summary>
+            <param name="lineLocations">a mapping of where each line begins</param>
+            <param name="body">The body of code</param>
+            <param name="languageFeatures">The language features which were set during parsing.</param>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.PythonAst.Bind">
+            <summary>
+            Binds an AST and makes it capable of being reduced and compiled.  Before calling Bind an AST cannot successfully
+            be reduced.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.PythonAst.EnsureGlobalVariable(System.String)">
+            <summary>
+            Creates a variable at the global level.  Called for known globals (e.g. __name__),
+            for variables explicitly declared global by the user, and names accessed
+            but not defined in the lexical scope.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.PythonAst.Reduce">
+            <summary>
+            Reduces the PythonAst to a LambdaExpression of type Type.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.PythonAst.TrueDivision">
+            <summary>
+            True division is enabled in this AST.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.PythonAst.AllowWithStatement">
+            <summary>
+            True if the with statement is enabled in this AST.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.PythonAst.AbsoluteImports">
+            <summary>
+            True if absolute imports are enabled
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.PythonAst.ToScriptCode">
+            <summary>
+            Returns a ScriptCode object for this PythonAst.  The ScriptCode object
+            can then be used to execute the code against it's closed over scope or
+            to execute it against a different scope.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.PythonAst.MakeLookupCode">
+            <summary>
+            Rewrites the tree for performing lookups against globals instead of being bound
+            against the optimized scope.  This is used if the user compiles optimied code and then
+            runs it against a different scope.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.PythonAst.OnDiskProxy">
+            <summary>
+            True if this is on-disk code which we don't really have an AST for.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.Ast.PythonReference">
+            <summary>
+            Represents a reference to a name.  A PythonReference is created for each name
+            referred to in a scope (global, class, or function).  
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.ScopeStatement.LocalParentTuple">
+            <summary>
+            The variable used to hold out parents closure tuple in our local scope.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.ScopeStatement.LocalContext">
+            <summary>
+            Gets the expression associated with the local CodeContext.  If the function
+            doesn't have a local CodeContext then this is the global context.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.ScopeStatement.IsClosure">
+            <summary>
+            True if this scope accesses a variable from an outer scope.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.ScopeStatement.ContainsNestedFreeVariables">
+            <summary>
+            True if an inner scope is accessing a variable defined in this scope.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.ScopeStatement.NeedsLocalsDictionary">
+            <summary>
+            True if we are forcing the creation of a dictionary for storing locals.
+            
+            This occurs for calls to locals(), dir(), vars(), unqualified exec, and
+            from ... import *.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.ScopeStatement.HasLateBoundVariableSets">
+            <summary>
+            True if variables can be set in a late bound fashion that we don't
+            know about at code gen time - for example via from foo import *.
+            
+            This is tracked independently of the ContainsUnqualifiedExec/NeedsLocalsDictionary
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.ScopeStatement.GetOrMakeFunctionCode">
+            <summary>
+            Gets or creates the FunctionCode object for this FunctionDefinition.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.ScopeStatement.FreeVariables">
+            <summary>
+            Variables that are bound in an outer scope - but not a global scope
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.ScopeStatement.GlobalVariables">
+            <summary>
+            Variables that are bound to the global scope
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.ScopeStatement.CellVariables">
+            <summary>
+            Variables that are referred to from a nested scope and need to be
+            promoted to cells.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.ScopeStatement.GetUpdateTrackbackExpression(System.Linq.Expressions.ParameterExpression)">
+            <summary>
+            Gets the expression for updating the dynamic stack trace at runtime when an
+            exception is thrown.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.ScopeStatement.GetSaveLineNumberExpression(System.Linq.Expressions.ParameterExpression,System.Boolean)">
+            <summary>
+            Gets the expression for the actual updating of the line number for stack traces to be available
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.ScopeStatement.WrapScopeStatements(System.Linq.Expressions.Expression,System.Boolean)">
+            <summary>
+            Wraps the body of a statement which should result in a frame being available during
+            exception handling.  This ensures the line number is updated as the stack is unwound.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.Ast.ScopeStatement.DelayedFunctionCode">
+            <summary>
+            Provides a place holder for the expression which represents
+            a FunctionCode.  For functions/classes this gets updated after
+            the AST has been generated because the FunctionCode needs to
+            know about the tree which gets generated.  For modules we 
+            immediately have the value because it always comes in as a parameter.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.Ast.ScopeStatement.DelayedProfiling">
+            <summary>
+            Reducible node so that re-writing for profiling does not occur until
+            after the script code has been completed and is ready to be compiled.
+            
+            Without this extra node profiling would force reduction of the node
+            and we wouldn't have setup our constant access correctly yet.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.SliceExpression.StepProvided">
+            <summary>
+            True if the user provided a step parameter (either providing an explicit parameter
+            or providing an empty step parameter) false if only start and stop were provided.
+            </summary>
+        </member>
+        <member name="F:IronPython.Compiler.Ast.TryStatement._body">
+            <summary>
+            The statements under the try-block.
+            </summary>
+        </member>
+        <member name="F:IronPython.Compiler.Ast.TryStatement._handlers">
+            <summary>
+            Array of except (catch) blocks associated with this try. NULL if there are no except blocks.
+            </summary>
+        </member>
+        <member name="F:IronPython.Compiler.Ast.TryStatement._else">
+            <summary>
+            The body of the optional Else block for this try. NULL if there is no Else block.
+            </summary>
+        </member>
+        <member name="F:IronPython.Compiler.Ast.TryStatement._finally">
+            <summary>
+            The body of the optional finally associated with this try. NULL if there is no finally block.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.TryStatement.TransformHandlers(System.Linq.Expressions.ParameterExpression)">
+            <summary>
+            Transform multiple python except handlers for a try block into a single catch body.
+            </summary>
+            <param name="exception">The variable for the exception in the catch block.</param>
+            <returns>Null if there are no except handlers. Else the statement to go inside the catch handler</returns>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.TryStatement.GetTracebackHeader(IronPython.Compiler.Ast.Statement,System.Linq.Expressions.ParameterExpression,System.Linq.Expressions.Expression)">
+            <summary>
+            Surrounds the body of an except block w/ the appropriate code for maintaining the traceback.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.PythonVariable.ReadBeforeInitialized">
+            <summary>
+            True iff there is a path in control flow graph on which the variable is used before initialized (assigned or deleted).
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Ast.PythonVariable.AccessedInNestedScope">
+            <summary>
+            True iff the variable is referred to from the inner scope.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.Ast.PythonWalker">
+            <summary>
+            PythonWalker class - The Python AST Walker (default result is true)
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.Ast.PythonWalkerNonRecursive">
+            <summary>
+            PythonWalkerNonRecursive class - The Python AST Walker (default result is false)
+            </summary>
+        </member>
+        <member name="F:IronPython.Compiler.Ast.VariableKind.Local">
+            <summary>
+            Local variable.
+            
+            Local variables can be referenced from nested lambdas
+            </summary>
+        </member>
+        <member name="F:IronPython.Compiler.Ast.VariableKind.Parameter">
+            <summary>
+            Parameter to a LambdaExpression
+            
+            Like locals, they can be referenced from nested lambdas
+            </summary>
+        </member>
+        <member name="F:IronPython.Compiler.Ast.VariableKind.Global">
+            <summary>
+            Global variable
+            
+            Should only appear in global (top level) lambda.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Ast.WithStatement.Reduce">
+            <summary>
+            WithStatement is translated to the DLR AST equivalent to
+            the following Python code snippet (from with statement spec):
+            
+            mgr = (EXPR)
+            exit = mgr.__exit__  # Not calling it yet
+            value = mgr.__enter__()
+            exc = True
+            try:
+                VAR = value  # Only if "as VAR" is present
+                BLOCK
+            except:
+                # The exceptional case is handled here
+                exc = False
+                if not exit(*sys.exc_info()):
+                    raise
+                # The exception is swallowed if exit() returns true
+            finally:
+                # The normal and non-local-goto cases are handled here
+                if exc:
+                    exit(None, None, None)
+            
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.ClosureExpression">
+            <summary>
+            Small reducable node which just fetches the value from a ClosureCell
+            object.  Like w/ global variables the compiler recognizes these on 
+            sets and turns them into assignments on the python global object.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.ClosureExpression.ClosureCell">
+            <summary>
+            Gets the expression which points at the closure cell.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.ClosureExpression.OriginalParameter">
+            <summary>
+            The original expression for the incoming parameter if this is a parameter closure.  Otherwise
+            the value is null.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.ClosureExpression.PythonVariable">
+            <summary>
+            Gets the PythonVariable for which this closure expression was created.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.ClosureExpression.Create">
+            <summary>
+            Creates the storage for the closure cell.  If this is a closure over a parameter it
+            captures the initial incoming parameter value.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.ClosureExpression.Reduce">
+            <summary>
+            Reduces the closure cell to a read of the value stored in the cell.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.ClosureExpression.Assign(System.Linq.Expressions.Expression)">
+            <summary>
+            Assigns a value to the closure cell.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.ClosureExpression.Delete">
+            <summary>
+            Removes the current value from the closure cell.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.ReferenceClosureInfo">
+            <summary>
+            Tracking for variables lifted into closure objects. Used to store information in a function
+            about the outer variables it accesses.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.GeneratorRewriter">
+            <summary>
+            When finding a yield return or yield break, this rewriter flattens out
+            containing blocks, scopes, and expressions with stack state. All
+            scopes encountered have their variables promoted to the generator's
+            closure, so they survive yields.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.GeneratorRewriter.ToTemp(System.Linq.Expressions.Expression@)">
+            <summary>
+            Spills the right side into a temp, and replaces it with its temp.
+            Returns the expression that initializes the temp.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.GeneratorRewriter.MakeAssign(System.Linq.Expressions.Expression,System.Linq.Expressions.Expression)">
+            <summary>
+            Makes an assignment to this variable. Pushes the assignment as far
+            into the right side as possible, to allow jumps into it.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.DelayedTupleExpression">
+            <summary>
+            Accesses the property of a tuple.  The node can be created first and then the tuple and index
+            type can be filled in before the tree is actually generated.  This enables creation of these
+            nodes before the tuple type is actually known.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.LazyCode`1">
+            <summary>
+            Represents code which can be lazily compiled.
+            
+            The code is created in an AST which provides the Expression of T and 
+            whether or not the code should be interpreted.  For non-pre compiled
+            scenarios the code will not be compiled until the 1st time it is run.
+            
+            For pre-compiled scenarios the code is IExpressionSerializable and will
+            turn into a normal pre-compiled method.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.CompilationMode">
+            <summary>
+            Specifies the compilation mode which will be used during the AST transformation
+            </summary>
+        </member>
+        <member name="F:IronPython.Compiler.CompilationMode.ToDisk">
+            <summary>
+            Compilation will proceed in a manner in which the resulting AST can be serialized to disk.
+            </summary>
+        </member>
+        <member name="F:IronPython.Compiler.CompilationMode.Uncollectable">
+            <summary>
+            Compilation will use a type and declare static fields for globals.  The resulting type
+            is uncollectible and therefore extended use of this will cause memory leaks.
+            </summary>
+        </member>
+        <member name="F:IronPython.Compiler.CompilationMode.Collectable">
+            <summary>
+            Compilation will use an array for globals.  The resulting code will be fully collectible
+            and once all references are released will be collected.
+            </summary>
+        </member>
+        <member name="F:IronPython.Compiler.CompilationMode.Lookup">
+            <summary>
+            Compilation will force all global accesses to do a full lookup.  This will also happen for
+            any unbound local references.  This is the slowest form of code generation and is only
+            used for exec/eval code where we can run against an arbitrary dictionary.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.ReducableDynamicExpression">
+            <summary>
+            Provides a wrapper around "dynamic" expressions which we've opened coded (for optimized code generation).
+            
+            This lets us recognize both normal Dynamic and our own Dynamic expressions and apply the combo binder on them.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.PythonSavableScriptCode">
+            <summary>
+            A ScriptCode which can be saved to disk.  We only create this when called via
+            the clr.CompileModules API.  This ScriptCode does not support running.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.OnDiskScriptCode">
+            <summary>
+            A ScriptCode which has been loaded from an assembly which is saved on disk.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.OnDiskScriptCode.MakeAstFromSourceUnit(Microsoft.Scripting.SourceUnit)">
+            <summary>
+            Creates a fake PythonAst object which is represenative of the on-disk script code.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.PythonGlobal">
+            <summary>
+            Provides cached global variable for modules to enable optimized access to
+            module globals.  Both the module global value and the cached value can be held
+            onto and the cached value can be invalidated by the providing LanguageContext.
+            
+            The cached value is provided by the LanguageContext.GetModuleCache API.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.PythonGlobalVariableExpression">
+            <summary>
+            Small reducable node which just fetches the value from a PythonGlobal
+            object.  The compiler recognizes these on sets and turns them into
+            assignments on the python global object.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.PythonScriptCode">
+            <summary>
+            Represents a script code which can be dynamically bound to execute against
+            arbitrary Scope objects.  This is used for code when the user runs against
+            a particular scope as well as for exec and eval code as well.  It is also
+            used when tracing is enabled.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.RuntimeScriptCode">
+            <summary>
+            Represents a script code which can be consumed at runtime as-is.  This code has
+            no external dependencies and is closed over its scope.  
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.PythonCompilerOptions.#ctor">
+            <summary>
+            Creates a new PythonCompilerOptions with the default language features enabled.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.PythonCompilerOptions.#ctor(IronPython.Runtime.ModuleOptions)">
+            <summary>
+            Creates a new PythonCompilerOptions with the specified language features enabled.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.PythonCompilerOptions.#ctor(System.Boolean)">
+            <summary>
+            Creates a new PythonCompilerOptions and enables or disables true division.
+            
+            This overload is obsolete, instead you should use the overload which takes a
+            ModuleOptions.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.PythonCompilerOptions.InitialIndent">
+            <summary>
+            Gets or sets the initial indentation.  This can be set to allow parsing
+            partial blocks of code that are already indented.
+            
+            For each element of the array there is an additional level of indentation.
+            Each integer value represents the number of spaces used for the indentation.
+            
+            If this value is null then no indentation level is specified.
+            </summary>
+        </member>
+        <member name="F:IronPython.Compiler.Parser._languageFeatures">
+            <summary>
+            Language features initialized on parser construction and possibly updated during parsing. 
+            The code can set the language features (e.g. "from __future__ import division").
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Parser.ParseInteractiveCode(Microsoft.Scripting.ScriptCodeParseResult@)">
+            <summary>
+            Parse one or more lines of interactive input
+            </summary>
+            <returns>null if input is not yet valid but could be with more lines</returns>
+        </member>
+        <member name="M:IronPython.Compiler.Parser.GetNextAutoIndentSize(System.String,System.Int32)">
+            <summary>
+            Given the interactive text input for a compound statement, calculate what the
+            indentation level of the next line should be
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Parser.ParseYieldExpression">
+            <summary>
+            Peek if the next token is a 'yield' and parse a yield expression. Else return null.
+            
+            Called w/ yield already eaten.
+            </summary>
+            <returns>A yield expression if present, else null. </returns>
+        </member>
+        <member name="M:IronPython.Compiler.Parser.MaybeEatNewLine">
+            <summary>
+            Maybe eats a new line token returning true if the token was
+            eaten.
+            
+            Python always tokenizes to have only 1  new line character in a 
+            row.  But we also craete NLToken's and ignore them except for 
+            error reporting purposes.  This gives us the same errors as 
+            CPython and also matches the behavior of the standard library 
+            tokenize module.  This function eats any present NL tokens and throws
+            them away.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Parser.EatNewLine">
+            <summary>
+            Eats a new line token throwing if the next token isn't a new line.  
+            
+            Python always tokenizes to have only 1  new line character in a 
+            row.  But we also craete NLToken's and ignore them except for 
+            error reporting purposes.  This gives us the same errors as 
+            CPython and also matches the behavior of the standard library 
+            tokenize module.  This function eats any present NL tokens and throws
+            them away.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.Token">
+            <summary>
+            Summary description for Token.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.Tokenizer">
+            <summary>
+            IronPython tokenizer
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Tokenizer.#ctor(Microsoft.Scripting.ErrorSink,IronPython.Compiler.PythonCompilerOptions,System.Boolean)">
+            <summary>
+            Used to create tokenizer for hosting API.
+            </summary>
+        </member>
+        <member name="T:IronPython.Compiler.Tokenizer.TokenEqualityComparer">
+            <summary>
+            Equality comparer that can compare strings to our current token w/o creating a new string first.
+            </summary>
+        </member>
+        <member name="P:IronPython.Compiler.Tokenizer.EndContinues">
+            <summary>
+            True if the last characters in the buffer are a backslash followed by a new line indicating
+            that their is an incompletement statement which needs further input to complete.
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Tokenizer.ReadNewline">
+            <summary>
+            Returns whether the 
+            </summary>
+        </member>
+        <member name="M:IronPython.Compiler.Tokenizer.ResizeInternal(System.Char[]@,System.Int32,System.Int32,System.Int32)">
+            <summary>
+            Resizes an array to a speficied new size and copies a portion of the original array into its beginning.
+            </summary>
+        </member>
+        <member name="T:IronPython.Modules._ast.AugLoad">
+            <summary>
+            Not used.
+            </summary>
+        </member>
+        <member name="T:IronPython.Modules._ast.AugStore">
+            <summary>
+            Not used.
+            </summary>
+        </member>
+        <member name="T:IronPython.Modules._ast.Suite">
+            <summary>
+            Not an actual node. We don't create this, but it's here for compatibility.
+            </summary>
+        </member>
+        <member name="M:IronPython.Modules.Builtin.filter(IronPython.Runtime.CodeContext,System.Object,IronPython.Runtime.PythonTuple)">
+            <summary>
+            Specialized version because enumerating tuples by Python's definition
+            doesn't call __getitem__, but filter does!
+            </summary>
+        </member>
+        <member name="M:IronPython.Modules.Builtin.open(IronPython.Runtime.CodeContext,System.String,System.String,System.Int32)">
+            <summary>
+            Opens a file and returns a new file object.
+            
+            name -> the name of the file to open.
+            mode -> the mode to open the file (r for reading, w for writing, a for appending, default is r).
+            bufsize -> the size of the buffer to be used (&lt;= 0 indicates to use the default size)
+            </summary>
+        </member>
+        <member name="M:IronPython.Modules.Builtin.open(IronPython.Runtime.CodeContext,System.IO.Stream)">
+            <summary>
+            Creates a new Python file object from a .NET stream object.
+            
+            stream -> the stream to wrap in a file object.
+            </summary>
+        </member>
+        <member name="M:IronPython.Modules.Builtin.range(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            object overload of range - attempts to convert via __int__, and __trunc__ if arg is
+            an OldInstance
+            </summary>
+        </member>
+        <member name="M:IronPython.Modules.Builtin.range(IronPython.Runtime.CodeContext,System.Object,System.Object,System.Object)">
+            <summary>
+            object overload of range - attempts to convert via __int__, and __trunc__ if arg is
+            an OldInstance
+            </summary>
+        </member>
+        <member name="M:IronPython.Modules.Builtin.GetRuntimeGeneratedCodeCompilerOptions(IronPython.Runtime.CodeContext,System.Boolean,IronPython.Runtime.CompileFlags)">
+            <summary>
+            Gets the appropriate LanguageContext to be used for code compiled with Python's compile, eval, execfile, etc...
+            </summary>
+        </member>
+        <member name="M:IronPython.Modules.Builtin.GetCompilerInheritance(System.Object)">
+            <summary> Returns true if we should inherit our callers context (true division, etc...), false otherwise </summary>
+        </member>
+        <member name="M:IronPython.Modules.Builtin.GetCompilerFlags(System.Int32)">
+            <summary> Returns the default compiler flags or the flags the user specified. </summary>
+        </member>
+        <member name="M:IronPython.Modules.Builtin.GetExecEvalScopeOptional(IronPython.Runtime.CodeContext,IronPython.Runtime.PythonDictionary,System.Object,System.Boolean)">
+            <summary>
+            Gets a scope used for executing new code in optionally replacing the globals and locals dictionaries.
+            </summary>
+        </member>
+        <member name="M:IronPython.Modules.SysModule.callstats">
+            <summary>
+            Returns detailed call statistics.  Not implemented in IronPython and always returns None.
+            </summary>
+        </member>
+        <member name="M:IronPython.Modules.SysModule.displayhookImpl(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Handles output of the expression statement.
+            Prints the value and sets the __builtin__._
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.IPythonExpandable">
+            <summary>
+            Interface used to mark objects which contain a dictionary of custom attributes that shadow
+            their existing attributes in a dynamic fashion.  <seealso cref="T:MetaExpandable"/>
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.IPythonExpandable.EnsureCustomAttributes">
+            <summary>
+            Ensures that a non-null IDictionary instance is created for CustomAttributes and
+            returns it.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.MetaExpandable`1">
+            <summary>
+            Meta-object which allows IPythonExpandable objects to behave like Python objects in their
+            ability to dynamically add and remove new or existing custom attributes, generally shadowing
+            existing built-in members.  <seealso cref="T:IPythonExpandable"/>
+            
+            Getting: Member accesses first consult the object's CustomAttributes dictionary, then fall
+                through to the underlying object.
+            
+            Setting: Values can be bound to any member name, shadowing any existing attributes except
+                public non-PythonHidden fields and properties, which will bypass the dictionary.  Thus,
+                it is possible for SetMember to fail, for example if the property is read-only or of
+                the wrong type.
+            
+            Deleting: Any member represented in the dictionary can be deleted, re-exposing the
+                underlying member if it exists.  Any other deletions will fail.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.IComConvertible">
+            <summary>
+            An interface that is implemented on DynamicMetaObjects.
+            
+            This allows objects to opt-into custom conversions when calling
+            COM APIs.  The IronPython binders all call this interface before
+            doing any COM binding.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.ContextArgBuilder">
+            <summary>
+            ArgBuilder which provides the CodeContext parameter to a method.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.MakeReadOnlyMemberError(System.Type,System.String)">
+            <summary>
+            Provides a way for the binder to provide a custom error message when lookup fails.  Just
+            doing this for the time being until we get a more robust error return mechanism.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.MakeUndeletableMemberError(System.Type,System.String)">
+            <summary>
+            Provides a way for the binder to provide a custom error message when lookup fails.  Just
+            doing this for the time being until we get a more robust error return mechanism.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.GetBinder(IronPython.Runtime.CodeContext)">
+            <summary>
+            Gets the PythonBinder associated with tihs CodeContext
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.TryLookupSlot(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
+            <summary>
+            Performs .NET member resolution.  This looks within the given type and also
+            includes any extension members.  Base classes and their extension members are 
+            not searched.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.TryLookupProtectedSlot(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
+            <summary>
+            Performs .NET member resolution.  This looks within the given type and also
+            includes any extension members.  Base classes and their extension members are 
+            not searched.
+            
+            This version allows PythonType's for protected member resolution.  It shouldn't
+            be called externally for other purposes.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.TryResolveSlot(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,IronPython.Runtime.Types.PythonType,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
+            <summary>
+            Performs .NET member resolution.  This looks the type and any base types
+            for members.  It also searches for extension members in the type and any base types.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.LookupMembers(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,IronPython.Runtime.PythonDictionary)">
+            <summary>
+            Gets the member names which are defined in this type and any extension members.
+            
+            This search does not include members in any subtypes or their extension members.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.ResolveMemberNames(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,IronPython.Runtime.Types.PythonType,System.Collections.Generic.Dictionary{System.String,System.String})">
+            <summary>
+            Gets the member names which are defined in the type and any subtypes.  
+            
+            This search includes members in the type and any subtypes as well as extension
+            types of the type and its subtypes.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.MakeExtensionTypes">
+            <summary>
+            Creates the initial table of extension types.  These are standard extension that we apply
+            to well known .NET types to make working with them better.  Being added to this table does
+            not make a type a Python type though so that it's members are generally accessible w/o an
+            import clr and their type is not re-named.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.MakeSystemTypes">
+            <summary>
+            Creates a table of standard .NET types which are also standard Python types.  These types have a standard
+            set of extension types which are shared between all runtimes.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.DomainManager_AssemblyLoaded(System.Object,Microsoft.Scripting.AssemblyLoadedEventArgs)">
+            <summary>
+            Event handler for when our domain manager has an assembly loaded by the user hosting the script
+            runtime.  Here we can gather any information regarding extension methods.  
+            
+            Currently DLR-style extension methods become immediately available w/o an explicit import step.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.PythonBinder.SlotCache">
+            <summary>
+            Provides a cache from Type/name -> PythonTypeSlot and also allows access to
+            all members (and remembering whether all members are cached).
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.CacheSlot(System.Type,System.Boolean,System.String,IronPython.Runtime.Types.PythonTypeSlot,Microsoft.Scripting.Actions.MemberGroup)">
+            <summary>
+            Writes to a cache the result of a type lookup.  Null values are allowed for the slots and they indicate that
+            the value does not exist.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.TryGetCachedSlot(System.Type,System.Boolean,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
+            <summary>
+            Looks up a cached type slot for the specified member and type.  This may return true and return a null slot - that indicates
+            that a cached result for a member which doesn't exist has been stored.  Otherwise it returns true if a slot is found or
+            false if it is not.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.TryGetCachedMember(System.Type,System.String,System.Boolean,Microsoft.Scripting.Actions.MemberGroup@)">
+            <summary>
+            Looks up a cached member group for the specified member and type.  This may return true and return a null group - that indicates
+            that a cached result for a member which doesn't exist has been stored.  Otherwise it returns true if a group is found or
+            false if it is not.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.IsFullyCached(System.Type,System.Boolean)">
+            <summary>
+            Checks to see if all members have been populated for the provided type.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.CacheAll(System.Type,System.Boolean,System.Collections.Generic.Dictionary{System.String,System.Collections.Generic.KeyValuePair{IronPython.Runtime.Types.PythonTypeSlot,Microsoft.Scripting.Actions.MemberGroup}})">
+            <summary>
+            Populates the type with all the provided members and marks the type 
+            as being fully cached.
+            
+            The dictionary is used for the internal storage and should not be modified after
+            providing it to the cache.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.GetAllMembers(System.Type,System.Boolean)">
+            <summary>
+            Returns an enumerable object which provides access to all the members of the provided type.
+            
+            The caller must check that the type is fully cached and populate the cache if it isn't before
+            calling this method.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.FastGetBase">
+            <summary>
+            Base class for all of our fast get delegates.  This holds onto the
+            delegate and provides the Update function.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.FastGetBase.Update(System.Runtime.CompilerServices.CallSite,System.Object,IronPython.Runtime.CodeContext)">
+            <summary>
+            Updates the call site when the current rule is no longer applicable.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.FastSetBase`1">
+            <summary>
+            Base class for all of our fast set delegates.  This holds onto the
+            delegate and provides the Update and Optimize functions.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.FastSetBase`1.Update(System.Runtime.CompilerServices.CallSite,System.Object,`0)">
+            <summary>
+            Updates the call site when the current rule is no longer applicable.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.BindingWarnings">
+            <summary>
+            Provides support for emitting warnings when built in methods are invoked at runtime.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.Binders.Convert(System.Linq.Expressions.Expression,IronPython.Runtime.PythonContext,System.Type,Microsoft.Scripting.Actions.ConversionResultKind,System.Linq.Expressions.Expression)">
+            <summary>
+            Backwards compatible Convert for the old sites that need to flow CodeContext
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.Binders.InvokeSplat(IronPython.Runtime.PythonContext)">
+            <summary>
+            Creates a new InvokeBinder which will call with positional splatting.
+            
+            The signature of the target site should be object(function), object[], retType
+            </summary>
+            <param name="state"></param>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.Binders.InvokeKeywords(IronPython.Runtime.PythonContext)">
+            <summary>
+            Creates a new InvokeBinder which will call with positional and keyword splatting.
+            
+            The signature of the target site should be object(function), object[], dictionary, retType
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.CompatibilityInvokeBinder">
+            <summary>
+            Fallback action for performing an invoke from Python.  We translate the
+            CallSignature which supports splatting position and keyword args into
+            their expanded form.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.CreateFallback">
+            <summary>
+            Fallback action for performing a new() on a foreign IDynamicMetaObjectProvider.  used
+            when call falls back.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonGetMemberBinder.Bind(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Python's Invoke is a non-standard action.  Here we first try to bind through a Python
+            internal interface (IPythonInvokable) which supports CallSigantures.  If that fails
+            and we have an IDO then we translate to the DLR protocol through a nested dynamic site -
+            this includes unsplatting any keyword / position arguments.  Finally if it's just a plain
+            old .NET type we use the default binder which supports CallSignatures.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.IPythonInvokable">
+            <summary>
+            Interface used to mark objects as being invokable from Python.  These objects support
+            calling with splatted positional and keyword arguments.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Binding.IPythonSite.Context">
+            <summary>
+            Gets the PythonContext which the CallSiteBinder is associated with.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.PythonProtocol">
+            <summary>
+            Provides binding logic which is implemented to follow various Python protocols.  This includes
+            things such as calling __call__ to perform calls, calling __nonzero__/__len__ to convert to
+            bool, calling __add__/__radd__ to do addition, etc...  
+            
+            This logic gets shared between both the IDynamicMetaObjectProvider implementation for Python objects as well
+            as the Python sites.  This ensures the logic we follow for our builtin types and user defined
+            types is identical and properly conforming to the various protocols.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonProtocol.ConvertToBool(System.Dynamic.DynamicMetaObjectBinder,System.Dynamic.DynamicMetaObject)">
+            <summary>
+            Gets a MetaObject which converts the provided object to a bool using __nonzero__ or __len__
+            protocol methods.  This code is shared between both our fallback for a site and our MetaObject
+            for user defined objects.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonProtocol.GetConvertByLengthBody(IronPython.Runtime.PythonContext,System.Linq.Expressions.Expression)">
+            <summary>
+            Used for conversions to bool
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonProtocol.MakeContainsOperation(IronPython.Runtime.Binding.PythonOperationBinder,System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Creates a rule for the contains operator.  This is exposed via "x in y" in 
+            IronPython.  It is implemented by calling the __contains__ method on x and
+            passing in y.  
+            
+            If a type doesn't define __contains__ but does define __getitem__ then __getitem__ is 
+            called repeatedly in order to see if the object is there.
+            
+            For normal .NET enumerables we'll walk the iterator and see if it's present.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.PythonProtocol.ComparisonHelper">
+            <summary>
+            Delegate for finishing the comparison.   This takes in a condition and a return value and needs to update the ConditionalBuilder
+            with the appropriate resulting body.  The condition may be null.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonProtocol.MakeOneCompareGeneric(IronPython.Runtime.Binding.SlotOrFunction,System.Boolean,System.Dynamic.DynamicMetaObject[],IronPython.Runtime.Binding.PythonProtocol.ComparisonHelper,IronPython.Runtime.Binding.ConditionalBuilder,System.Type)">
+            <summary>
+            Helper to handle a comparison operator call.  Checks to see if the call can
+            return NotImplemented and allows the caller to modify the expression that
+            is ultimately returned (e.g. to turn __cmp__ into a bool after a comparison)
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonProtocol.DoCoerce(IronPython.Runtime.PythonContext,IronPython.Runtime.Binding.ConditionalBuilder,IronPython.Runtime.Binding.PythonOperationKind,System.Dynamic.DynamicMetaObject[],System.Boolean,System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
+            <summary>
+            calls __coerce__ for old-style classes and performs the operation if the coercion is successful.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonProtocol.MakeSortComparisonRule(System.Dynamic.DynamicMetaObject[],System.Dynamic.DynamicMetaObjectBinder,IronPython.Runtime.Binding.PythonOperationKind)">
+            <summary>
+            Makes the comparison rule which returns an int (-1, 0, 1).  TODO: Better name?
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonProtocol.MakeIndexerOperation(System.Dynamic.DynamicMetaObjectBinder,IronPython.Runtime.Binding.PythonIndexType,System.Dynamic.DynamicMetaObject[],System.Dynamic.DynamicMetaObject)">
+            <summary>
+            Python has three protocols for slicing:
+               Simple Slicing x[i:j]
+               Extended slicing x[i,j,k,...]
+               Long Slice x[start:stop:step]
+            
+            The first maps to __*slice__ (get, set, and del).  
+               This takes indexes - i, j - which specify the range of elements to be
+               returned.  In the slice variants both i, j must be numeric data types.  
+            The 2nd and 3rd are both __*item__.  
+               This receives a single index which is either a Tuple or a Slice object (which 
+               encapsulates the start, stop, and step values) 
+            
+            This is in addition to a simple indexing x[y].
+            
+            For simple slicing and long slicing Python generates Operators.*Slice.  For
+            the extended slicing and simple indexing Python generates a Operators.*Item
+            action.
+            
+            Extended slicing maps to the normal .NET multi-parameter input.  
+            
+            So our job here is to first determine if we're to call a __*slice__ method or
+            a __*item__ method.  
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonProtocol.ConvertArgs(System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Helper to convert all of the arguments to their known types.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonProtocol.GetItemSliceArguments(IronPython.Runtime.PythonContext,IronPython.Runtime.Binding.PythonIndexType,System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Gets the arguments that need to be provided to __*item__ when we need to pass a slice object.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.PythonProtocol.Callable">
+            <summary>
+            Base class for calling indexers.  We have two subclasses that target built-in functions and user defined callable objects.
+            
+            The Callable objects get handed off to ItemBuilder's which then call them with the appropriate arguments.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonProtocol.Callable.MakeCallable(IronPython.Runtime.PythonContext,IronPython.Runtime.Binding.PythonIndexType,IronPython.Runtime.Types.BuiltinFunction,IronPython.Runtime.Types.PythonTypeSlot)">
+            <summary>
+            Creates a new CallableObject.  If BuiltinFunction is available we'll create a BuiltinCallable otherwise
+            we create a SlotCallable.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonProtocol.Callable.GetTupleArguments(System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Gets the arguments in a form that should be used for extended slicing.
+            
+            Python defines that multiple tuple arguments received (x[1,2,3]) get 
+            packed into a Tuple.  For most .NET methods we just want to expand
+            this into the multiple index arguments.  For slots and old-instances
+            we want to pass in the tuple
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonProtocol.Callable.CompleteRuleTarget(System.Dynamic.DynamicMetaObjectBinder,System.Dynamic.DynamicMetaObject[],System.Func{System.Dynamic.DynamicMetaObject})">
+            <summary>
+            Adds the target of the call to the rule.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.PythonProtocol.BuiltinCallable">
+            <summary>
+            Subclass of Callable for a built-in function.  This calls a .NET method performing
+            the appropriate bindings.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.PythonProtocol.SlotCallable">
+            <summary>
+            Callable to a user-defined callable object.  This could be a Python function,
+            a class defining __call__, etc...
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.PythonProtocol.IndexBuilder">
+            <summary>
+            Base class for building a __*item__ or __*slice__ call.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.PythonProtocol.SliceBuilder">
+            <summary>
+            Derived IndexBuilder for calling __*slice__ methods
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.PythonProtocol.ItemBuilder">
+            <summary>
+            Derived IndexBuilder for calling __*item__ methods.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonProtocol.GetIndexOperators(IronPython.Runtime.Binding.PythonIndexType,System.String@,System.String@,System.Int32@)">
+            <summary>
+            Helper to get the symbols for __*item__ and __*slice__ based upon if we're doing
+            a get/set/delete and the minimum number of arguments required for each of those.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonProtocol.ShouldCoerce(IronPython.Runtime.PythonContext,IronPython.Runtime.Binding.PythonOperationKind,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject,System.Boolean)">
+            <summary>
+            Checks if a coercion check should be performed.  We perform coercion under the following
+            situations:
+                1. Old instances performing a binary operator (excluding rich comparisons)
+                2. User-defined new instances calling __cmp__ but only if we wouldn't dispatch to a built-in __coerce__ on the parent type
+                
+            This matches the behavior of CPython.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonProtocol.TypeError(System.Dynamic.DynamicMetaObjectBinder,System.String,System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Produces an error message for the provided message and type names.  The error message should contain
+            string formatting characters ({0}, {1}, etc...) for each of the type names.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.BindingHelpers">
+            <summary>
+            Common helpers used by the various binding logic.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.BindingHelpers.TryGetStaticFunction(IronPython.Runtime.PythonContext,System.String,System.Dynamic.DynamicMetaObject,IronPython.Runtime.Types.BuiltinFunction@)">
+            <summary>
+            Tries to get the BuiltinFunction for the given name on the type of the provided MetaObject.  
+            
+            Succeeds if the MetaObject is a BuiltinFunction or BuiltinMethodDescriptor.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.BindingHelpers.GetCallSignature(System.Dynamic.DynamicMetaObjectBinder)">
+            <summary>
+            Gets the best CallSignature from a MetaAction.
+            
+            The MetaAction should be either a Python InvokeBinder, or a DLR InvokeAction or 
+            CreateAction.  For Python we can use a full-fidelity 
+            </summary>
+            <param name="action"></param>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.BindingHelpers.GenericInvokeMember(System.Dynamic.InvokeMemberBinder,IronPython.Runtime.Binding.ValidationInfo,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Transforms an invoke member into a Python GetMember/Invoke.  The caller should
+            verify that the given attribute is not resolved against a normal .NET class
+            before calling this.  If it is a normal .NET member then a fallback InvokeMember
+            is preferred.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.BindingHelpers.IsSubclassOf(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject)">
+            <summary>
+            Determines if the type associated with the first MetaObject is a subclass of the
+            type associated with the second MetaObject.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.BindingHelpers.AddRecursionCheck(IronPython.Runtime.PythonContext,System.Linq.Expressions.Expression)">
+            <summary>
+            Adds a try/finally which enforces recursion limits around the target method.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.BindingHelpers.InvokeFallback(System.Dynamic.DynamicMetaObjectBinder,System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Helper to do fallback for Invoke's so we can handle both StandardAction and Python's 
+            InvokeBinder.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.BindingHelpers.GetComArguments(System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Converts arguments into a form which can be used for COM interop.
+            
+            The argument is only converted if we have an IronPython specific
+            conversion when calling COM methods.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.BindingHelpers.GetComArgument(System.Dynamic.DynamicMetaObject)">
+            <summary>
+            Converts a single argument into a form which can be used for COM 
+            interop.  
+            
+            The argument is only converted if we have an IronPython specific
+            conversion when calling COM methods.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.ConditionalBuilder">
+            <summary>
+            Builds up a series of conditionals when the False clause isn't yet known.  We can
+            keep appending conditions and if true's.  Each subsequent true branch becomes the
+            false branch of the previous condition and body.  Finally a non-conditional terminating
+            branch must be added.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.ConditionalBuilder.AddCondition(System.Linq.Expressions.Expression,System.Linq.Expressions.Expression)">
+            <summary>
+            Adds a new conditional and body.  The first call this becomes the top-level
+            conditional, subsequent calls will have it added as false statement of the
+            previous conditional.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.ConditionalBuilder.ExtendLastCondition(System.Linq.Expressions.Expression)">
+            <summary>
+            If present, converts the finish condition body be a normal conditional body. 
+            The builder instance will become unfinished again. 
+            
+            If no finish condition body is available, this extends the last condition check 
+            with the new condition.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.ConditionalBuilder.FinishCondition(System.Linq.Expressions.Expression)">
+            <summary>
+            Adds the non-conditional terminating node.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Binding.ConditionalBuilder.NoConditions">
+            <summary>
+            Returns true if no conditions have been added
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Binding.ConditionalBuilder.IsFinal">
+            <summary>
+            Returns true if a final, non-conditional, body has been added.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.ConditionalBuilder.GetMetaObject(System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Gets the resulting meta object for the full body.  FinishCondition
+            must have been called.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.ConditionalBuilder.AddVariable(System.Linq.Expressions.ParameterExpression)">
+            <summary>
+            Adds a variable which will be scoped at the level of the final expression.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaUserObject.GetConversionFailedReturnValue(IronPython.Runtime.Binding.PythonConversionBinder,System.Dynamic.DynamicMetaObject)">
+            <summary>
+             Various helpers related to calling Python __*__ conversion methods 
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaUserObject.Fallback(System.Dynamic.DynamicMetaObjectBinder,System.Dynamic.DynamicMetaObject)">
+            <summary>
+            Helper for falling back - if we have a base object fallback to it first (which can
+            then fallback to the calling site), otherwise fallback to the calling site.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaUserObject.Fallback(System.Dynamic.SetMemberBinder,System.Dynamic.DynamicMetaObject)">
+            <summary>
+            Helper for falling back - if we have a base object fallback to it first (which can
+            then fallback to the calling site), otherwise fallback to the calling site.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.MetaUserObject.GetOrInvokeBinderHelper`1">
+            <summary>
+            Provides the lookup logic for resolving a Python object.  Subclasses
+            provide the actual logic for producing the binding result.  Currently
+            there are two forms of the binding result: one is the DynamicMetaObject
+            form used for non-optimized bindings.  The other is the Func of CallSite,
+            object, CodeContext, object form which is used for fast binding and
+            pre-compiled rules.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.MetaUserObject.MetaGetBinderHelper">
+            <summary>
+            GetBinder which produces a DynamicMetaObject.  This binder always
+            successfully produces a DynamicMetaObject which can perform the requested get.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaUserObject.MetaGetBinderHelper.MakeGetAttributeRule(IronPython.Runtime.Binding.MetaUserObject.GetBindingInfo,IronPython.Runtime.Types.IPythonObject,IronPython.Runtime.Types.PythonTypeSlot,System.Dynamic.DynamicMetaObject)">
+            <summary>
+            Makes a rule which calls a user-defined __getattribute__ function and falls back to __getattr__ if that
+            raises an AttributeError.
+            
+            slot is the __getattribute__ method to be called.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaUserObject.MetaGetBinderHelper.MakeOldStyleAccess">
+            <summary>
+            Checks a range of the MRO to perform old-style class lookups if any old-style classes
+            are present.  We will call this twice to produce a search before a slot and after
+            a slot.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaUserObject.TryGetGetAttribute(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,IronPython.Runtime.Types.PythonTypeSlot@)">
+            <summary>
+            Checks to see if this type has __getattribute__ that overrides all other attribute lookup.
+            
+            This is more complex then it needs to be.  The problem is that when we have a 
+            mixed new-style/old-style class we have a weird __getattribute__ defined.  When
+            we always dispatch through rules instead of PythonTypes it should be easy to remove
+            this.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaUserObject.MetaSetBinderHelper.FallbackSetError(System.Dynamic.SetMemberBinder,System.Dynamic.DynamicMetaObject)">
+            <summary>
+            Helper for falling back - if we have a base object fallback to it first (which can
+            then fallback to the calling site), otherwise fallback to the calling site.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaUserObject.FindSlot(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.Types.IPythonObject,System.Boolean@,System.Boolean@,System.Boolean@)">
+            <summary>
+            Looks up the associated PythonTypeSlot from the object.  Indicates if the result
+            came from a standard .NET type in which case we will fallback to the sites binder.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaUserObject.FallbackGetError(System.Dynamic.DynamicMetaObjectBinder,System.Dynamic.DynamicMetaObject)">
+            <summary>
+            Helper for falling back - if we have a base object fallback to it first (which can
+            then fallback to the calling site), otherwise fallback to the calling site.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaUserObject.FallbackDeleteError(System.Dynamic.DeleteMemberBinder,System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Helper for falling back - if we have a base object fallback to it first (which can
+            then fallback to the calling site), otherwise fallback to the calling site.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.PythonOperationKind">
+            <summary>
+            Custom dynamic site kinds for simple sites that just take a fixed set of parameters.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Documentation">
+            <summary>
+            Unary operator.
+            
+            Gets various documentation about the object returned as a string
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.CallSignatures">
+            <summary>
+            Unary operator.
+            
+            Gets information about the type of parameters, returned as a string.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.IsCallable">
+            <summary>
+            Unary operator.
+            
+            Checks whether the object is callable or not, returns true if it is.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Contains">
+            <summary>
+            Binary operator.
+            
+            Checks to see if the instance contains another object.  Returns true or false.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Length">
+            <summary>
+            Unary operator.
+            
+            Returns the number of items stored in the object.
+            </summary>      
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Compare">
+            <summary>
+            Binary operator.
+            
+            Compares two instances returning an integer indicating the relationship between them.  May
+            throw if the object types are uncomparable.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.DivMod">
+            <summary>
+            Binary operator.
+            
+            Returns both the dividend and quotioent of x / y.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.AbsoluteValue">
+            <summary>
+            Unary operator.
+            
+            Get the absolute value of the instance.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Positive">
+            <summary>
+            Unary operator.
+            
+            Gets the positive value of the instance.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Negate">
+            <summary>
+            Unary operator.
+            
+            Negates the instance and return the new value.
+            </summary>        
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.OnesComplement">
+            <summary>
+            Unary operator.
+            
+            Returns the ones complement of the instance.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.IsFalse">
+            <summary>
+            Unary operator.
+            
+            Boolean negation
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Not">
+            <summary>
+            Unary operator.
+            
+            Negation, returns object
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.GetEnumeratorForIteration">
+            <summary>
+            Get enumerator for iteration binder.  Returns a KeyValuePair&lt;IEnumerator, IDisposable&gt;
+            
+            The IEnumerator is used for iteration.  The IDisposable is provided if the object was an
+            IEnumerable or IEnumerable&lt;T&gt; and is a disposable object.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Add">
+            <summary>Operator for performing add</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Subtract">
+            <summary>Operator for performing sub</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Power">
+            <summary>Operator for performing pow</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Multiply">
+            <summary>Operator for performing mul</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.FloorDivide">
+            <summary>Operator for performing floordiv</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Divide">
+            <summary>Operator for performing div</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.TrueDivide">
+            <summary>Operator for performing truediv</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Mod">
+            <summary>Operator for performing mod</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.LeftShift">
+            <summary>Operator for performing lshift</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.RightShift">
+            <summary>Operator for performing rshift</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.BitwiseAnd">
+            <summary>Operator for performing and</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.BitwiseOr">
+            <summary>Operator for performing or</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ExclusiveOr">
+            <summary>Operator for performing xor</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.LessThan">
+            <summary>Operator for performing lt</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.GreaterThan">
+            <summary>Operator for performing gt</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.LessThanOrEqual">
+            <summary>Operator for performing le</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.GreaterThanOrEqual">
+            <summary>Operator for performing ge</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.Equal">
+            <summary>Operator for performing eq</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.NotEqual">
+            <summary>Operator for performing ne</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.LessThanGreaterThan">
+            <summary>Operator for performing lg</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceAdd">
+            <summary>Operator for performing in-place add</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceSubtract">
+            <summary>Operator for performing in-place sub</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlacePower">
+            <summary>Operator for performing in-place pow</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceMultiply">
+            <summary>Operator for performing in-place mul</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceFloorDivide">
+            <summary>Operator for performing in-place floordiv</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceDivide">
+            <summary>Operator for performing in-place div</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceTrueDivide">
+            <summary>Operator for performing in-place truediv</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceMod">
+            <summary>Operator for performing in-place mod</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceLeftShift">
+            <summary>Operator for performing in-place lshift</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceRightShift">
+            <summary>Operator for performing in-place rshift</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceBitwiseAnd">
+            <summary>Operator for performing in-place and</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceBitwiseOr">
+            <summary>Operator for performing in-place or</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceExclusiveOr">
+            <summary>Operator for performing in-place xor</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseAdd">
+            <summary>Operator for performing reverse add</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseSubtract">
+            <summary>Operator for performing reverse sub</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReversePower">
+            <summary>Operator for performing reverse pow</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseMultiply">
+            <summary>Operator for performing reverse mul</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseFloorDivide">
+            <summary>Operator for performing reverse floordiv</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseDivide">
+            <summary>Operator for performing reverse div</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseTrueDivide">
+            <summary>Operator for performing reverse truediv</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseMod">
+            <summary>Operator for performing reverse mod</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseLeftShift">
+            <summary>Operator for performing reverse lshift</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseRightShift">
+            <summary>Operator for performing reverse rshift</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseBitwiseAnd">
+            <summary>Operator for performing reverse and</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseBitwiseOr">
+            <summary>Operator for performing reverse or</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseExclusiveOr">
+            <summary>Operator for performing reverse xor</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseDivMod">
+            <summary>Operator for performing reverse divmod</summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.SlotOrFunction">
+            <summary>
+            Provides an abstraction for calling something which might be a builtin function or
+            might be some arbitrary user defined slot.  If the object is a builtin function the
+            call will go directly to the underlying .NET method.  If the object is an arbitrary
+            callable object we will setup a nested dynamic site for performing the additional
+            dispatch.
+            
+            TODO: We could probably do a specific binding to the object if it's another IDyanmicObject.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.SlotOrFunction.GetCombinedTargets(IronPython.Runtime.Binding.SlotOrFunction,IronPython.Runtime.Binding.SlotOrFunction,IronPython.Runtime.Binding.SlotOrFunction@,IronPython.Runtime.Binding.SlotOrFunction@)">
+            <summary>
+            Combines two methods, which came from two different binary types, selecting the method which has the best
+            set of conversions (the conversions which result in the least narrowing).
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.SlotOrFunction.TryGetBinder(IronPython.Runtime.PythonContext,System.Dynamic.DynamicMetaObject[],System.String,System.String,IronPython.Runtime.Binding.SlotOrFunction@,IronPython.Runtime.Types.PythonType@)">
+            <summary>
+            Tries to get a MethodBinder associated with the slot for the specified type.
+            
+            If a method is found the binder is set and true is returned.
+            If nothing is found binder is null and true is returned.
+            If something other than a method is found false is returned.
+            
+            TODO: Remove rop
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.PythonInvokeBinder">
+            <summary>
+            The Action used for Python call sites.  This supports both splatting of position and keyword arguments.
+            
+            When a foreign object is encountered the arguments are expanded into normal position/keyword arguments.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonInvokeBinder.Bind(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Python's Invoke is a non-standard action.  Here we first try to bind through a Python
+            internal interface (IPythonInvokable) which supports CallSigantures.  If that fails
+            and we have an IDO then we translate to the DLR protocol through a nested dynamic site -
+            this includes unsplatting any keyword / position arguments.  Finally if it's just a plain
+            old .NET type we use the default binder which supports CallSignatures.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonInvokeBinder.Fallback(System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Fallback - performs the default binding operation if the object isn't recognized
+            as being invokable.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Binding.PythonInvokeBinder.Signature">
+            <summary>
+            Gets the CallSignature for this invocation which describes how the MetaObject array
+            is to be mapped.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonInvokeBinder.InvokeForeignObject(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Creates a nested dynamic site which uses the unpacked arguments.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.PythonInvokeBinder.TranslateArguments(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[],System.Dynamic.CallInfo@,System.Collections.Generic.List{System.Linq.Expressions.Expression}@,System.Linq.Expressions.Expression@,System.Dynamic.BindingRestrictions@)">
+            <summary>
+            Translates our CallSignature into a DLR Argument list and gives the simple MetaObject's which are extracted
+            from the tuple or dictionary parameters being splatted.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.MetaOldInstance">
+            <summary>
+            Provides a MetaObject for instances of Python's old-style classes.
+            
+            TODO: Lots of CodeConetxt references, need to move CodeContext onto OldClass and pull it from there.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper">
+            <summary>
+            Performs the actual work of binding to the function.
+            
+            Overall this works by going through the arguments and attempting to bind all the outstanding known
+            arguments - position arguments and named arguments which map to parameters are easy and handled
+            in the 1st pass for GetArgumentsForRule.  We also pick up any extra named or position arguments which
+            will need to be passed off to a kw argument or a params array.
+            
+            After all the normal args have been assigned to do a 2nd pass in FinishArguments.  Here we assign
+            a value to either a value from the params list, kw-dict, or defaults.  If there is ambiguity between
+            this (e.g. we have a splatted params list, kw-dict, and defaults) we call a helper which extracts them
+            in the proper order (first try the list, then the dict, then the defaults).
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetRestrictions">
+            <summary>
+            Makes the test for our rule.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetSimpleRestriction">
+            <summary>
+            Makes the test when we just have simple positional arguments.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetComplexRestriction">
+            <summary>
+            Makes the test when we have a keyword argument call or splatting.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetArgumentsForRule">
+            <summary>
+            Gets the array of expressions which correspond to each argument for the function.  These
+            correspond with the function as it's defined in Python and must be transformed for our
+            delegate type before being used.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.FinishArguments(System.Linq.Expressions.Expression[],System.Collections.Generic.List{System.Linq.Expressions.Expression},System.Collections.Generic.Dictionary{System.String,System.Linq.Expressions.Expression})">
+            <summary>
+            Binds any missing arguments to values from params array, kw dictionary, or default values.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.TryFinishList(System.Linq.Expressions.Expression[],System.Collections.Generic.List{System.Linq.Expressions.Expression})">
+            <summary>
+            Creates the argument for the list expansion parameter.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeParamsAddition(System.Collections.Generic.List{System.Linq.Expressions.Expression})">
+            <summary>
+            Adds extra positional arguments to the start of the expanded list.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.TryFinishDictionary(System.Linq.Expressions.Expression[],System.Collections.Generic.Dictionary{System.String,System.Linq.Expressions.Expression})">
+            <summary>
+            Creates the argument for the dictionary expansion parameter.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeDictionaryAddition(System.Collections.Generic.KeyValuePair{System.String,System.Linq.Expressions.Expression})">
+            <summary>
+            Adds an unbound keyword argument into the dictionary.
+            </summary>
+            <param name="kvp"></param>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.AddCheckForNoExtraParameters(System.Linq.Expressions.Expression[])">
+            <summary>
+            Adds a check to the last parameter (so it's evaluated after we've extracted
+            all the parameters) to ensure that we don't have any extra params or kw-params
+            when we don't have a params array or params dict to expand them into.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ValidateNotDuplicate(System.Linq.Expressions.Expression,System.String,System.Int32)">
+            <summary>
+            Helper function to validate that a named arg isn't duplicated with by
+            a params list or the dictionary (or both).
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ExtractNonDefaultValue(System.String)">
+            <summary>
+            Helper function to get a value (which has no default) from either the 
+            params list or the dictionary (or both).
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ExtractDictionaryArgument(System.String)">
+            <summary>
+            Helper function to get the specified variable from the dictionary.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ExtractDefaultValue(System.Int32,System.Int32)">
+            <summary>
+            Helper function to extract the variable from defaults, or to call a helper
+            to check params / kw-dict / defaults to see which one contains the actual value.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ExtractFromListOrDictionary(System.String)">
+            <summary>
+            Helper function to extract from the params list or dictionary depending upon
+            which one has an available value.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ExtractNextParamsArg">
+            <summary>
+            Helper function to extract the next argument from the params list.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetArgumentsForTargetType(System.Linq.Expressions.Expression[])">
+            <summary>
+            Fixes up the argument list for the appropriate target delegate type.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetFunctionParam">
+            <summary>
+            Helper function to get the function argument strongly typed.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeDictionaryCopy(System.Dynamic.DynamicMetaObject)">
+            <summary>
+            Called when the user is expanding a dictionary - we copy the user
+            dictionary and verify that it contains only valid string names.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeParamsCopy(System.Linq.Expressions.Expression)">
+            <summary>
+            Called when the user is expanding a params argument
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeDictionary(System.Collections.Generic.Dictionary{System.String,System.Linq.Expressions.Expression})">
+            <summary>
+            Called when the user hasn't supplied a dictionary to be expanded but the
+            function takes a dictionary to be expanded.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeParamsTuple(System.Collections.Generic.List{System.Linq.Expressions.Expression})">
+            <summary>
+            Helper function to create the expression for creating the actual tuple passed through.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeFunctionInvoke(System.Linq.Expressions.Expression[])">
+            <summary>
+            Creates the code to invoke the target delegate function w/ the specified arguments.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.AddInitialization(System.Linq.Expressions.Expression)">
+            <summary>
+            Appends the initialization code for the call to the function if any exists.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonType.MakeStandardDotNetTypeCall(System.Dynamic.DynamicMetaObjectBinder,System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Creating a standard .NET type is easy - we just call it's constructor with the provided
+            arguments.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonType.MakePythonTypeCall(System.Dynamic.DynamicMetaObjectBinder,System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Creating a Python type involves calling __new__ and __init__.  We resolve them
+            and generate calls to either the builtin funcions directly or embed sites which
+            call the slots at runtime.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonType.TooManyArgsForDefaultNew(System.Dynamic.DynamicMetaObjectBinder,System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            Checks if we have a default new and init - in this case if we have any
+            arguments we don't allow the call.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonType.MakeVersionCheck">
+            <summary>
+            Creates a test which tests the specific version of the type.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.MetaPythonType.GetBinderHelper`1">
+            <summary>
+            Base class for performing member binding.  Derived classes override Add methods
+            to produce the actual final result based upon what the GetBinderHelper resolves.
+            </summary>
+            <typeparam name="TResult"></typeparam>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.MetaPythonType.MetaGetBinderHelper">
+            <summary>
+            Provides the normal meta binder binding.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Binding.MetaPythonType.FastGetBinderHelper">
+            <summary>
+            Provides delegate based fast binding.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Binding.MetaPythonObject.MakeDelegateTarget(System.Dynamic.DynamicMetaObjectBinder,System.Type,System.Dynamic.DynamicMetaObject)">
+            <summary>
+            Creates a target which creates a new dynamic method which contains a single
+            dynamic site that invokes the callable object.
+            
+            TODO: This should be specialized for each callable object
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Binding.PythonOperationBinder.ReturnType">
+            <summary>
+            The result type of the operation.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.BuiltinPythonModule">
+            <summary>
+            Implements a built-in module which is instanced per PythonContext.
+            
+            Implementers can subclass this type and then have a module which has efficient access
+            to internal state (this doesn't need to go through PythonContext.GetModuleState).  These
+            modules can also declare module level globals which they'd like to provide efficient
+            access to by overloading GetGlobalVariableNames.  When Initialize is called these
+            globals are provided and can be cached in the instance for fast global access.
+            
+            Just like normal static modules these modules are registered with the PythonModuleAttribute.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.BuiltinPythonModule.Initialize(IronPython.Runtime.CodeContext,System.Collections.Generic.Dictionary{System.String,IronPython.Compiler.PythonGlobal})">
+            <summary>
+            Initializes the module for it's first usage.  By default this calls PerformModuleReload with the
+            the dictionary.
+            </summary>
+            <param name="codeContext">The CodeContext for the module.</param>
+            <param name="optimizedGlobals">A list of globals which have optimize access.  Contains at least all of the global variables reutrned by GetGlobalVariableNames.</param>
+        </member>
+        <member name="M:IronPython.Runtime.BuiltinPythonModule.GetGlobalVariableNames">
+            <summary>
+            Gets a list of variable names which should have optimized storage (instances of PythonGlobal objects).
+            The module receives the global objects during the Initialize call and can hold onto them for
+            direct access to global members.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.BuiltinPythonModule.PerformModuleReload">
+            <summary>
+            Called when the user attempts to reload() on your module and by the base class Initialize method.
+            
+            This provides an opportunity to allocate any per-module data which is not simply function definitions.
+            
+            A common usage here is to create exception objects which are allocated by the module using PythonExceptions.CreateSubType.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.BuiltinPythonModule.Context">
+            <summary>
+            Provides access to the PythonContext which this module was created for.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.BuiltinPythonModule.Globals">
+            <summary>
+            Provides access to the CodeContext for the module.  Returns null before Initialize() is called.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.ConstantDictionaryStorage">
+            <summary>
+            Copy on write constant dictionary storage used for dictionaries created with constant items.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.DebuggerDictionaryStorage">
+            <summary>
+            Adapts an IDictionary[object, object] for use as a PythonDictionary used for
+            our debug frames.  Also hides the special locals which start with $.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.CodeContext">
+            <summary>
+            Captures and flows the state of executing code from the generated 
+            Python code into the IronPython runtime.
+            </summary>    
+        </member>
+        <member name="M:IronPython.Runtime.CodeContext.#ctor(IronPython.Runtime.PythonDictionary,IronPython.Runtime.ModuleContext)">
+            <summary>
+            Creates a new CodeContext which is backed by the specified Python dictionary.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.CodeContext.ModuleContext">
+            <summary>
+            Gets the module state for top-level code.
+            </summary>   
+        </member>
+        <member name="P:IronPython.Runtime.CodeContext.GlobalScope">
+            <summary>
+            Gets the DLR scope object that corresponds to the global variables of this context.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.CodeContext.LanguageContext">
+            <summary>
+            Gets the PythonContext which created the CodeContext.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.CodeContext.GlobalDict">
+            <summary>
+            Gets the dictionary for the global variables from the ModuleContext.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.CodeContext.ShowCls">
+            <summary>
+            True if this global context should display CLR members on shared types (for example .ToString on int/bool/etc...)
+            
+            False if these attributes should be hidden.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CodeContext.TryLookupName(System.String,System.Object@)">
+            <summary>
+            Attempts to lookup the provided name in this scope or any outer scope.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CodeContext.TryLookupBuiltin(System.String,System.Object@)">
+            <summary>
+            Looks up a global variable.  If the variable is not defined in the
+            global scope then built-ins is consulted.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.CodeContext.Dict">
+            <summary>
+            Gets the dictionary used for storage of local variables.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CodeContext.TryGetVariable(System.String,System.Object@)">
+            <summary>
+            Attempts to lookup the variable in the local scope.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CodeContext.TryRemoveVariable(System.String)">
+            <summary>
+            Removes a variable from the local scope.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CodeContext.SetVariable(System.String,System.Object)">
+            <summary>
+            Sets a variable in the local scope.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CodeContext.TryGetGlobalVariable(System.String,System.Object@)">
+            <summary>
+            Gets a variable from the global scope.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CodeContext.SetGlobalVariable(System.String,System.Object)">
+            <summary>
+            Sets a variable in the global scope.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CodeContext.TryRemoveGlobalVariable(System.String)">
+            <summary>
+            Removes a variable from the global scope.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CodeContext.GetBuiltinsDict">
+            <summary>
+            Returns the dictionary associated with __builtins__ if one is
+            set or null if it's not available.  If __builtins__ is a module
+            the module's dictionary is returned.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.DontMapIEnumerableToIterAttribute">
+            <summary>
+            Marks a type so that IronPython will not expose the IEnumerable interface out as
+            __iter__
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.DontMapGetMemberNamesToDirAttribute">
+            <summary>
+            Marks a type so that IronPython will not expose types which have GetMemberNames
+            as having a __dir__ method.
+            
+            Also suppresses __dir__ on something which implements IDynamicMetaObjectProvider
+            but is not an IPythonObject.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.DontMapICollectionToLenAttribute">
+            <summary>
+            Marks a type so that IronPython will not expose the ICollection interface out as
+            __len__.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.DontMapIDisposableToContextManagerAttribute">
+            <summary>
+            Marks a type so that IronPython will not expose the IDisposable interface out as
+            __enter__ and __exit__ methods of a context manager.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.DontMapIEnumerableToContainsAttribute">
+            <summary>
+            Marks a type so that IronPython will not expose the IEnumerable interface out as
+            __contains__
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.EmptyDictionaryStorage">
+            <summary>
+            Singleton used for dictionaries which contain no items.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Exceptions.GeneratorExitException">
+            <summary>
+            GeneratorExitException is a standard exception raised by Generator.Close() to allow a caller
+            to close out a generator.
+            </summary>
+            <remarks>GeneratorExit is introduced in Pep342 for Python2.5. </remarks>
+        </member>
+        <member name="T:IronPython.Runtime.Exceptions.IndentationException">
+            <summary>
+            .NET exception thrown when a Python syntax error is related to incorrect indentation.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Exceptions.PythonExceptions">
+            <summary>
+            Implementation of the Python exceptions module and the IronPython/CLR exception mapping 
+            mechanism.  The exception module is the parent module for all Python exception classes
+            and therefore is built-in to IronPython.dll instead of IronPython.Modules.dll.
+            
+            The exception mapping mechanism is exposed as internal surface area available to only
+            IronPython / IronPython.Modules.dll.  The actual exceptions themselves are all public.
+            
+            Because the oddity of the built-in exception types all sharing the same physical layout
+            (see also PythonExceptions.BaseException) some classes are defined as classes w/ their
+            proper name and some classes are defined as PythonType fields.  When a class is defined
+            for convenience their's also an _TypeName version which is the PythonType.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Exceptions.PythonExceptions.BaseException">
+            <summary>
+            Base class for all Python exception objects.
+            
+            When users throw exceptions they typically throw an exception which is
+            a subtype of this.  A mapping is maintained between Python exceptions
+            and .NET exceptions and a corresponding .NET exception is thrown which
+            is associated with the Python exception.  This class represents the
+            base class for the Python exception hierarchy.  
+            
+            Users can catch exceptions rooted in either hierarchy.  The hierarchy
+            determines whether the user catches the .NET exception object or the 
+            Python exception object.
+            
+            Most built-in Python exception classes are actually instances of the BaseException
+            class here.  This is important because in CPython the exceptions do not 
+            add new members and therefore their layouts are compatible for multiple
+            inheritance.  The exceptions to this rule are the classes which define 
+            their own fields within their type, therefore altering their layout:
+                EnvironmentError
+                SyntaxError
+                    IndentationError     (same layout as SyntaxError)
+                    TabError             (same layout as SyntaxError)
+                SystemExit
+                UnicodeDecodeError
+                UnicodeEncodeError
+                UnicodeTranslateError
+                
+            These exceptions cannot be combined in multiple inheritance, e.g.:
+                class foo(EnvironmentError, IndentationError): pass
+                
+            fails but they can be combined with anything which is just a BaseException:
+                class foo(UnicodeDecodeError, SystemError): pass
+                
+            Therefore the majority of the classes are just BaseException instances with a 
+            custom PythonType object.  The specialized ones have their own .NET class
+            which inherits from BaseException.  User defined exceptions likewise inherit
+            from this and have their own .NET class.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__init__(System.Object[])">
+            <summary>
+            Initializes the Exception object with an unlimited number of arguments
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.message">
+            <summary>
+            Returns the exception 'message' if only a single argument was provided 
+            during creation or an empty string.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.args">
+            <summary>
+            Gets or sets the arguments used for creating the exception
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__reduce__">
+            <summary>
+            Returns a tuple of (type, (arg0, ..., argN)) for implementing pickling/copying
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__reduce_ex__(System.Int32)">
+            <summary>
+            Returns a tuple of (type, (arg0, ..., argN)) for implementing pickling/copying
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.Item(System.Int32)">
+            <summary>
+            Gets the nth member of the args property
+            </summary>            
+        </member>
+        <member name="P:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__dict__">
+            <summary>
+            Gets or sets the dictionary which is used for storing members not declared to have space reserved
+            within the exception object.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__setstate__(IronPython.Runtime.PythonDictionary)">
+            <summary>
+            Updates the exception's state (dictionary) with the new values
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.clsException">
+            <summary>
+            Gets the CLR exception associated w/ this Python exception.  Not visible
+            until a .NET namespace is imported.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.GetBoundMember(System.String)">
+            <summary>
+            Provides custom member lookup access that fallbacks to the dictionary
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.SetMemberAfter(System.String,System.Object)">
+            <summary>
+            Provides custom member assignment which stores values in the dictionary
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.DeleteCustomMember(System.String)">
+            <summary>
+            Provides custom member deletion which deletes values from the dictionary
+            or allows clearing 'message'.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__repr__(IronPython.Runtime.CodeContext)">
+            <summary>
+            Implements __repr__ which returns the type name + the args
+            tuple code formatted.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.InitializeFromClr(System.Exception)">
+            <summary>
+            Initializes the Python exception from a .NET exception
+            </summary>
+            <param name="exception"></param>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.GetClrException">
+            <summary>
+            Helper to get the CLR exception associated w/ this Python exception
+            creating it if one has not already been created.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateThrowableForRaise(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.Object)">
+            <summary>
+            Creates a new throwable exception of type type where the type is an new-style exception.
+            
+            Used at runtime when creating the exception from a user provided type via the raise statement.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateThrowableForRaise(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.OldClass,System.Object)">
+            <summary>
+            Creates a throwable exception of type type where the type is an OldClass.
+            
+            Used at runtime when creating the exception form a user provided type that's an old class (via the raise statement).
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.ToClr(System.Object)">
+            <summary>
+            Returns the CLR exception associated with a Python exception
+            creating a new exception if necessary
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.ToPython(System.Exception)">
+            <summary>
+            Given a CLR exception returns the Python exception which most closely maps to the CLR exception.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.ToPythonNewStyle(System.Exception)">
+            <summary>
+            Creates a new style Python exception from the .NET exception
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.SetPythonException(System.Exception,System.Object)">
+            <summary>
+            Internal helper to associate a .NET exception and a Python exception.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.GetPythonException(System.Exception)">
+            <summary>
+            Internal helper to get the associated Python exception from a .NET exception.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.SyntaxErrorToPython(Microsoft.Scripting.SyntaxErrorException)">
+            <summary>
+            Converts the DLR SyntaxErrorException into a Python new-style SyntaxError instance.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateSubType(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType,System.String,System.String,System.String,System.Func{System.String,System.Exception})">
+            <summary>
+            Creates a PythonType for a built-in module.  These types are mutable like
+            normal user types.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateSubType(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType,System.Type,System.String,System.String,System.String,System.Func{System.String,System.Exception})">
+            <summary>
+            Creates a PythonType for a built-in module.  These types are mutable like
+            normal user types.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateSubType(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType[],System.Type,System.String,System.String,System.String,System.Func{System.String,System.Exception})">
+            <summary>
+            Creates a PythonType for a built-in module, where the type may inherit
+            from multiple bases.  These types are mutable like normal user types. 
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateSubType(IronPython.Runtime.Types.PythonType,System.String,System.Func{System.String,System.Exception})">
+            <summary>
+            Creates a new type for a built-in exception which derives from another Python
+            type.  .  These types are built-in and immutable like any other normal type.  For 
+            example StandardError.x = 3 is illegal.  This isn't for module exceptions which 
+            are like user defined types.  thread.error.x = 3 is legal.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateSubType(IronPython.Runtime.Types.PythonType,System.Type,System.Func{System.String,System.Exception})">
+            <summary>
+            Creates a new type for a built-in exception which is the root concrete type.  
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.PythonExceptions.GetDynamicStackFrames(System.Exception)">
+            <summary>
+            Gets the list of DynamicStackFrames for the current exception.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Exceptions.StopIterationException">
+            <summary>
+            .NET exception that is thrown to signal the end of iteration in Python
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Exceptions.SystemExitException">
+            <summary>
+            .NET exception that is thrown to shutdown the interpretter and exit the system.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.SystemExitException.GetExitCode(System.Object@)">
+            <summary>
+            Result of sys.exit(n)
+            </summary>
+            <param name="otherCode">
+            null if the script exited using "sys.exit(int_value)"
+            null if the script exited using "sys.exit(None)"
+            x    if the script exited using "sys.exit(x)" where isinstance(x, int) == False
+            </param>
+            <returns>
+            int_value if the script exited using "sys.exit(int_value)"
+            1 otherwise
+            </returns>
+        </member>
+        <member name="T:IronPython.Runtime.Exceptions.TabException">
+            <summary>
+            .NET Exception thrown when a Python syntax error is related to incorrect tabs.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Exceptions.TraceBack.Extract">
+            <summary>
+            returns string containing human readable representation of traceback
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.ExtensionMethodSet">
+            <summary>
+            Represents the set of extension methods which are loaded into a module.
+            
+            This set is immutable (as far the external viewer is considered).  When a 
+            new extension method set is loaded into a module we create a new ExtensionMethodsSet object.  
+            
+            Multiple modules which have the same set of extension methods use the same set.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.ExtensionMethodSet.AssemblyLoadInfo">
+            <summary>
+            Tracks the extension types that are loaded for a given assembly.
+            
+            We can have either types, namespaces, or a full assembly added as a reference.
+            
+            When the user just adds types we just add them to the type hash set.
+            
+            When the user adds namespaces we add them to the namespaces hashset.  On the
+            next lookup we'll lazily load the types from that namespace and put them in Types.
+            
+            When the user adds assemblies we set the value to the NotYetLoadedButFullAssembly
+            value.  The next load request will load the types from that namespace and put them
+            in Types.  When we do that we'll mark the assembly as FullyLoaded so we don't 
+            have to go through that again if the user adds a namespace.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ExtensionMethodSet.GetExtensionMethods(System.String)">
+            <summary>
+            Returns all of the extension methods with the given name.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ExtensionMethodSet.GetExtensionMethods(IronPython.Runtime.Types.PythonType)">
+            <summary>
+            Returns all of the extension methods which are applicable for the given type.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.FormattingHelper.InvariantCommaNumberInfo">
+            <summary>
+            Helper NumberFormatInfo for use by int/BigInteger __format__ routines
+            for width specified leading zero support that contains ','s every 3 digits.
+            i.e. For use by d/g/G format specifiers. NOT for use by n format specifiers.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.InstancedModuleDictionaryStorage">
+            <summary>
+            ModuleDictionaryStorage for a built-in module which is bound to a specific instance.
+            
+            These modules don't need to use PythonContext.GetModuleState() for storage and therefore
+            can provide efficient access to internal variables.  They can also cache PythonGlobal
+            objects and provide efficient access to module globals.  
+            
+            To the end user these modules appear just like any other module.  These modules are
+            implemented by subclassing the BuiltinPythonModule class.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.MemoryView.FixSlice(IronPython.Runtime.Slice,System.Int32,System.Int32@,System.Int32@)">
+            <summary>
+            MemoryView slicing is somewhat different and more restricted than
+            standard slicing.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Method.CheckSelf(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Validates that the current self object is usable for this method.  
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonTypeOps.GetInitMethod(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.Object)">
+            <summary>
+            Looks up __init__ avoiding calls to __getattribute__ and handling both
+            new-style and old-style classes in the MRO.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonTypeOps.GetBuiltinFunction(System.Type,System.String,System.String,System.Nullable{IronPython.Runtime.Types.FunctionType},System.Reflection.MemberInfo[])">
+            <summary>
+            Gets a builtin function for the given declaring type and member infos.
+            
+            Given the same inputs this always returns the same object ensuring there's only 1 builtinfunction
+            for each .NET method.
+            
+            This method takes both a cacheName and a pythonName.  The cache name is the real method name.  The pythonName
+            is the name of the method as exposed to Python.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonTypeOps.IsMethodAlwaysVisible(System.Type,System.Reflection.MemberInfo[])">
+            <summary>
+            Checks to see if the provided members are always visible for the given type.
+            
+            This filters out methods such as GetHashCode and Equals on standard .NET 
+            types that we expose directly as Python types (e.g. object, string, etc...).
+            
+            It also filters out the base helper overrides that are added for supporting
+            super calls on user defined types.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonTypeOps.IsStaticFunction(System.Type,System.Reflection.MethodInfo)">
+            <summary>
+            a function is static if it's a static .NET method and it's defined on the type or is an extension method 
+            with StaticExtensionMethod decoration.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonTypeOps.EnsureBaseType(IronPython.Runtime.PythonTuple)">
+            <summary>
+            If we have only interfaces, we'll need to insert object's base
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ArrayOps.Multiply(System.Array,System.Int32)">
+            <summary>
+            Multiply two object[] arrays - slow version, we need to get the type, etc...
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ArrayOps.Multiply(System.Object[],System.Int32,System.Int32)">
+            <summary>
+            Multiply two object[] arrays - internal version used for objects backed by arrays
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ArrayOps.Add(System.Object[],System.Int32,System.Object[],System.Int32)">
+            <summary>
+            Add two arrays - internal versions for objects backed by arrays
+            </summary>
+            <param name="data1"></param>
+            <param name="size1"></param>
+            <param name="data2"></param>
+            <param name="size2"></param>
+            <returns></returns>
+        </member>
+        <member name="T:IronPython.Runtime.Operations.CharOps">
+            <summary>
+            We override the behavior of equals, compare and hashcode to make
+            chars seem as much like strings as possible.  In Python there is no
+            difference between these types.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Operations.CustomTypeDescHelpers">
+            <summary>
+            Helper class that all custom type descriptor implementations call for
+            the bulk of their implementation.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.DoubleOps.DoubleToFormatString(IronPython.Runtime.CodeContext,System.Double,IronPython.Runtime.StringFormatSpec)">
+            <summary>
+            Returns the digits for the format spec, no sign is included.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Operations.InstanceOps">
+             <summary>
+             InstanceOps contains methods that get added to CLS types depending on what
+             methods and constructors they define. These have not been added directly to
+             PythonType since they need to be added conditionally.
+             
+             Possibilities include:
+             
+                 __new__, one of 3 __new__ sets can be added:
+                     DefaultNew - This is the __new__ used for a PythonType (list, dict, object, etc...) that
+                         has only 1 default public constructor that takes no parameters.  These types are 
+                         mutable types, and __new__ returns a new instance of the type, and __init__ can be used
+                         to re-initialize the types.  This __new__ allows an unlimited number of arguments to
+                         be passed if a non-default __init__ is also defined.
+            
+                     NonDefaultNew - This is used when a type has more than one constructor, or only has one
+                         that takes more than zero parameters.  This __new__ does not allow an arbitrary # of
+                         extra arguments.
+             
+                     DefaultNewCls - This is the default new used for CLS types that have only a single ctor
+                         w/ an arbitray number of arguments.  This constructor allows setting of properties
+                         based upon an extra set of kw-args, e.g.: System.Windows.Forms.Button(Text='abc').  It
+                         is only used on non-Python types.
+             
+                 __init__:
+                     For types that do not define __init__ we have an __init__ function that takes an
+                     unlimited number of arguments and does nothing.  All types share the same reference
+                     to 1 instance of this.
+             
+                 next: Defined when a type is an enumerator to expose the Python iter protocol.
+             
+             
+                 repr: Added for types that override ToString
+             
+                 get: added for types that implement IDescriptor
+             </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.InstanceOps.DynamicDir(IronPython.Runtime.CodeContext,System.Dynamic.IDynamicMetaObjectProvider)">
+            <summary>
+            __dir__(self) -> Returns the list of members defined on a foreign IDynamicMetaObjectProvider.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.InstanceOps.EnterMethod(System.IDisposable)">
+            <summary>
+            Provides the implementation of __enter__ for objects which implement IDisposable.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.InstanceOps.ExitMethod(System.IDisposable,System.Object,System.Object,System.Object)">
+            <summary>
+            Provides the implementation of __exit__ for objects which implement IDisposable.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.InstanceOps.IsStaticTypeMemberInAll(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.String,System.Object@)">
+            <summary>
+            Determines if a type member can be imported.  This is used to treat static types like modules.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.InstanceOps.ContainsGenericMethod``1(IronPython.Runtime.CodeContext,System.Collections.Generic.IEnumerable{``0},``0)">
+            <summary>
+            Implements __contains__ for types implementing IEnumerable of T.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.InstanceOps.ContainsMethod(IronPython.Runtime.CodeContext,System.Collections.IEnumerable,System.Object)">
+            <summary>
+            Implements __contains__ for types implementing IEnumerable
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.InstanceOps.ContainsGenericMethodIEnumerator``1(IronPython.Runtime.CodeContext,System.Collections.Generic.IEnumerator{``0},``0)">
+            <summary>
+            Implements __contains__ for types implementing IEnumerable of T.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.InstanceOps.ContainsMethodIEnumerator(IronPython.Runtime.CodeContext,System.Collections.IEnumerator,System.Object)">
+            <summary>
+            Implements __contains__ for types implementing IEnumerable
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.InstanceOps.SerializeReduce(IronPython.Runtime.CodeContext,System.Object,System.Int32)">
+            <summary>
+            Implements __reduce_ex__ for .NET types which are serializable.  This uses the .NET
+            serializer to get a string of raw data which can be serialized.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Operations.ObjectOps">
+            <summary>
+            Contains Python extension methods that are added to object
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Operations.ObjectOps._nativelyPickleableTypes">
+            <summary> Types for which the pickle module has built-in support (from PEP 307 case 2)  </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Operations.ObjectOps.__class__">
+            <summary>
+            __class__, a custom slot so that it works for both objects and types.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__delattr__(IronPython.Runtime.CodeContext,System.Object,System.String)">
+            <summary>
+            Removes an attribute from the provided member
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__hash__(System.Object)">
+            <summary>
+            Returns the hash code of the given object
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__getattribute__(IronPython.Runtime.CodeContext,System.Object,System.String)">
+            <summary>
+            Gets the specified attribute from the object without running any custom lookup behavior
+            (__getattr__ and __getattribute__)
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__init__(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Initializes the object.  The base class does nothing.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__init__(IronPython.Runtime.CodeContext,System.Object,System.Object[])">
+            <summary>
+            Initializes the object.  The base class does nothing.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__init__(IronPython.Runtime.CodeContext,System.Object,System.Collections.Generic.IDictionary{System.Object,System.Object},System.Object[])">
+            <summary>
+            Initializes the object.  The base class does nothing.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__new__(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType)">
+            <summary>
+            Creates a new instance of the type
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__new__(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.Object[])">
+            <summary>
+            Creates a new instance of the type
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__new__(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.Collections.Generic.IDictionary{System.Object,System.Object},System.Object[])">
+            <summary>
+            Creates a new instance of the type
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__reduce__(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Runs the pickle protocol
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__reduce_ex__(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Runs the pickle protocol
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__reduce_ex__(IronPython.Runtime.CodeContext,System.Object,System.Object)">
+            <summary>
+            Runs the pickle protocol
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__repr__(System.Object)">
+            <summary>
+            Returns the code representation of the object.  The default implementation returns
+            a string which consists of the type and a unique numerical identifier.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__setattr__(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object)">
+            <summary>
+            Sets an attribute on the object without running any custom object defined behavior.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__sizeof__(System.Object)">
+            <summary>
+            Returns the number of bytes of memory required to allocate the object.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.__str__(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Returns a friendly string representation of the object. 
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.GetInitializedSlotValues(System.Object)">
+            <summary>
+            Return a dict that maps slot names to slot values, but only include slots that have been assigned to.
+            Looks up slots in base types as well as the current type.
+            
+            Sort-of Python equivalent (doesn't look up base slots, while the real code does):
+              return dict([(slot, getattr(self, slot)) for slot in type(self).__slots__ if hasattr(self, slot)])
+            
+            Return null if the object has no __slots__, or empty dict if it has __slots__ but none are initialized.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.ReduceProtocol0(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Implements the default __reduce_ex__ method as specified by PEP 307 case 2 (new-style instance, protocol 0 or 1)
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.FindClosestNonPythonBase(IronPython.Runtime.Types.PythonType)">
+            <summary>
+            Returns the closest base class (in terms of MRO) that isn't defined in Python code
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.ObjectOps.ReduceProtocol2(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Implements the default __reduce_ex__ method as specified by PEP 307 case 3 (new-style instance, protocol 2)
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Operations.PythonOps">
+            <summary>
+            Contains functions that are called directly from
+            generated code to perform low-level runtime functionality.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeDictFromItems(System.Object[])">
+            <summary>
+            Creates a new dictionary extracting the keys and values from the
+            provided data array.  Keys/values are adjacent in the array with
+            the value coming first.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeHomogeneousDictFromItems(System.Object[])">
+            <summary>
+            Creates a new dictionary extracting the keys and values from the
+            provided data array.  Keys/values are adjacent in the array with
+            the value coming first.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MultiplySequence``1(IronPython.Runtime.Operations.PythonOps.MultiplySequenceWorker{``0},``0,IronPython.Runtime.Index,System.Boolean)">
+            <summary>
+            Wraps up all the semantics of multiplying sequences so that all of our sequences
+            don't duplicate the same logic.  When multiplying sequences we need to deal with
+            only multiplying by valid sequence types (ints, not floats), support coercion
+            to integers if the type supports it, not multiplying by None, and getting the
+            right semantics for multiplying by negative numbers and 1 (w/ and w/o subclasses).
+            
+            This function assumes that it is only called for case where count is not implicitly
+            coercible to int so that check is skipped.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.CallWithContextAndThis(IronPython.Runtime.CodeContext,System.Object,System.Object,System.Object[])">
+            <summary>
+            Supports calling of functions that require an explicit 'this'
+            Currently, we check if the function object implements the interface 
+            that supports calling with 'this'. If not, the 'this' object is dropped
+            and a normal call is made.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.CheckInitializedAttribute(System.Object,System.Object,System.String)">
+            <summary>
+            Called from generated code emitted by NewTypeMaker.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.GetUserDescriptor(System.Object,System.Object,System.Object)">
+            <summary>
+            Handles the descriptor protocol for user-defined objects that may implement __get__
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.TrySetUserDescriptor(System.Object,System.Object,System.Object)">
+            <summary>
+            Handles the descriptor protocol for user-defined objects that may implement __set__
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.TryDeleteUserDescriptor(System.Object,System.Object)">
+            <summary>
+            Handles the descriptor protocol for user-defined objects that may implement __delete__
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.RaiseAssertionError(System.Object)">
+            <summary>
+            Python runtime helper for raising assertions. Used by AssertStatement.
+            </summary>
+            <param name="msg">Object representing the assertion message</param>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeList">
+            <summary>
+            Python runtime helper to create instance of Python List object.
+            </summary>
+            <returns>New instance of List</returns>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeList(System.Object[])">
+            <summary>
+            Python runtime helper to create a populated instance of Python List object.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeListNoCopy(System.Object[])">
+            <summary>
+            Python runtime helper to create a populated instance of Python List object w/o
+            copying the array contents.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeListFromSequence(System.Object)">
+            <summary>
+            Python runtime helper to create a populated instance of Python List object.
+            
+            List is populated by arbitrary user defined object.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeEmptyList(System.Int32)">
+            <summary>
+            Python runtime helper to create an instance of Python List object.
+            
+            List has the initial provided capacity.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeTuple(System.Object[])">
+            <summary>
+            Python runtime helper to create an instance of Tuple
+            </summary>
+            <param name="items"></param>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeTupleFromSequence(System.Object)">
+            <summary>
+            Python runtime helper to create an instance of Tuple
+            </summary>
+            <param name="items"></param>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.GetEnumeratorValues(IronPython.Runtime.CodeContext,System.Object,System.Int32)">
+            <summary>
+            Python Runtime Helper for enumerator unpacking (tuple assignments, ...)
+            Creates enumerator from the input parameter e, and then extracts 
+            expected number of values, returning them as array
+            
+            If the input is a Python tuple returns the tuples underlying data array.  Callers
+            should not mutate the resulting tuple.
+            </summary>
+            <param name="context">The code context of the AST getting enumerator values.</param>
+            <param name="e">object to enumerate</param>
+            <param name="expected">expected number of objects to extract from the enumerator</param>
+            <returns>
+            array of objects (.Lengh == expected) if exactly expected objects are in the enumerator.
+            Otherwise throws exception
+            </returns>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeSlice(System.Object,System.Object,System.Object)">
+            <summary>
+            Python runtime helper to create instance of Slice object
+            </summary>
+            <param name="start">Start of the slice.</param>
+            <param name="stop">End of the slice.</param>
+            <param name="step">Step of the slice.</param>
+            <returns>Slice</returns>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.PrintNewline(IronPython.Runtime.CodeContext)">
+            <summary>
+            Prints newline into default standard output
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.PrintNewlineWithDest(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Prints newline into specified destination. Sets softspace property to false.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.PrintComma(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Prints value into default standard output with Python comma semantics.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.PrintCommaWithDest(IronPython.Runtime.CodeContext,System.Object,System.Object)">
+            <summary>
+            Prints value into specified destination with Python comma semantics.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.PrintExpressionValue(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Called from generated code when we are supposed to print an expression value
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.ImportTop(IronPython.Runtime.CodeContext,System.String,System.Int32)">
+            <summary>
+            Called from generated code for:
+            
+            import spam.eggs
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.ImportBottom(IronPython.Runtime.CodeContext,System.String,System.Int32)">
+            <summary>
+            Python helper method called from generated code for:
+            
+            import spam.eggs as ham
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.ImportWithNames(IronPython.Runtime.CodeContext,System.String,System.String[],System.Int32)">
+            <summary>
+            Called from generated code for:
+            
+            from spam import eggs1, eggs2 
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.ImportFrom(IronPython.Runtime.CodeContext,System.Object,System.String)">
+            <summary>
+            Imports one element from the module in the context of:
+            
+            from module import a, b, c, d
+            
+            Called repeatedly for all elements being imported (a, b, c, d above)
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.ImportStar(IronPython.Runtime.CodeContext,System.String,System.Int32)">
+            <summary>
+            Called from generated code for:
+            
+            from spam import *
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.UnqualifiedExec(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Unqualified exec statement support.
+            A Python helper which will be called for the statement:
+            
+            exec code
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.QualifiedExec(IronPython.Runtime.CodeContext,System.Object,IronPython.Runtime.PythonDictionary,System.Object)">
+            <summary>
+            Qualified exec statement support,
+            Python helper which will be called for the statement:
+            
+            exec code in globals [, locals ]
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.BuildExceptionInfo(IronPython.Runtime.CodeContext,System.Exception)">
+            <summary>
+            Called from generated code at the start of a catch block.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.GetExceptionInfo(IronPython.Runtime.CodeContext)">
+            <summary>
+            Get an exception tuple for the "current" exception. This is used for sys.exc_info()
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.GetExceptionInfoLocal(IronPython.Runtime.CodeContext,System.Exception)">
+            <summary>
+            Get an exception tuple for a given exception. This is like the inverse of MakeException.
+            </summary>
+            <param name="context">the code context</param>
+            <param name="ex">the exception to create a tuple for.</param>
+            <returns>a tuple of (type, value, traceback)</returns>
+            <remarks>This is called directly by the With statement so that it can get an exception tuple
+            in its own private except handler without disturbing the thread-wide sys.exc_info(). </remarks>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeRethrownException(IronPython.Runtime.CodeContext)">
+            <summary>
+            helper function for re-raised exceptions.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeRethrowExceptionWorker(System.Exception)">
+            <summary>
+            helper function for re-raised exception.
+            This entry point is used by 'raise' inside 'with' statement
+            </summary>
+            <param name="e"></param>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeException(IronPython.Runtime.CodeContext,System.Object,System.Object,System.Object)">
+            <summary>
+            helper function for non-re-raise exceptions.
+            
+            type is the type of exception to throw or an instance.  If it 
+            is an instance then value should be null.  
+            
+            If type is a type then value can either be an instance of type,
+            a Tuple, or a single value.  This case is handled by EC.CreateThrowable.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.ExtractAnyArgument(IronPython.Runtime.PythonFunction,System.String,System.Int32,IronPython.Runtime.List,System.Collections.IDictionary)">
+            <summary>
+            Extracts an argument from either the dictionary or params
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.InitializeUserTypeSlots(IronPython.Runtime.Types.PythonType)">
+            <summary>
+            Creates a new array the values set to Uninitialized.Instance.  The array
+            is large enough to hold for all of the slots allocated for the type and
+            its sub types.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.IsNumericObject(System.Object)">
+            <summary>
+            Helper to determine if the value is a simple numeric type (int or big int or bool) - used for OldInstance
+            deprecated form of slicing.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.IsNumericType(System.Type)">
+            <summary>
+            Helper to determine if the type is a simple numeric type (int or big int or bool) - used for OldInstance
+            deprecated form of slicing.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.IsNonExtensibleNumericType(System.Type)">
+            <summary>
+            Helper to determine if the type is a simple numeric type (int or big int or bool) but not a subclass
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.NormalizeBigInteger(System.Object,System.Numerics.BigInteger,System.Nullable{System.Int32}@)">
+            <summary>
+            For slicing.  Fixes up a BigInteger and returns an integer w/ the length of the
+            object added if the value is negative.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.GetLengthOnce(System.Object,System.Nullable{System.Int32}@)">
+            <summary>
+            For slicing.  Gets the length of the object, used to only get the length once.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.CheckTypeVersion(System.Object,System.Int32)">
+            <summary>
+            Helper method for DynamicSite rules that check the version of their dynamic object
+            TODO - Remove this method for more direct field accesses
+            </summary>
+            <param name="o"></param>
+            <param name="version"></param>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.TestBoundBuiltinFunction(IronPython.Runtime.Types.BuiltinFunction,System.Object)">
+            <summary>
+            Called from generated code.  Gets a builtin function and the BuiltinFunctionData associated
+            with the object.  Tests to see if the function is bound and has the same data for the generated
+            rule.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.ConvertFromObject``1(System.Object)">
+            <summary>
+            Convert object to a given type. This code is equivalent to NewTypeMaker.EmitConvertFromObject
+            except that it happens at runtime instead of compile time.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.DefineDynamicAssembly(System.Reflection.AssemblyName,System.Reflection.Emit.AssemblyBuilderAccess)">
+            <summary>
+            Provides access to AppDomain.DefineDynamicAssembly which cannot be called from a DynamicMethod
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeNewCustomDelegate(System.Type[])">
+            <summary>
+            Generates a new delegate type.  The last type in the array is the return type.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeNewCustomDelegate(System.Type[],System.Nullable{System.Runtime.InteropServices.CallingConvention})">
+            <summary>
+            Generates a new delegate type.  The last type in the array is the return type.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.InitializeModule(System.Reflection.Assembly,System.String,System.String[])">
+            <summary>
+            Provides the entry point for a compiled module.  The stub exe calls into InitializeModule which
+            does the actual work of adding references and importing the main module.  Upon completion it returns
+            the exit code that the program reported via SystemExit or 0.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.InitializeModuleEx(System.Reflection.Assembly,System.String,System.String[],System.Boolean)">
+            <summary>
+            Provides the entry point for a compiled module.  The stub exe calls into InitializeModule which
+            does the actual work of adding references and importing the main module.  Upon completion it returns
+            the exit code that the program reported via SystemExit or 0.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.RemoveName(IronPython.Runtime.CodeContext,System.String)">
+            <summary>
+            Called from generated code, helper to remove a name
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.LookupName(IronPython.Runtime.CodeContext,System.String)">
+            <summary>
+            Called from generated code, helper to do name lookup
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.SetName(IronPython.Runtime.CodeContext,System.String,System.Object)">
+            <summary>
+            Called from generated code, helper to do name assignment
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.ToPython(System.IntPtr)">
+            <summary>
+            Returns an IntPtr in the proper way to CPython - an int or a Python long
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.MakeExceptionTypeError(System.Object)">
+            <summary>
+            Create at TypeError exception for when Raise() can't create the exception requested.  
+            </summary>
+            <param name="type">original type of exception requested</param>
+            <returns>a TypeEror exception</returns>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.PythonOps.GetDynamicStackFrames(System.Exception)">
+            <summary>
+            Gets a list of DynamicStackFrames for the given exception.  These stack frames
+            can be programmatically inspected to understand the frames the exception crossed
+            through including Python frames.
+            
+            Dynamic stack frames are not preserved when an exception crosses an app domain
+            boundary.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Operations.UnicodeHelper">
+            <summary>
+            Helper clas for calls to unicode(...).  We generate code which checks if unicode
+            is str and if it is we redirect those calls to the unicode function defined on this
+            class.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Operations.ExtensibleString">
+            <summary>
+            ExtensibleString is the base class that is used for types the user defines
+            that derive from string.  It carries along with it the string's value and
+            our converter recognizes it as a string.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Operations.StringOps">
+            <summary>
+            StringOps is the static class that contains the methods defined on strings, i.e. 'abc'
+            
+            Here we define all of the methods that a Python user would see when doing dir('abc').
+            If the user is running in a CLS aware context they will also see all of the methods
+            defined in the CLS System.String type.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.StringOps.capitalize(System.String)">
+            <summary>
+            Returns a copy of this string converted to uppercase
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.StringOps.istitle(System.String)">
+            <summary>
+            return true if self is a titlecased string and there is at least one
+            character in self; also, uppercase characters may only follow uncased
+            characters (e.g. whitespace) and lowercase characters only cased ones.
+            return false otherwise.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.StringOps.join(System.String,System.Object)">
+            <summary>
+            Return a string which is the concatenation of the strings 
+            in the sequence seq. The separator between elements is the 
+            string providing this method
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.StringOps.format(IronPython.Runtime.CodeContext,System.String,System.Object[])">
+            <summary>
+            Replaces each replacement field in the string with the provided arguments.
+            
+            replacement_field =  "{" field_name ["!" conversion] [":" format_spec] "}"
+            field_name        =  (identifier | integer) ("." identifier | "[" element_index "]")*
+            
+            format_spec: [[fill]align][sign][#][0][width][,][.precision][type]
+            
+            Conversion can be 'r' for repr or 's' for string.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.StringOps.format(IronPython.Runtime.CodeContext,System.String,System.Collections.Generic.IDictionary{System.Object,System.Object},System.Object[])">
+            <summary>
+            Replaces each replacement field in the string with the provided arguments.
+            
+            replacement_field =  "{" field_name ["!" conversion] [":" format_spec] "}"
+            field_name        =  (identifier | integer) ("." identifier | "[" element_index "]")*
+            
+            format_spec: [[fill]align][sign][#][0][width][.precision][type]
+            
+            Conversion can be 'r' for repr or 's' for string.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.StringOps.GetStartingOffset(System.Text.Encoding,System.Byte[])">
+            <summary>
+            Gets the starting offset checking to see if the incoming bytes already include a preamble.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Operations.StringOps.PythonEncoderFallbackBuffer">
+            When encoding or decoding strings if an error occurs CPython supports several different
+            behaviors, in addition it supports user-extensible behaviors as well.  For the default
+            behavior we're ok - both of us support throwing and replacing.  For custom behaviors
+            we define a single fallback for decoding and encoding that calls the python function to do
+            the replacement.
+            
+            When we do the replacement we call the provided handler w/ a UnicodeEncodeError or UnicodeDecodeError
+            object which contains:
+                    encoding    (string, the encoding the user requested)
+                    end         (the end of the invalid characters)
+                    object      (the original string being decoded)
+                    reason      (the error, e.g. 'unexpected byte code', not sure of others)
+                    start       (the start of the invalid sequence)
+                    
+            The decoder returns a tuple of (unicode, int) where unicode is the replacement string
+            and int is an index where encoding should continue.
+        </member>
+        <member name="M:IronPython.Runtime.Operations.TypeGroupOps.GetItem(Microsoft.Scripting.Actions.TypeGroup,IronPython.Runtime.Types.PythonType[])">
+            <summary>
+            Indexer for generic parameter resolution.  We bind to one of the generic versions
+            available in this type collision.  A user can also do someType[()] to force to
+            bind to the non-generic version, but we will always present the non-generic version
+            when no bindings are available.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Operations.UserTypeOps.ToStringHelper(IronPython.Runtime.Types.IPythonObject)">
+            <summary>
+            Object.ToString() displays the CLI type name.  But we want to display the class name (e.g.
+            '&lt;foo object at 0x000000000000002C&gt;' unless we've overridden __repr__ but not __str__ in 
+            which case we'll display the result of __repr__.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Operations.UserTypeDebugView">
+            <summary>
+            Provides a debug view for user defined types.  This class is declared as public
+            because it is referred to from generated code.  You should not use this class.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Operations.IDelegateConvertible">
+            <summary>
+            Interface used for things which can convert to delegates w/o code gen.  Currently
+            this is just non-overloaded builtin functions and bound builtin functions.  Avoiding
+            the code gen is not only nice for compilation but it also enables delegates to be added
+            in C# and removed in Python.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.PythonHiddenBaseClassAttribute">
+            <summary>
+            Marks a class as being hidden from the Python hierarchy.  This is applied to the base class
+            and then all derived types will not see the base class in their hierarchy and will not be
+            able to access members declaredo on the base class.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.SequenceTypeInfoAttribute">
+            <summary>
+            Provides more specific type information for Python lists which are not strongly typed.
+            
+            This attribute can be applied to fields, parameters, proeprties, and return values.  It can be
+            inspected to get type information about the types of the values of the expected 
+            list or the returned list.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.ModuleContext">
+            <summary>
+            Captures the globals and other state of module code.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ModuleContext.#ctor(IronPython.Runtime.PythonDictionary,IronPython.Runtime.PythonContext)">
+            <summary>
+            Creates a new ModuleContext which is backed by the specified dictionary.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ModuleContext.#ctor(IronPython.Runtime.PythonModule,IronPython.Runtime.PythonContext)">
+            <summary>
+            Creates a new ModuleContext for the specified module.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.ModuleContext.Globals">
+            <summary>
+            Gets the dictionary used for the global variables in the module
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.ModuleContext.Context">
+            <summary>
+            Gets the language context which created this module.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.ModuleContext.GlobalScope">
+            <summary>
+            Gets the DLR Scope object which is associated with the modules dictionary.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.ModuleContext.GlobalContext">
+            <summary>
+            Gets the global CodeContext object which is used for execution of top-level code.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.ModuleContext.Module">
+            <summary>
+            Gets the module object which this code is executing in.
+            
+            This module may or may not be published in sys.modules.  For user defined
+            code typically the module gets published at the start of execution.  But if
+            this ModuleContext is attached to a Scope, or if we've just created a new
+            module context for executing code it will not be in sys.modules.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.ModuleContext.Features">
+            <summary>
+            Gets the features that code has been compiled with in the module.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.ModuleContext.ShowCls">
+            <summary>
+            Gets or sets whether code running in this context should display
+            CLR members (for example .ToString on objects).
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ModuleContext.InitializeBuiltins(System.Boolean)">
+            <summary>
+            Initializes __builtins__ for the module scope.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.ModuleGlobalCache">
+            <summary>
+            Cached global value.  Created and maintained on a per-language basis.  Default
+            implementation returns a singleton which indicates caching is not occuring.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ModuleGlobalCache.#ctor(System.Object)">
+            <summary>
+            Creates a new ModuleGlobalCache with the specified value.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.ModuleGlobalCache.IsCaching">
+            <summary>
+            True if the ModuleGlobalCache is participating in a caching strategy.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.ModuleGlobalCache.HasValue">
+            <summary>
+            True if there is currently a value associated with this global variable.  False if
+            it is currently unassigned.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.ModuleGlobalCache.Value">
+            <summary>
+            Gets or sets the current cached value
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ModuleGlobalCache.Changed(System.Object,Microsoft.Scripting.Runtime.ModuleChangeEventArgs)">
+            <summary>
+            Event handler for when the value has changed.  Language implementors should call this when
+            the cached value is invalidated.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.ModuleOptions.TrueDivision">
+            <summary>
+            Enable true division (1/2 == .5)
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.ModuleOptions.ShowClsMethods">
+            <summary>
+            Indicates that .NET methods such as .ToString should be available on Python objects.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.ModuleOptions.Optimized">
+            <summary>
+            Indicates that the module should be generated in an optimal form which will result
+            in it being uncollectable.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.ModuleOptions.Initialize">
+            <summary>
+            Indicates when the module should be executed immedatiately upon creation.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.ModuleOptions.WithStatement">
+            <summary>
+            Enable usage of the with statement
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.ModuleOptions.AbsoluteImports">
+            <summary>
+            Enable absolute imports
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.ModuleOptions.NoBuiltins">
+            <summary>
+            Indiciates that __builtins__ should not be set in the module
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.ModuleOptions.ModuleBuiltins">
+            <summary>
+            Indiciates that when the module is initialized it should set __builtins__ to the __builtin__ module
+            instead of the __builtin__ dictionary.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.ModuleOptions.ExecOrEvalCode">
+            <summary>
+            Marks code as being created for exec, eval.  Code generated this way will
+            be capable of running against different scopes and will do lookups at runtime
+            for free global variables.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.ModuleOptions.SkipFirstLine">
+            <summary>
+            Indiciates that the first line of code should be skipped.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.ModuleOptions.PrintFunction">
+            <summary>
+            Enable usage of print as a function for better compatibility with Python 3.0.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.ModuleOptions.Interpret">
+            <summary>
+            Forces the code to be interpreted rather than compiled
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.ModuleOptions.UnicodeLiterals">
+            <summary>
+            String Literals should be parsed as Unicode strings
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.ModuleOptions.Verbatim">
+            <summary>
+            Include comments in the parse tree
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.ModuleOptions.LightThrow">
+            <summary>
+            Generated code should support light exceptions
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Profiler">
+            <summary>
+            Manages the acquisition of profiling data for a single ScriptRuntime
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Profiler.GetProfiler(IronPython.Runtime.PythonContext)">
+            <summary>
+            Get the unique Profiler instance for this ScriptRuntime
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Profiler.GetProfilerIndex(System.Reflection.MethodBase)">
+            <summary>
+            Given a MethodBase, return an index into the array of perf data.  Treat each
+            CLR method as unique.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Profiler.GetProfilerIndex(System.String)">
+            <summary>
+            Given the unique name of something we're profiling, return an index into the array of perf data.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Profiler.GetNewProfilerIndex(System.String)">
+            <summary>
+            Add a new profiler entry. Not all names are unique.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Profiler.GetProfile(System.Boolean)">
+            <summary>
+            Gets the current summary of profile data
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Profiler.Reset">
+            <summary>
+            Resets the current summary of profile data back to zero
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Profiler.AddProfiling(System.Linq.Expressions.Expression,System.Linq.Expressions.ParameterExpression,System.String,System.Boolean)">
+            <summary>
+            Adds profiling calls to a Python method.
+            Calculates both the time spent only in this method
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Profiler.AddProfiling(System.Linq.Expressions.Expression,System.Reflection.MethodBase)">
+            <summary>
+            Wraps a call to a MethodInfo with profiling capture for that MethodInfo
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Profiler.Data">
+            <summary>
+            Encapsulates profiler data to return to clients
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.ProfilerTreatsAsExternalAttribute">
+            <summary>
+            Marks that this built-in method should be treated as external by the profiler.
+            When placed on a call emitted into a Python method, all the time spent in this
+            call will still show up in its parent's inclusive time, but will not be
+            part of its exclusive time.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CustomDictionaryStorage.GetExtraItems">
+            <summary>
+            Gets all of the extra names and values stored in the dictionary.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CustomDictionaryStorage.TrySetExtraValue(System.String,System.Object)">
+            <summary>
+            Attemps to sets a value in the extra keys.  Returns true if the value is set, false if 
+            the value is not an extra key.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CustomDictionaryStorage.TryGetExtraValue(System.String,System.Object@)">
+            <summary>
+            Attempts to get a value from the extra keys.  Returns true if the value is an extra
+            key and has a value.  False if it is not an extra key or doesn't have a value.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CustomDictionaryStorage.TryRemoveExtraValue(System.String)">
+            <summary>
+            Attempts to remove the key.  Returns true if the key is removed, false
+            if the key was not removed, or null if the key is not an extra key.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.ByteArray">
+            <summary>
+            bytearray(string, encoding[, errors]) -> bytearray
+            bytearray(iterable) -> bytearray
+            
+            Construct a mutable bytearray object from:
+             - an iterable yielding values in range(256), including:
+                + a list of integer values
+                + a bytes, bytearray, buffer, or array object
+             - a text string encoded using the specified encoding
+             
+            bytearray([int]) -> bytearray
+            
+            Construct a zero-ititialized bytearray of the specified length.
+            (default=0)
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ByteArray.istitle">
+            <summary>
+            return true if self is a titlecased string and there is at least one
+            character in self; also, uppercase characters may only follow uncased
+            characters (e.g. whitespace) and lowercase characters only cased ones. 
+            return false otherwise.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ByteArray.join(System.Object)">
+            <summary>
+            Return a string which is the concatenation of the strings 
+            in the sequence seq. The separator between elements is the 
+            string providing this method
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Bytes.istitle">
+            <summary>
+            return true if self is a titlecased string and there is at least one
+            character in self; also, uppercase characters may only follow uncased
+            characters (e.g. whitespace) and lowercase characters only cased ones. 
+            return false otherwise.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Bytes.join(System.Object)">
+            <summary>
+            Return a string which is the concatenation of the strings 
+            in the sequence seq. The separator between elements is the 
+            string providing this method
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Bytes.ToByteArray">
+            <summary>
+            Returns a copy of the internal byte array.
+            </summary>
+            <returns>
+            System.Byte[]
+            </returns>
+        </member>
+        <member name="M:IronPython.Runtime.Bytes.GetUnsafeByteArray">
+            <summary>
+            This method returns the underlying byte array directly.
+            It should be used sparingly!
+            </summary>
+            <returns>
+            System.Byte[]
+            </returns>
+        </member>
+        <member name="T:IronPython.Runtime.ClassMethodAttribute">
+            <summary>
+            Marks a method as being a class method.  The PythonType which was used to access
+            the method will then be passed as the first argument.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.ClrModule">
+            <summary>
+            this class contains objecs and static methods used for
+            .NET/CLS interop with Python.  
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.GetCurrentRuntime(IronPython.Runtime.CodeContext)">
+            <summary>
+            Gets the current ScriptDomainManager that IronPython is loaded into.  The
+            ScriptDomainManager can then be used to work with the language portion of the
+            DLR hosting APIs.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.Use(IronPython.Runtime.CodeContext,System.String)">
+            <summary>
+            Use(name) -> module
+            
+            Attempts to load the specified module searching all languages in the loaded ScriptRuntime.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.Use(IronPython.Runtime.CodeContext,System.String,System.String)">
+            <summary>
+            Use(path, language) -> module
+            
+            Attempts to load the specified module belonging to a specific language loaded into the
+            current ScriptRuntime.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.SetCommandDispatcher(IronPython.Runtime.CodeContext,System.Action{System.Action})">
+            <summary>
+            SetCommandDispatcher(commandDispatcher)
+            
+            Sets the current command dispatcher for the Python command line.  
+            
+            The command dispatcher will be called with a delegate to be executed.  The command dispatcher
+            should invoke the target delegate in the desired context.
+            
+            A common use for this is to enable running all REPL commands on the UI thread while the REPL
+            continues to run on a non-UI thread.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.LoadTypeLibrary(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            LoadTypeLibrary(rcw) -> type lib desc
+            
+            Gets an ITypeLib object from OLE Automation compatible RCW ,
+            reads definitions of CoClass'es and Enum's from this library
+            and creates an object that allows to instantiate coclasses
+            and get actual values for the enums.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.LoadTypeLibrary(IronPython.Runtime.CodeContext,System.Guid)">
+            <summary>
+            LoadTypeLibrary(guid) -> type lib desc
+            
+            Reads the latest registered type library for the corresponding GUID,
+            reads definitions of CoClass'es and Enum's from this library
+            and creates a IDynamicMetaObjectProvider that allows to instantiate coclasses
+            and get actual values for the enums.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.AddReferenceToTypeLibrary(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            AddReferenceToTypeLibrary(rcw) -> None
+            
+            Makes the type lib desc available for importing. See also LoadTypeLibrary.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.AddReferenceToTypeLibrary(IronPython.Runtime.CodeContext,System.Guid)">
+            <summary>
+            AddReferenceToTypeLibrary(guid) -> None
+            
+            Makes the type lib desc available for importing.  See also LoadTypeLibrary.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.GetClrType(System.Type)">
+            <summary>
+            Gets the CLR Type object from a given Python type object.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.GetPythonType(System.Type)">
+            <summary>
+            Gets the Python type object from a given CLR Type object.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.GetDynamicType(System.Type)">
+            <summary>
+            OBSOLETE: Gets the Python type object from a given CLR Type object.
+            
+            Use clr.GetPythonType instead.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.accepts(System.Object[])">
+            <summary>
+            accepts(*types) -> ArgChecker
+            
+            Decorator that returns a new callable object which will validate the arguments are of the specified types.
+            </summary>
+            <param name="types"></param>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.returns(System.Object)">
+            <summary>
+            returns(type) -> ReturnChecker
+            
+            Returns a new callable object which will validate the return type is of the specified type.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.ClrModule.ArgChecker">
+            <summary>
+            Decorator for verifying the arguments to a function are of a specified type.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.ClrModule.RuntimeArgChecker">
+            <summary>
+            Returned value when using clr.accepts/ArgChecker.  Validates the argument types and
+            then calls the original function.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.ClrModule.ReturnChecker">
+            <summary>
+            Decorator for verifying the return type of functions.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.ClrModule.RuntimeReturnChecker">
+            <summary>
+            Returned value when using clr.returns/ReturnChecker.  Calls the original function and
+            validates the return type is of a specified type.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.Dir(System.Object)">
+            <summary>
+            returns the result of dir(o) as-if "import clr" has not been performed.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.DirClr(System.Object)">
+            <summary>
+            Returns the result of dir(o) as-if "import clr" has been performed.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.Convert(IronPython.Runtime.CodeContext,System.Object,System.Type)">
+            <summary>
+            Attempts to convert the provided object to the specified type.  Conversions that 
+            will be attempted include standard Python conversions as well as .NET implicit
+            and explicit conversions.
+            
+            If the conversion cannot be performed a TypeError will be raised.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.CompileModules(IronPython.Runtime.CodeContext,System.String,System.Collections.Generic.IDictionary{System.String,System.Object},System.String[])">
+            <summary>
+            Provides a helper for compiling a group of modules into a single assembly.  The assembly can later be
+            reloaded using the clr.AddReference API.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.CompileSubclassTypes(System.String,System.Object[])">
+            <summary>
+            clr.CompileSubclassTypes(assemblyName, *typeDescription)
+            
+            Provides a helper for creating an assembly which contains pre-generated .NET 
+            base types for new-style types.
+            
+            This assembly can then be AddReferenced or put sys.prefix\DLLs and the cached 
+            types will be used instead of generating the types at runtime.
+            
+            This function takes the name of the assembly to save to and then an arbitrary 
+            number of parameters describing the types to be created.  Each of those
+            parameter can either be a plain type or a sequence of base types.
+            
+            clr.CompileSubclassTypes(object) -> create a base type for object
+            clr.CompileSubclassTypes(object, str, System.Collections.ArrayList) -> create 
+                base  types for both object and ArrayList.
+                
+            clr.CompileSubclassTypes(object, (object, IComparable)) -> create base types for 
+                object and an object which implements IComparable.
+            
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.GetSubclassedTypes">
+            <summary>
+            clr.GetSubclassedTypes() -> tuple
+            
+            Returns a tuple of information about the types which have been subclassed. 
+            
+            This tuple can be passed to clr.CompileSubclassTypes to cache these
+            types on disk such as:
+            
+            clr.CompileSubclassTypes('assembly', *clr.GetSubclassedTypes())
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.ClrModule.FileStreamContentProvider">
+            <summary>
+            Provides a StreamContentProvider for a stream of content backed by a file on disk.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.BuildPackageMap(System.String[])">
+            <summary>
+            Goes through the list of files identifying the relationship between packages
+            and subpackages.  Returns a dictionary with all of the package filenames (minus __init__.py)
+            mapping to their full name.  For example given a structure:
+            
+            C:\
+                someDir\
+                    package\
+                        __init__.py
+                        a.py
+                        b\
+                            __init.py
+                            c.py
+                    
+            Returns:
+                {r'C:\somedir\package' : 'package', r'C:\somedir\package\b', 'package.b'}
+                
+            This can then be used for calculating the full module name of individual files
+            and packages.  For example a's full name is "package.a" and c's full name is
+            "package.b.c".
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.GetProfilerData(IronPython.Runtime.CodeContext,System.Boolean)">
+            <summary>
+            Returns a list of profile data. The values are tuples of Profiler.Data objects
+            
+            All times are expressed in the same unit of measure as DateTime.Ticks
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.ClearProfilerData(IronPython.Runtime.CodeContext)">
+            <summary>
+            Resets all profiler counters back to zero
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.EnableProfiler(IronPython.Runtime.CodeContext,System.Boolean)">
+            <summary>
+            Enable or disable profiling for the current ScriptEngine.  This will only affect code
+            that is compiled after the setting is changed; previously-compiled code will retain
+            whatever setting was active when the code was originally compiled.
+            
+            The easiest way to recompile a module is to reload() it.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.Serialize(System.Object)">
+            <summary>
+            Serializes data using the .NET serialization formatter for complex
+            types.  Returns a tuple identifying the serialization format and the serialized 
+            data which can be fed back into clr.Deserialize.
+            
+            Current serialization formats include custom formats for primitive .NET
+            types which aren't already recognized as tuples.  None is used to indicate
+            that the Binary .NET formatter is used.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.ClrModule.Deserialize(System.String,System.String)">
+            <summary>
+            Deserializes the result of a Serialize call.  This can be used to perform serialization
+            for .NET types which are serializable.  This method is the callable object provided
+            from __reduce_ex__ for .serializable .NET types.
+            
+            The first parameter indicates the serialization format and is the first tuple element
+            returned from the Serialize call.  
+            
+            The second parameter is the serialized data.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Index">
+            <summary>
+            Wrapper class used when a user defined type (new-style or old-style)
+            defines __index__.  We provide a conversion from all user defined
+            types to the Index type so they can be used for determing and method bind
+            time the most appropriate method to dispatch to.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.NewStringFormatter">
+             <summary>
+             New string formatter for 'str'.format(...) calls and support for the Formatter
+             library via the _formatter_parser / _formatter_field_name_split
+             methods.
+            
+             We parse this format:
+            
+             replacement_field =  "{" field_name ["!" conversion] [":" format_spec] "}"
+             field_name        =  (identifier | integer) ("." attribute_name | "[" element_index "]")*
+             attribute_name    =  identifier
+             element_index     =  identifier
+             conversion        =  "r" | "s"
+             format_spec       = any char, { must be balanced (for computed values), passed to __format__ method on object
+             </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.FormatString(IronPython.Runtime.PythonContext,System.String,IronPython.Runtime.PythonTuple,System.Collections.Generic.IDictionary{System.Object,System.Object})">
+            <summary>
+            Runs the formatting operation on the given format and keyword arguments
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.GetFormatInfo(System.String)">
+             <summary>
+             Gets the formatting information for the given format.  This is a list of tuples.  The tuples
+             include:
+            
+             text, field name, format spec, conversion
+             </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.GetFieldNameInfo(System.String)">
+             <summary>
+             Parses a field name returning the argument name and an iterable
+             object which can be used to access the individual attribute
+             or element accesses.  The iterator yields tuples of:
+            
+             bool (true if attribute, false if element index), attribute/index value
+             </summary>
+        </member>
+        <member name="T:IronPython.Runtime.NewStringFormatter.StringFormatParser">
+            <summary>
+            Base class used for parsing the format.  Subclasss override Text/ReplacementField methods.  Those
+            methods get called when they call Parse and then they can do the appropriate actions for the
+            format.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.Parse(System.String)">
+             <summary>
+             Gets an enumerable object for walking the parsed format.
+            
+             TODO: object array?  struct?
+             </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.Parse">
+            <summary>
+            Provides an enumerable of the parsed format.  The elements of the tuple are:
+                the text preceding the format information
+                the field name
+                the format spec
+                the conversion
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.ParseDoubleBracket(System.Int32,System.String@)">
+            <summary>
+            Handles {{ and }} within the string.  Returns true if a double bracket
+            is found and yields the text
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.ParseConversion">
+            <summary>
+            Parses the conversion character and returns it
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.CheckEnd">
+            <summary>
+            Checks to see if we're at the end of the format.  If there's no more characters left we report
+            the error, otherwise if we hit a } we return true to indicate parsing should stop.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.ParseFormatSpec(System.Int32@)">
+            <summary>
+            Parses the format spec string and returns it.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.ParseFieldName(System.Int32@)">
+            <summary>
+            Parses the field name and returns it.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.ParseFieldOrSpecWorker(System.Char[],System.Int32@)">
+             <summary>
+             Handles parsing the field name and the format spec and returns it.  At the parse
+             level these are basically the same - field names just have more terminating characters.
+            
+             The most complex part of parsing them is they both allow nested braces and require
+             the braces are matched.  Strangely though the braces need to be matched across the
+             combined field and format spec - not within each format.
+             </summary>
+        </member>
+        <member name="T:IronPython.Runtime.NewStringFormatter.Formatter">
+            <summary>
+            Provides the built-in string formatter which is exposed to Python via the str.format API.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.Formatter.ReplaceComputedFormats(System.String)">
+            <summary>
+            Inspects a format spec to see if it contains nested format specs which
+            we need to compute.  If so runs another string formatter on the format
+            spec to compute those values.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.Formatter.GetArgumentValue(IronPython.Runtime.NewStringFormatter.FieldName)">
+            <summary>
+            Given the field name gets the object from our arguments running
+            any of the member/index accessors.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.Formatter.ApplyConversion(System.Nullable{System.Char},System.Object)">
+            <summary>
+            Applies the known built-in conversions to the object if a conversion is
+            specified.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.Formatter.GetUnaccessedObject(IronPython.Runtime.NewStringFormatter.FieldName)">
+            <summary>
+            Gets the initial object represented by the field name - e.g. the 0 or
+            keyword name.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.Formatter.DoAccessors(IronPython.Runtime.NewStringFormatter.FieldName,System.Object)">
+            <summary>
+            Given the object value runs the accessors in the field name (if any) against the object.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.ParseFieldName(System.String,System.Boolean)">
+            <summary>
+            Parses the field name including attribute access or element indexing.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.ParseFieldAccessors(System.String,System.Int32,System.Boolean)">
+            <summary>
+            Parses the field name including attribute access or element indexing.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.AccessorsToPython(System.Collections.Generic.IEnumerable{IronPython.Runtime.NewStringFormatter.FieldAccessor})">
+            <summary>
+            Converts accessors from our internal structure into a PythonTuple matching how CPython
+            exposes these
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.NewStringFormatter.ParseIdentifier(System.String,System.Boolean,System.Int32@)">
+            <summary>
+            Parses an identifier and returns it
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.NewStringFormatter.FieldName">
+            <summary>
+            Encodes all the information about the field name.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.NewStringFormatter.FieldAccessor">
+            <summary>
+            Encodes a single field accessor (.b or [number] or [str])
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.PythonContext.NewObject">
+            <summary> stored for copy_reg module, used for reduce protocol </summary>
+        </member>
+        <member name="F:IronPython.Runtime.PythonContext.PythonReconstructor">
+            <summary> stored for copy_reg module, used for reduce protocol </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.#ctor(Microsoft.Scripting.Runtime.ScriptDomainManager,System.Collections.Generic.IDictionary{System.String,System.Object})">
+            <summary>
+            Creates a new PythonContext not bound to Engine.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonContext.RecursionLimit">
+            <summary>
+            Gets or sets the maximum depth of function calls.  Equivalent to sys.getrecursionlimit
+            and sys.setrecursionlimit.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonContext.MainThread">
+            <summary>
+            Gets or sets the main thread which should be interupted by thread.interrupt_main
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.HasModuleState(System.Object)">
+            <summary>
+            Checks to see if module state has the current value stored already.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.GetModuleState(System.Object)">
+            <summary>
+            Gets per-runtime state used by a module.  The module should have a unique key for
+            each piece of state it needs to store.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.SetModuleState(System.Object,System.Object)">
+            <summary>
+            Sets per-runtime state used by a module.  The module should have a unique key for
+            each piece of state it needs to store.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.GetSetModuleState(System.Object,System.Object)">
+            <summary>
+            Sets per-runtime state used by a module and returns the previous value.  The module
+            should have a unique key for each piece of state it needs to store.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.GetOrCreateModuleState``1(System.Object,System.Func{``0})">
+            <summary>
+            Sets per-runtime state used by a module and returns the previous value.  The module
+            should have a unique key for each piece of state it needs to store.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.InitializeSystemState">
+            <summary>
+            Initializes the sys module on startup.  Called both to load and reload sys
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.ReadOneLine(System.IO.StreamReader,System.Int32@)">
+            <summary>
+            Reads one line keeping track of the # of bytes read
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.HookAssemblyResolve">
+            <summary>
+            We use Assembly.LoadFile to load assemblies from a path specified by the script (in LoadAssemblyFromFileWithPath).
+            However, when the CLR loader tries to resolve any of assembly references, it will not be able to
+            find the dependencies, unless we can hook into the CLR loader.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.GetPythonService(Microsoft.Scripting.Hosting.ScriptEngine)">
+            <summary>
+            Returns (and creates if necessary) the PythonService that is associated with this PythonContext.
+            
+            The PythonService is used for providing remoted convenience helpers for the DLR hosting APIs.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonContext.DefaultEncoding">
+            <summary>
+            Gets or sets the default encoding for this system state / engine.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonContext.BuiltinModules">
+            <summary>
+            Dictionary from name to type of all known built-in module names.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonContext.BuiltinModuleNames">
+            <summary>
+            Dictionary from type to name of all built-in modules.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonContext.BuiltinModuleInstance">
+            <summary>
+            TODO: Remove me, or stop caching built-ins.  This is broken if the user changes __builtin__
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.GetMemberNames(System.Object)">
+            <summary>
+            Gets the member names associated with the object
+            TODO: Move "GetMemberNames" functionality into MetaObject implementations
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonContext.ErrorHandlers">
+            <summary> Dictionary of error handlers for string codecs. </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonContext.SearchFunctions">
+            <summary> Table of functions used for looking for additional codecs. </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.GetGenericSiteStorage``1">
+            <summary>
+            Gets a SiteLocalStorage when no call site is available.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.Operation(IronPython.Runtime.Binding.PythonOperationKind,System.Object,System.Object)">
+            <summary>
+            Invokes the specified operation on the provided arguments and returns the new resulting value.
+            
+            operation is usually a value from StandardOperators (standard CLR/DLR operator) or 
+            OperatorStrings (a Python specific operator)
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonContext.SharedContext">
+            <summary>
+            Returns a shared code context for the current PythonContext.  This shared
+            context can be used for performing general operations which usually
+            require a CodeContext.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonContext.SharedOverloadResolverFactory">
+            <summary>
+            Returns an overload resolver for the current PythonContext.  The overload
+            resolver will flow the shared context through as it's CodeContext.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonContext.SharedClsContext">
+            <summary>
+            Returns a shared code context for the current PythonContext.  This shared
+            context can be used for doing lookups which need to occur as if they
+            happened in a module which has done "import clr".
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.GetSetCommandDispatcher(System.Action{System.Action})">
+            <summary>
+            Sets the current command dispatcher for the Python command line.  The previous dispatcher
+            is returned.  Null can be passed to remove the current command dispatcher.
+            
+            The command dispatcher will be called with a delegate to be executed.  The command dispatcher
+            should invoke the target delegate in the desired context.
+            
+            A common use for this is to enable running all REPL commands on the UI thread while the REPL
+            continues to run on a non-UI thread.
+            
+            The ipy.exe REPL will call into PythonContext.DispatchCommand to dispatch each execution to
+            the correct thread.  Other REPLs can do the same to support this functionality as well.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.DispatchCommand(System.Action)">
+            <summary>
+            Dispatches the command to the current command dispatcher.  If there is no current command
+            dispatcher the command is executed immediately on the current thread.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.GetComparer(System.Object,System.Type)">
+            <summary>
+            Gets a function which can be used for comparing two values.  If cmp is not null
+            then the comparison will use the provided comparison function.  Otherwise
+            it will use the normal Python semantics.
+            
+            If type is null then a generic comparison function is returned.  If type is 
+            not null a comparison function is returned that's used for just that type.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.Collect(System.Int32)">
+            <summary>
+            Performs a GC collection including the possibility of freeing weak data structures held onto by the Python runtime.
+            </summary>
+            <param name="generation"></param>
+        </member>
+        <member name="M:IronPython.Runtime.PythonContext.GetPythonContext(System.Dynamic.DynamicMetaObjectBinder)">
+            <summary>
+            Gets a PythonContext given a DynamicMetaObjectBinder.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.PythonDynamicStackFrame">
+            <summary>
+            A DynamicStackFrame which has Python specific data.  Currently this
+            includes the code context which may provide access to locals and the
+            function code object which is needed to build frame objects from.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonDynamicStackFrame.CodeContext">
+            <summary>
+            Gets the code context of the function.
+            
+            If the function included a call to locals() or the FullFrames
+            option is enabled then the code context includes all local variables.
+            
+            Null if deserialized.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonDynamicStackFrame.Code">
+            <summary>
+            Gets the code object for this frame.  This is used in creating
+            the trace back. Null if deserialized.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.PythonFunction">
+            <summary>
+            Created for a user-defined function.  
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonFunction.#ctor(IronPython.Runtime.CodeContext,IronPython.Runtime.FunctionCode,IronPython.Runtime.PythonDictionary,System.String,IronPython.Runtime.PythonTuple,IronPython.Runtime.PythonTuple)">
+            <summary>
+            Python ctor - maps to function.__new__
+            
+            y = func(x.__code__, globals(), 'foo', None, (a, ))
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonFunction.Context">
+            <summary>
+            The parent CodeContext in which this function was declared.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonFunction.FunctionCompatibility">
+            <summary>
+            Captures the # of args and whether we have kw / arg lists.  This
+            enables us to share sites for simple calls (calls that don't directly
+            provide named arguments or the list/dict params).
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonFunction.CalculatedCachedCompat">
+            <summary>
+            Calculates the _compat value which is used for call-compatibility checks
+            for simple calls.  Whenver any of the dependent values are updated this
+            must be called again.
+            
+            The dependent values include:
+                _nparams - this is readonly, and never requies an update
+                _defaults - the user can mutate this (func_defaults) and that forces
+                            an update
+                expand dict/list - based on nparams and flags, both read-only
+                
+            Bits are allocated as:
+                00003fff - Normal argument count
+                0fffb000 - Default count
+                10000000 - unused
+                20000000 - expand list
+                40000000 - expand dict
+                80000000 - unused
+                
+            Enforce recursion is added at runtime.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonFunction.IsGeneratorWithExceptionHandling">
+            <summary>
+            Generators w/ exception handling need to have some data stored
+            on them so that we appropriately set/restore the exception state.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonFunction.FunctionID">
+            <summary>
+            Returns an ID for the function if one has been assigned, or zero if the
+            function has not yet required the use of an ID.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonFunction.ExpandListPosition">
+            <summary>
+            Gets the position for the expand list argument or -1 if the function doesn't have an expand list parameter.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonFunction.ExpandDictPosition">
+            <summary>
+            Gets the position for the expand dictionary argument or -1 if the function doesn't have an expand dictionary parameter.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonFunction.NormalArgumentCount">
+            <summary>
+            Gets the number of normal (not params or kw-params) parameters.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonFunction.ExtraArguments">
+            <summary>
+            Gets the number of extra arguments (params or kw-params)
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.PythonHiddenAttribute">
+            <summary>
+            Marks a member as being hidden from Python code.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.PythonModuleAttribute">
+            <summary>
+            This assembly-level attribute specifies which types in the engine represent built-in Python modules.
+            
+            Members of a built-in module type should all be static as an instance is never created.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonModuleAttribute.#ctor(System.String,System.Type,System.PlatformID[])">
+            <summary>
+            Creates a new PythonModuleAttribute that can be used to specify a built-in module that exists
+            within an assembly.
+            </summary>
+            <param name="name">The built-in module name</param>
+            <param name="type">The type that implements the built-in module.</param>
+            <param name="invalidPlatforms">The invalid platform identifiers for this module.</param>
+        </member>
+        <member name="P:IronPython.Runtime.PythonModuleAttribute.Name">
+            <summary>
+            The built-in module name
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonModuleAttribute.Type">
+            <summary>
+            The type that implements the built-in module
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.PythonTypeAttribute">
+             <summary>
+             Marks a type as being a PythonType for purposes of member lookup, creating instances, etc...  
+             
+             If defined a PythonType will use __new__ / __init__ when creating instances.  This allows the
+             object to match the native Python behavior such as returning cached values from __new__ or
+             supporting initialization to run multiple times via __init__.
+            
+             The attribute also allows you to specify an alternate type name.  This allows the .NET name to
+             be different from the Python name so they can follow .NET naming conventions.
+             
+             Types defining this attribute also don't show CLR methods such as Equals, GetHashCode, etc... until
+             the user has done an import clr.
+             </summary>
+        </member>
+        <member name="T:IronPython.Runtime.SetStorage">
+            <summary>
+            General-purpose storage used for Python sets and frozensets.
+            
+            The set storage is thread-safe for multiple readers or writers.
+            
+            Mutations to the set involve a simple locking strategy of locking on the SetStorage object
+            itself to ensure mutual exclusion.
+            
+            Reads against the set happen lock-free. When the set is mutated, it adds or removes buckets
+            in an atomic manner so that the readers will see a consistent picture as if the read
+            occurred either before or after the mutation.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.#ctor">
+            <summary>
+            Creates a new set storage with no buckets
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.#ctor(System.Int32)">
+            <summary>
+            Creates a new set storage with no buckets
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.SetStorage.Count">
+            <summary>
+            Returns the number of items currently in the set
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.Add(System.Object)">
+            <summary>
+            Adds a new item to the set, unless an equivalent item is already present
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.AddWorker(IronPython.Runtime.SetStorage.Bucket[],System.Object,System.Int32,System.Func{System.Object,System.Object,System.Boolean},System.Int32@)">
+            <summary>
+            Static helper which adds the given non-null item with a precomputed hash code. Returns
+            true if the item was added, false if it was already present in the set.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.AddOrRemoveWorker(System.Object,System.Int32)">
+            <summary>
+            Lock-free helper on a non-null item with a pre-calculated hash code. Removes the item
+            if it is present in the set, otherwise adds it.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.Clear">
+            <summary>
+            Clears the contents of the set
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.Clone">
+            <summary>
+            Clones the set, returning a new SetStorage object
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.Contains(System.Object)">
+            <summary>
+            Checks to see if the given item exists in the set
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.ContainsAlwaysHash(System.Object)">
+            <summary>
+            Checks to see if the given item exists in the set, and tries to hash it even
+            if it is known not to be in the set.
+            </summary>
+            <param name="item"></param>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.CopyTo(IronPython.Runtime.SetStorage)">
+            <summary>
+            Adds items from this set into the other set
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.Pop(System.Object@)">
+            <summary>
+            Removes the first set element in the iteration order.
+            </summary>
+            <returns>true if an item was removed, false if the set was empty</returns>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.Remove(System.Object)">
+            <summary>
+            Removes an item from the set and returns true if it was present, otherwise returns
+            false
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.RemoveAlwaysHash(System.Object)">
+            <summary>
+            Removes an item from the set and returns true if it was removed. The item will always
+            be hashed, throwing if it is unhashable - even if the set has no buckets.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.RemoveItem(System.Object)">
+            <summary>
+            Lock-free helper to remove a non-null item
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.IsDisjoint(IronPython.Runtime.SetStorage)">
+            <summary>
+            Determines whether the current set shares no elements with the given set
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.IsSubset(IronPython.Runtime.SetStorage)">
+            <summary>
+            Determines whether the current set is a subset of the given set
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.IsStrictSubset(IronPython.Runtime.SetStorage)">
+            <summary>
+            Determines whether the current set is a strict subset of the given set
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.UnionUpdate(IronPython.Runtime.SetStorage)">
+            <summary>
+            Mutates this set to contain its union with 'other'. The caller must lock the current
+            set if synchronization is desired.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.IntersectionUpdate(IronPython.Runtime.SetStorage)">
+            <summary>
+            Mutates this set to contain its intersection with 'other'. The caller must lock the
+            current set if synchronization is desired.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.SymmetricDifferenceUpdate(IronPython.Runtime.SetStorage)">
+            <summary>
+            Mutates this set to contain its symmetric difference with 'other'. The caller must
+            lock the current set if synchronization is desired.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.DifferenceUpdate(IronPython.Runtime.SetStorage)">
+            <summary>
+            Mutates this set to contain its difference with 'other'. The caller must lock the
+            current set if synchronization is desired.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.Union(IronPython.Runtime.SetStorage,IronPython.Runtime.SetStorage)">
+            <summary>
+            Computes the union of self and other, returning an entirely new set. This method is
+            thread-safe and makes no modifications to self or other.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.Intersection(IronPython.Runtime.SetStorage,IronPython.Runtime.SetStorage)">
+            <summary>
+            Computes the intersection of self and other, returning an entirely new set. This
+            method is thread-safe and makes no modifications to self or other.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.SymmetricDifference(IronPython.Runtime.SetStorage,IronPython.Runtime.SetStorage)">
+            <summary>
+            Computes the symmetric difference of self and other, returning an entirely new set.
+            This method is thread-safe and makes no modifications to self or other.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.Difference(IronPython.Runtime.SetStorage,IronPython.Runtime.SetStorage)">
+            <summary>
+            Computes the difference of self and other, returning an entirely new set. This
+            method is thread-safe and makes no modifications to self or other.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.SetStorage.Bucket">
+            <summary>
+            Used to store a single hashed item.
+            
+            Bucket is not serializable because it stores the computed hash code, which could change
+            between serialization and deserialization.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.Hash(System.Object)">
+            <summary>
+            Helper to hash the given item w/ support for null
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.SortBySize(IronPython.Runtime.SetStorage@,IronPython.Runtime.SetStorage@)">
+            <summary>
+            Helper which ensures that the first argument x requires the least work to enumerate
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.GetItems(System.Object)">
+            <summary>
+            A factory which creates a SetStorage object from any Python iterable. It extracts
+            the underlying storage of a set or frozen set without copying, which is left to the
+            caller if necessary.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.GetItems(System.Object,IronPython.Runtime.SetStorage@)">
+            <summary>
+            A factory which creates a SetStorage object from any Python iterable. It extracts
+            the underlying storage of a set or frozen set without copying, which is left to the
+            caller if necessary.
+            Returns true if the given object was a set or frozen set, false otherwise.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.GetFrozenItems(System.Object)">
+            <summary>
+            A factory which creates a SetStorage object from any Python iterable. It extracts
+            the underlying storage of a set or frozen set, copying in the former case, to return
+            a SetStorage object that is guaranteed not to receive any outside mutations.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.GetItemsIfSet(System.Object,IronPython.Runtime.SetStorage@)">
+            <summary>
+            Extracts the SetStorage object from o if it is a set or frozenset and returns true.
+            Otherwise returns false.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetStorage.GetHashableSetIfSet(System.Object@)">
+            <summary>
+            Creates a hashable set from the given set, or does nothing if the given object 
+            is not a set.
+            </summary>
+            <returns>True if o is a set or frozenset, false otherwise</returns>
+        </member>
+        <member name="T:IronPython.Runtime.SiteLocalStorage`1">
+            <summary>
+            Provides storage which is flowed into a callers site.  The same storage object is 
+            flowed for multiple calls enabling the callee to cache data that can be re-used
+            across multiple calls.
+            
+            Data is a public field so that this works properly with DynamicSite's as the reference
+            type (and EnsureInitialize)
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.StringFormatSpec">
+            <summary>
+            Provides a representation and parsing for the default formatting specification.  This is used
+            by object.__format__, int.__format__, long.__format__, and float.__format__ to do the common
+            format spec parsing.
+            
+            The default specification is:
+            
+            format_spec =  [[fill]align][sign][#][0][width][,][.precision][type]
+            fill        =  a character other than }
+            align       =  "&lt;" | "&gt;" | "=" | "^"
+            sign        =  "+" | "-" | " "
+            width       =  integer
+            precision   =  integer
+            type        =  "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "x" | "X" | "%"
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.StringFormatSpec.FromString(System.String)">
+            <summary>
+            Parses a format spec and returns a new StringFormatSpec object.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.SysModuleDictionaryStorage">
+            <summary>
+            Optimized storage for setting exc_type, exc_value, and exc_traceback.
+            
+            This optimization can go away in Python 3.0 when these attributes are no longer used.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.DynamicBaseTypeAttribute">
+            <summary>
+            Marks a type as being a suitable type to be used for user-defined classes.
+            
+            The requirements for this are that a type has to follow the patterns
+            that NewTypeMaker derived types follow.  This includes:
+                The type's constructors must all take PythonType as the 1st parameter
+                    which sets the underlying type for the actual object
+                The type needs to implement IPythonObject
+                Dictionary-based storage needs to be provided for setting individual members
+                Virtual methods exposed to Python need to support checking the types dictionary for invocations
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.InstanceCreator">
+            <summary>
+            Base class for helper which creates instances.  We have two derived types: One for user
+            defined types which prepends the type before calling, and one for .NET types which
+            doesn't prepend the type.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.NameConverter">
+            <summary>
+            Contains helper methods for converting C# names into Python names.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.NewTypeInfo">
+            <summary>
+            TypeInfo captures the minimal CLI information required by NewTypeMaker for a Python object
+            that inherits from a CLI type.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.NewTypeInfo.GetTypeInfo(System.String,IronPython.Runtime.PythonTuple)">
+            <summary>
+            "bases" contains a set of PythonTypes. These can include types defined in Python (say cpy1, cpy2),
+            CLI types (say cCLI1, cCLI2), and CLI interfaces (say iCLI1, iCLI2). Here are some
+            examples of how this works:
+            
+            (bases)                      => baseType,        {interfaceTypes}
+            
+            (cpy1)                       => System.Object,   {}
+            (cpy1, cpy2)                 => System.Object,   {}
+            (cpy1, cCLI1, iCLI1, iCLI2)  => cCLI1,           {iCLI1, iCLI2}
+            [some type that satisfies the line above] => 
+                                            cCLI1,           {iCLI1, iCLI2}
+            (cCLI1, cCLI2)               => error
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.NewTypeInfo.GetPythonTypes(System.String,System.Collections.Generic.ICollection{System.Object})">
+            <summary>
+            Filters out old-classes and throws if any non-types are included, returning a
+            yielding the remaining PythonType objects.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.NewTypeMaker">
+            <summary>
+            Python class hierarchy is represented using the __class__ field in the object. It does not 
+            use the CLI type system for pure Python types. However, Python types which inherit from a 
+            CLI type, or from a builtin Python type which is implemented in the engine by a CLI type,
+            do have to use the CLI type system to interoperate with the CLI world. This means that 
+            objects of different Python types, but with the same CLI base type, can use the same CLI type - 
+            they will just have different values for the __class__ field.
+            
+            The easiest way to inspect the functionality implemented by NewTypeMaker is to persist the
+            generated IL using "ipy.exe -X:SaveAssemblies", and then inspect the
+            persisted IL using ildasm.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.NewTypeMaker.LoadNewTypes(System.Reflection.Assembly)">
+            <summary>
+            Loads any available new types from the provided assembly and makes them
+            available via the GetNewType API.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.NewTypeMaker.IsInstanceType(System.Type)">
+            <summary>
+            Is this a type used for instances Python types (and not for the types themselves)?
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.NewTypeMaker.GetOriginalIndex(System.Reflection.ParameterInfo[],Microsoft.Scripting.Generation.ParameterInfoWrapper[],System.Int32)">
+            <summary>
+            Gets the position for the parameter which we are overriding.
+            </summary>
+            <param name="pis"></param>
+            <param name="overrideParams"></param>
+            <param name="i"></param>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.Types.NewTypeMaker.DefineHelperInterface(System.Type)">
+            <summary>
+            Defines an interface on the type that forwards all calls
+            to a helper method in UserType.  The method names all will
+            have Helper appended to them to get the name for UserType.  The 
+            UserType version should take 1 extra parameter (self).
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.NewTypeMaker.OverrideMethods(System.Type,System.Collections.Generic.Dictionary{System.String,System.String[]})">
+            <summary>
+            Overrides methods - this includes all accessible virtual methods as well as protected non-virtual members
+            including statics and non-statics.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitBaseMethodDispatch(System.Reflection.MethodInfo,Microsoft.Scripting.Generation.ILGen)">
+            <summary>
+            Loads all the incoming arguments and forwards them to mi which
+            has the same signature and then returns the result
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitBaseClassCallCheckForProperties(Microsoft.Scripting.Generation.ILGen,System.Reflection.MethodInfo,System.String)">
+            <summary>
+            Emits code to check if the class has overridden this specific
+            function.  For example:
+            
+            MyDerivedType.SomeVirtualFunction = ...
+                or
+            
+            class MyDerivedType(MyBaseType):
+                def SomeVirtualFunction(self, ...):
+            
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitConvertFromObject(Microsoft.Scripting.Generation.ILGen,System.Type)">
+            <summary>
+            Emit code to convert object to a given type. This code is semantically equivalent
+            to PythonBinder.EmitConvertFromObject, except this version accepts ILGen whereas
+            PythonBinder accepts Compiler. The Binder will chagne soon and the two will merge.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitBaseClassCallCheckForEvents(Microsoft.Scripting.Generation.ILGen,System.Reflection.MethodInfo,System.String)">
+            <summary>
+            Emits code to check if the class has overridden this specific
+            function.  For example:
+            
+            MyDerivedType.SomeVirtualFunction = ...
+                or
+            
+            class MyDerivedType(MyBaseType):
+                def SomeVirtualFunction(self, ...):
+            
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitNonInheritedMethodLookup(System.String,Microsoft.Scripting.Generation.ILGen)">
+            <summary>
+            Emits the call to lookup a member defined in the user's type.  Returns
+            the local which stores the resulting value and leaves a value on the
+            stack indicating the success of the lookup.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.NewTypeMaker.CreateSuperCallHelper(System.Reflection.MethodInfo)">
+            <summary>
+            Creates a method for doing a base method dispatch.  This is used to support
+            super(type, obj) calls.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitClrCallStub(Microsoft.Scripting.Generation.ILGen,System.Reflection.MethodInfo,System.Reflection.Emit.LocalBuilder)">
+            <summary>
+            Generates stub to receive the CLR call and then call the dynamic language code.
+            This code is same as StubGenerator.cs in the Microsoft.Scripting, except it
+            accepts ILGen instead of Compiler.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.NewTypeMaker.GetOverriddenMethods(System.Type,System.String)">
+            <summary>
+            Called from PythonTypeOps - the BuiltinFunction._function lock must be held.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.ReturnFixer">
+            <summary>
+            Same as the DLR ReturnFixer, but accepts lower level constructs,
+            such as LocalBuilder, ParameterInfos and ILGen.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.DocBuilder.GetOverloadDoc(System.Reflection.MethodBase,System.String,System.Int32,System.Boolean)">
+            <summary>
+            Creates a DLR OverloadDoc object which describes information about this overload.
+            </summary>
+            <param name="info">The method to document</param>
+            <param name="name">The name of the method if it should override the name in the MethodBase</param>
+            <param name="endParamSkip">Parameters to skip at the end - used for removing the value on a setter method</param>
+            <param name="includeSelf">true to include self on instance methods</param>
+        </member>
+        <member name="M:IronPython.Runtime.Types.DocBuilder.AppendTypeFormat(System.Type,System.Text.StringBuilder,System.Reflection.ParameterInfo)">
+            <summary>
+            Converts a Type object into a string suitable for lookup in the help file.  All generic types are
+            converted down to their generic type definition.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.DocBuilder.GetXPathDocument(System.Reflection.Assembly)">
+            <summary>
+            Gets the XPathDocument for the specified assembly, or null if one is not available.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.DocBuilder.GetXmlDoc(System.Reflection.MethodBase,System.String@,System.String@,System.Collections.Generic.List{System.Collections.Generic.KeyValuePair{System.String,System.String}}@)">
+            <summary>
+            Gets the Xml documentation for the specified MethodBase.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.DocBuilder.GetXmlDoc(System.Type,System.String@)">
+            <summary>
+            Gets the Xml documentation for the specified Type.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.DocBuilder.GetXmlDocForProperty(System.Type,System.String,System.String@,System.String@)">
+            <summary>
+            Gets the Xml documentation for the specified Field.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.DocBuilder.GetXmlDoc(System.Reflection.EventInfo,System.String@,System.String@)">
+            <summary>
+            Gets the Xml documentation for the specified Field.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.DocBuilder.XmlToString(System.Xml.XPath.XPathNodeIterator)">
+            <summary>
+            Converts the XML as stored in the config file into a human readable string.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.BuiltinFunctionOverloadMapper.FindMatchingTargets(System.Type[],System.Collections.Generic.IList{System.Reflection.MethodBase},System.Boolean)">
+            <summary>
+            Find matching overloads by checking signature against available targets
+            </summary>
+            <param name="sig">Given signature</param>
+            <param name="targets">List of possible targets</param>
+            <param name="removeCodeContext">If set to true, the method will check whether the first paramter of the
+            target is of the type CodeContext and removes it</param>
+            <returns>Possible overloads</returns>
+        </member>
+        <member name="M:IronPython.Runtime.Types.BuiltinFunctionOverloadMapper.ThrowOverloadException(System.Type[],System.Collections.Generic.IList{System.Reflection.MethodBase})">
+            <summary>
+            Throws a formatted exception if no overload matchs.
+            </summary>
+            <param name="sig">Passed signature which should be used</param>
+            <param name="targets">Given targets, which does not fit to the signature</param>
+            <example>
+            <code language="cs" title="Cause overload exceptiob"><![CDATA[
+            # Will cause an exception:
+            from System import Convert, Double
+            Convert.ToInt32.Overloads[Double, Double](24)
+            ]]></code>
+            </example>
+        </member>
+        <member name="T:IronPython.Runtime.Types.CustomAttributeTracker">
+            <summary>
+            Provides a CustomTracker which handles special fields which have custom
+            behavior on get/set.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.CustomInstanceDictionaryStorage">
+            <summary>
+            Provides custom, versioned, dictionary access for instances.  Used for both
+            new-style and old-style instances.
+            
+            Each class can allocate a version for instance storage using the 
+            CustomInstanceDictionaryStorage.AllocateInstance method.  The version allocated
+            is dependent upon the names which are likely to appear in the instance 
+            dictionary.  Currently these names are calculated by collecting the names
+            that are assigned to during the __init__ method and combining these with
+            all such names in the types MRO.
+            
+            When creating the dictionary for storing instance values the class can then create
+            a PythonDictionary backed by a CustomInstanceDictionaryStorage with it's
+            version.  When doing a get/set optimized code can then be produced that
+            verifies we have CustomInstanceDictionaryStorage and it has the 
+            correct version.  If we have a matching dictionary then gets/sets can turn
+            into simple array accesses rather than dictionary gets/sets.  For programs
+            which access a large number of instance variables this can dramatically
+            speed up the program.
+            
+            TODO: Should we attempt to unify all versions which share the same keys?
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.FunctionType">
+            <summary>
+            Represents a set of attributes that different functions can have.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Types.FunctionType.None">
+            <summary>No flags have been set </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Types.FunctionType.Function">
+            <summary>This is a function w/ no instance pointer </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Types.FunctionType.Method">
+            <summary>This is a method that requires an instance</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Types.FunctionType.FunctionMethodMask">
+            <summary>Built-in functions can encapsulate both methods and functions, in which case both bits are set</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Types.FunctionType.AlwaysVisible">
+            <summary>True is the function/method should be visible from pure-Python code</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Types.FunctionType.ReversedOperator">
+            <summary>True if this is a __r*__ method for a CLS overloaded operator method</summary>
+        </member>
+        <member name="F:IronPython.Runtime.Types.FunctionType.BinaryOperator">
+            <summary>
+            This method represents a binary operator method for a CLS overloaded operator method.
+            
+            Being a binary operator causes the following special behaviors to kick in:
+                A failed binding at call time returns NotImplemented instead of raising an exception
+                A reversed operator will automatically be created if:
+                    1. The parameters are both of the instance type
+                    2. The parameters are in reversed order (other, this)
+                    
+            This enables simple .NET operator methods to be mapped into the Python semantics.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Types.FunctionType.ModuleMethod">
+            <summary>
+            A method declared on a built-in module
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.OperatorMapping">
+            <summary>
+            OperatorMapping provides a mapping from DLR operators to their associated .NET methods.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.OperatorMapping.GetOperatorMapping(IronPython.Runtime.Binding.PythonOperationKind)">
+            <summary>
+            Given an operator returns the OperatorMapping associated with the operator or null
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.OperatorMapping.Operator">
+            <summary>
+            The operator the OperatorMapping provides info for.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.OperatorMapping.Name">
+            <summary>
+            The primary method name associated with the method.  This method name is
+            usally in the form of op_Operator (e.g. op_Addition).
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.OperatorMapping.AlternateName">
+            <summary>
+            The secondary method name associated with the method.  This method name is
+            usually a standard .NET method name with pascal casing (e.g. Add).
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.OperatorMapping.AlternateExpectedType">
+            <summary>
+            The return type that must match for the alternate operator to be valid.
+            
+            This is available alternate operators don't have special names and therefore
+            could be confused for a normal method which isn't fulfilling the contract.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonSiteCache">
+            <summary>
+            Cached CallSites.  User types are cached on the PythonType and System types are cached on the
+            PythonContext to avoid cross-runtime contamination due to the binder on the site.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonType">
+            <summary>
+            Represents a PythonType.  Instances of PythonType are created via PythonTypeBuilder.  
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.IronPython#Runtime#Binding#IFastInvokable#MakeInvokeBinding``1(System.Runtime.CompilerServices.CallSite{``0},IronPython.Runtime.Binding.PythonInvokeBinder,IronPython.Runtime.CodeContext,System.Object[])">
+            <summary>
+            Implements fast binding for user defined types.  This ensures that common highly dynamic
+            scenarios will run fast (for instance creating new types repeatedly and only creating a limited
+            number of instances of them).  It also gives better code sharing amongst different subclasses
+            of the same types and improved startup time due to reduced code generation.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonType.FastBindingBuilderBase">
+            <summary>
+            Base class for doing fast type invoke binding.  Subclasses are created using
+            reflection once during the binding.  The subclasses can then proceed to do
+            the binding w/o using reflection.  Otherwise we'd have lots more reflection
+            calls which would slow the binding up.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.FastBindingBuilderBase.GetOrCreateFastNew">
+            <summary>
+            Gets or creates delegate for calling the constructor function.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Types.PythonType._fastBindCtors">
+            <summary>
+            Provides delegates that will invoke a parameterless type ctor.  The first key provides
+            the dictionary for a specific type, the 2nd key provides the delegate for a specific
+            call site type used in conjunction w/ our IFastInvokable implementation.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Types.PythonType._userTypeCtors">
+            <summary>
+            Shared built-in functions for creating instances of user defined types.  Because all
+            types w/ the same UnderlyingSystemType share the same constructors these can be
+            shared across multiple types.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.PythonTuple,IronPython.Runtime.PythonDictionary)">
+            <summary>
+            Creates a new type for a user defined type.  The name, base classes (a tuple of type
+            objects), and a dictionary of members is provided.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.PythonTuple,IronPython.Runtime.PythonDictionary,System.String)">
+            <summary>
+            Creates a new type for a user defined type.  The name, base classes (a tuple of type
+            objects), and a dictionary of members is provided.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(System.Type)">
+            <summary>
+            Creates a new PythonType object which is backed by the specified .NET type for
+            storage.  The type is considered a system type which can not be modified
+            by the user.
+            </summary>
+            <param name="underlyingSystemType"></param>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.Types.PythonType,System.String,System.Func{System.String,System.Exception})">
+            <summary>
+            Creates a new PythonType which is a subclass of the specified PythonType.
+            
+            Used for runtime defined new-style classes which require multiple inheritance.  The
+            primary example of this is the exception system.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.Types.PythonType[],System.String)">
+            <summary>
+            Creates a new PythonType which is a subclass of the specified PythonTypes.
+            
+            Used for runtime defined new-style classes which require multiple inheritance.  The
+            primary example of this is the exception system.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.Types.PythonType[],System.Type,System.String,System.Func{System.String,System.Exception})">
+            <summary>
+            Creates a new PythonType which is a subclass of the specified PythonTypes.
+            
+            Used for runtime defined new-style classes which require multiple inheritance.  The
+            primary example of this is the exception system.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType,System.String,System.String,System.String,System.Func{System.String,System.Exception})">
+            <summary>
+            Creates a new PythonType which is a subclass of the specified PythonType.
+            
+            Used for runtime defined new-style classes which require multiple inheritance.  The
+            primary example of this is the exception system.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType[],System.String,System.String,System.String)">
+            <summary>
+            Creates a new PythonType which is a subclass of the specified PythonTypes.
+            
+            Used for runtime defined new-style classes which require multiple inheritance.  The
+            primary example of this is the exception system.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType[],System.Type,System.String,System.String,System.String,System.Func{System.String,System.Exception})">
+            <summary>
+            Creates a new PythonType which is a subclass of the specified PythonTypes.
+            
+            Used for runtime defined new-style classes which require multiple inheritance.  The
+            primary example of this is the exception system.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.Types.OldClass)">
+            <summary>
+            Creates a new PythonType object which represents an Old-style class.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Types.PythonType.TypeFlagHeapType">
+            <summary>
+            Used in copy_reg which is the only consumer of __flags__ in the standard library.
+            
+            Set if the type is user defined
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Types.PythonType.TypeFlagAbstractMethodsDefined">
+            <summary>
+            Set if the type has __abstractmethods__ defined
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.IsIterable(IronPython.Runtime.CodeContext)">
+            <summary>
+            Check whether the current type is iterabel
+            </summary>
+            <param name="context"></param>
+            <returns>True if it is iterable</returns>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.__instancecheck__(System.Object)">
+            <summary>
+            Returns true if the specified object is an instance of this type.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.PythonType.Name">
+            <summary>
+            Gets the name of the dynamic type
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.PythonType.ResolutionOrder">
+            <summary>
+            Gets the resolution order used for attribute lookup
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.GetPythonType(System.Type)">
+            <summary>
+            Gets the dynamic type that corresponds with the provided static type. 
+            
+            Returns null if no type is available.  TODO: In the future this will
+            always return a PythonType created by the DLR.
+            </summary>
+            <param name="type"></param>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.SetPythonType(System.Type,IronPython.Runtime.Types.PythonType)">
+            <summary>
+            Sets the python type that corresponds with the provided static type.
+            
+            This is used for built-in types which have a metaclass.  Currently
+            only used by ctypes.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext)">
+            <summary>
+            Allocates the storage for the instance running the .NET constructor.  This provides
+            the creation functionality for __new__ implementations.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Allocates the storage for the instance running the .NET constructor.  This provides
+            the creation functionality for __new__ implementations.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext,System.Object,System.Object)">
+            <summary>
+            Allocates the storage for the instance running the .NET constructor.  This provides
+            the creation functionality for __new__ implementations.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext,System.Object,System.Object,System.Object)">
+            <summary>
+            Allocates the storage for the instance running the .NET constructor.  This provides
+            the creation functionality for __new__ implementations.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext,System.Object[])">
+            <summary>
+            Allocates the storage for the instance running the .NET constructor.  This provides
+            the creation functionality for __new__ implementations.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext,System.Object[],System.String[])">
+            <summary>
+            Allocates the storage for the instance running the .NET constructor.  This provides
+            the creation functionality for __new__ implementations.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.PythonType.UnderlyingSystemType">
+            <summary>
+            Gets the underlying system type that is backing this type.  All instances of this
+            type are an instance of the underlying system type.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.PythonType.ExtensionType">
+            <summary>
+            Gets the extension type for this type.  The extension type provides
+            a .NET type which can be inherited from to extend sealed classes
+            or value types which Python allows inheritance from.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.PythonType.BaseTypes">
+            <summary>
+            Gets the base types from which this type inherits.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.IsSubclassOf(IronPython.Runtime.Types.PythonType)">
+            <summary>
+            Returns true if this type is a subclass of other
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.PythonType.IsSystemType">
+            <summary>
+            True if the type is a system type.  A system type is a type which represents an
+            underlying .NET type and not a subtype of one of these types.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.TryLookupSlot(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
+            <summary>
+            Looks up a slot on the dynamic type
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.TryResolveSlot(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
+            <summary>
+            Searches the resolution order for a slot matching by name
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.TryResolveMixedSlot(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
+            <summary>
+            Searches the resolution order for a slot matching by name.
+            
+            Includes searching for methods in old-style classes
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.AddSlot(System.String,IronPython.Runtime.Types.PythonTypeSlot)">
+            <summary>
+            Internal helper to add a new slot to the type
+            </summary>
+            <param name="name"></param>
+            <param name="slot"></param>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.TryGetMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object@)">
+            <summary>
+            Gets a value from a dynamic type and any sub-types.  Values are stored in slots (which serve as a level of 
+            indirection).  This searches the types resolution order and returns the first slot that
+            contains the value.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.TryGetNonCustomMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object@)">
+            <summary>
+            Attempts to lookup a member w/o using the customizer.  Equivelent to object.__getattribute__
+            but it doens't throw an exception.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.TryGetBoundMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object@)">
+            <summary>
+            Gets a value from a dynamic type and any sub-types.  Values are stored in slots (which serve as a level of 
+            indirection).  This searches the types resolution order and returns the first slot that
+            contains the value.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.TryGetNonCustomBoundMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object@)">
+            <summary>
+            Attempts to lookup a member w/o using the customizer.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.TrySetMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object)">
+            <summary>
+            Sets a value on an instance.  If a slot is available in the most derived type the slot
+            is set there, otherwise the value is stored directly in the instance.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.TrySetNonCustomMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object)">
+            <summary>
+            Attempst to set a value w/o going through the customizer.
+            
+            This enables languages to provide the "base" implementation for setting attributes
+            so that the customizer can call back here.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.GetMemberNames(IronPython.Runtime.CodeContext)">
+            <summary>
+            Returns a list of all slot names for the type and any subtypes.
+            </summary>
+            <param name="context">The context that is doing the inquiry of InvariantContext.Instance.</param>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.GetMemberNames(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Returns a list of all slot names for the type, any subtypes, and the instance.
+            </summary>
+            <param name="context">The context that is doing the inquiry of InvariantContext.Instance.</param>
+            <param name="self">the instance to get instance members from, or null.</param>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.AddUserTypeMembers(IronPython.Runtime.CodeContext,System.Collections.Generic.Dictionary{System.String,System.String},IronPython.Runtime.Types.PythonType,IronPython.Runtime.List)">
+            <summary>
+            Adds members from a user defined type.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.AddInstanceMembers(System.Object,System.Collections.Generic.Dictionary{System.String,System.String},IronPython.Runtime.List)">
+            <summary>
+            Adds members from a user defined type instance
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.__clrtype__">
+            <summary>
+            Gets the .NET type which is used for instances of the Python type.
+            
+            When overridden by a metaclass enables a customization of the .NET type which
+            is used for instances of the Python type.  Meta-classes can construct custom
+            types at runtime which include new .NET methods, fields, custom attributes or
+            other features to better interoperate with .NET.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.InitializeSystemType">
+            <summary>
+            Initializes a PythonType that represents a standard .NET type.  The same .NET type
+            can be shared with the Python type system.  For example object, string, int,
+            etc... are all the same types.  
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.AddSystemConstructors">
+            <summary>
+            Creates a __new__ method for the type.  If the type defines interesting constructors
+            then the __new__ method will call that.  Otherwise if it has only a single argless
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.GetNextVersion">
+            <summary>
+            This will return a unique integer for every version of every type in the system.
+            This means that DynamicSite code can generate a check to see if it has the correct
+            PythonType and version with a single integer compare.
+            
+            TODO - This method and related code should fail gracefully on overflow.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.AddSubType(IronPython.Runtime.Types.PythonType)">
+            <summary>
+            Internal helper function to add a subtype
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.PythonType.SubTypes">
+            <summary>
+            Gets a list of weak references to all the subtypes of this class.  May return null
+            if there are no subtypes of the class.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Types.PythonType.PythonTypeAttributes.SystemCtor">
+            <summary>
+            The type has a ctor which does not accept PythonTypes.  This is used
+            for user defined types which implement __clrtype__
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonType.GetSharedWeakReference">
+            <summary>
+            Returns a CLR WeakReference object to this PythonType that can be shared
+            between anyone who needs a weak reference to the type.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.LateBoundInitBinder">
+            <summary>
+            Used when a type overrides __new__ with a Python function or other object
+            that can return an arbitrary value.  If the return value is not the same type
+            as the type which had __new__ then we need to lookup __init__ on the type
+            and invoke it.  Also handles initialization for finalization when __del__
+            is defined for the same reasons.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.LateBoundInitBinder.Bind(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
+            <summary>
+            target is the newly initialized value.
+            args are the arguments to be passed to __init__
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.ResolvedMember">
+            <summary>
+            Couples a MemberGroup and the name which produces the member group together
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.SlotFieldAttribute">
+            <summary>
+            Represents an ops-extension which adds a new slot.  The slot can have arbitrary
+            get/set behavior above and beyond normal .NET methods or properties.  This is
+            typically in regards to how it processes access from instances or subtypes.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonTypeDictSlot">
+            <summary>
+            Provides a slot object for the dictionary to allow setting of the dictionary.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.Mro">
+             <summary>
+             Calculates the method resolution order for a Python class
+             the rules are:
+                  If A is a subtype of B, then A has precedence (A > B)
+                  If C appears before D in the list of bases then C > D
+                  If E > F in one __mro__ then E > F in all __mro__'s for our subtype
+             
+             class A(object): pass
+             class B(object): pass
+             class C(B): pass
+             class N(A,B,C): pass         # illegal
+            
+             This is because:
+                  C.__mro__ == (C, B, object)
+                  N.__mro__ == (N, A, B, C, object)
+             which would conflict, but:
+            
+             N(B,A) is ok  (N, B, a, object)
+             N(C, B, A) is ok (N, C, B, A, object)
+            
+             Calculates a C3 MRO as described in "The Python 2.3 Method Resolution Order"
+             plus support for old-style classes.
+             
+             We build up a list of our base classes MRO's plus our base classes themselves.
+             We go through the list in order.  Look at the 1st class in the current list, and
+             if it's not the non-first class in any other list then remove it from all the lists
+             and append it to the mro.  Otherwise continue to the next list.  If all the classes at
+             the start are no-good then the MRO is bad and we throw. 
+             
+             For old-style classes if the old-style class is the only one in the list of bases add
+             it as a depth-first old-style MRO, otherwise compute a new-style mro for all the classes 
+             and use that.
+             </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.Mro.Calculate(IronPython.Runtime.Types.PythonType,System.Collections.Generic.IList{IronPython.Runtime.Types.PythonType},System.Boolean)">
+            <summary>
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.OldInstance.Dictionary">
+            <summary>
+            Returns the dictionary used to store state for this object
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.ReflectedSlotProperty">
+            <summary>
+            Represents a member of a user-defined type which defines __slots__.  The names listed in
+            __slots__ have storage allocated for them with the type and provide fast get/set access.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.ReflectedSlotProperty.Index">
+            <summary>
+            Gets the index into the object array to be used for the slot storage.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonTypeInfo">
+            <summary>
+            Helpers for interacting w/ .NET types.  This includes:
+            
+                Member resolution via GetMember/GetMembers.  This performs a member lookup which includes the registered
+                    extension types in the PythonBinder.  Internally the class has many MemberResolver's which provide
+                    the various resolution behaviors.  
+                
+                Cached member access - this is via static classes such as Object and provides various MemberInfo's so we're
+                    not constantly looking up via reflection.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.Types.PythonTypeInfo._resolvers">
+            <summary> list of resolvers which we run to resolve items </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetMemberAll(IronPython.Runtime.Binding.PythonBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type,System.String)">
+            <summary>
+            Gets the statically known member from the type with the specific name.  Searches the entire type hierarchy to find the specified member.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetMembersAll(IronPython.Runtime.Binding.PythonBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type)">
+            <summary>
+            Gets all the statically known members from the specified type.  Searches the entire type hierarchy to get all possible members.
+            
+            The result may include multiple resolution.  It is the callers responsibility to only treat the 1st one by name as existing.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetMember(IronPython.Runtime.Binding.PythonBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type,System.String)">
+            <summary>
+            Gets the statically known member from the type with the specific name.  Searches only the specified type to find the member.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetMembers(IronPython.Runtime.Binding.PythonBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type)">
+            <summary>
+            Gets all the statically known members from the specified type.  Searches only the specified type to find the members.
+            
+            The result may include multiple resolution.  It is the callers responsibility to only treat the 1st one by name as existing.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.MemberResolver">
+            <summary>
+            Abstract class used for resolving members.  This provides two methods of member look.  The first is looking
+            up a single member by name.  The other is getting all of the members.
+            
+            There are various subclasses of this which have different methods of resolving the members.  The primary
+            function of the resolvers are to provide the name->value lookup.  They also need to provide a simple name
+            enumerator.  The enumerator is kept simple because it's allowed to return duplicate names as well as return
+            names of members that don't exist.  The base MemberResolver will then verify their existance as well as 
+            filter duplicates.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.MemberResolver.ResolveMember(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type,System.String)">
+            <summary>
+            Looks up an individual member and returns a MemberGroup with the given members.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.MemberResolver.ResolveMembers(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type)">
+            <summary>
+            Returns a list of members that exist on the type.  The ResolvedMember structure indicates both
+            the name and provides the MemberGroup.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.MemberResolver.GetCandidateNames(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type)">
+            <summary>
+            Returns a list of possible members which could exist.  ResolveMember needs to be called to verify their existance. Duplicate
+            names can also be returned.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.OneOffResolver">
+            <summary>
+            One off resolver for various special methods which are known by name.  A delegate is provided to provide the actual member which
+            will be resolved.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.StandardResolver">
+            <summary>
+            Standard resolver for looking up .NET members.  Uses reflection to get the members by name.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.EqualityResolver">
+            <summary>
+            Resolves methods mapped to __eq__ and __ne__ from:
+                1. IStructuralEquatable.Equals
+                2. IValueEquality.Equals (CLR2 only)
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.ComparisonResolver">
+            <summary>
+            Resolves methods mapped to __gt__, __lt__, __ge__, __le__, as well as providing an alternate resolution
+            for __eq__ and __ne__, from the comparable type's CompareTo method.
+            
+            This should be run after the EqualityResolver.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.OperatorResolver">
+            <summary>
+            Resolves methods mapped to __*__ methods automatically from the .NET operator.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.OperatorResolver.FilterAlternateMethods(IronPython.Runtime.Types.OperatorMapping,Microsoft.Scripting.Actions.MemberGroup)">
+            <summary>
+            Filters alternative methods out that don't match the expected signature and therefore
+            are just sharing a common method name.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.OperatorResolver.FilterObjectEquality(Microsoft.Scripting.Actions.MemberGroup)">
+            <summary>
+            Removes Object.Equals methods as we never return these for PythonOperationKind.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.PrivateBindingResolver">
+            <summary>
+            Provides bindings to private members when that global option is enabled.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.ProtectedMemberResolver">
+            <summary>
+            Provides resolutions for protected members that haven't yet been
+            subclassed by NewTypeMaker.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.MakeResolverTable">
+            <summary>
+            Creates the resolver table which includes all the possible resolutions.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="P:IronPython.Runtime.Types.PythonTypeInfo.ComplexResolver">
+            <summary>
+            Provides a resolution for __complex__
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.PythonTypeInfo.FloatResolver">
+            <summary>
+            Provides a resolution for __float__
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.PythonTypeInfo.IntResolver">
+            <summary>
+            Provides a resolution for __int__
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.PythonTypeInfo.BigIntegerResolver">
+            <summary>
+            Provides a resolution for __long__
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.PythonTypeInfo.GetItemResolver">
+            <summary>
+            Provides a resolution for __getitem__
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.PythonTypeInfo.SetItemResolver">
+            <summary>
+            Provides a resolution for __setitem__
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.StringResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
+            <summary>
+            Provides a resolution for __str__.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.ReprResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
+            <summary>
+            Provides a resolution for __repr__
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.TypeOverridesMethod(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type,System.String)">
+            <summary>
+            Helper to see if the type explicitly overrides the method.  This ignores members
+            defined on object.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.HashResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
+            <summary>
+            Provides a resolution for __hash__, first looking for IStructuralEquatable.GetHashCode,
+            then IValueEquality.GetValueHashCode.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.NewResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
+            <summary>
+            Provides a resolution for __new__.  For standard .NET types __new__ resolves to their
+            constructor.  For Python types they inherit __new__ from their base class.
+            
+            TODO: Can we just always fallback to object.__new__?  If not why not?
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.NextResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
+            <summary>
+            Provides a resolution for next
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.LengthResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
+            <summary>
+            Provides a resolution for __len__
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.IterResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
+            <summary>
+            Provides a resolution for __iter__
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.FallbackInequalityResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
+            <summary>
+            Looks for an Equals overload defined on the type and if one is present binds __ne__ to an
+            InstanceOps helper.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.ContainsResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
+            <summary>
+            Provides an implementation of __contains__.  We can pull contains from:
+                ICollection of T which defines Contains directly
+                IList which defines Contains directly
+                IDictionary which defines Contains directly
+                IDictionary of K,V which defines Contains directly
+                IEnumerable of K which we have an InstaceOps helper for
+                IEnumerable which we have an instance ops helper for
+                IEnumerator of K which we have an InstanceOps helper for
+                IEnumerator which we have an instance ops helper for
+                
+            String is ignored here because it defines __contains__ via extension methods already.
+                
+            The lookup is well ordered and not dependent upon the order of values returned by reflection.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetEnumeratorContains(System.Type,System.Collections.Generic.IList{System.Type},System.Collections.Generic.List{Microsoft.Scripting.Actions.MemberTracker}@,System.Boolean@,System.Type,System.Type,System.String)">
+            <summary>
+            Helper for IEnumerable/IEnumerator __contains__ 
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.MemberBinder">
+            <summary>
+            Base class used for resolving a name into a member on the type.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.MemberBinder.GetBaseInstanceMethod(System.Type,System.String[])">
+            <summary>
+            Gets an instance op method for the given type and name.
+            
+            Instance ops methods appaer on the base most class that's required to expose it.  So
+            if we have: Array[int], Array, object we'd only add an instance op method to Array and
+            Array[int] inherits it.  It's obviously not on object because if it was there we'd just
+            put the method in ObjectOps.
+            
+            Therefore the different binders expose this at the appropriate times.  
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.ResolveBinder">
+            <summary>
+            MemberBinder which searches the entire type hierarchy and their extension types to find a member.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonTypeInfo.LookupBinder">
+            <summary>
+            MemberBinder which searches only the current type and it's extension types to find a member.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetMemberGroup(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type,System.String)">
+            <summary>
+            Primary worker for getting the member(s) associated with a single name.  Can be called with different MemberBinder's to alter the
+            scope of the search.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetResolvedMembers(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type)">
+            <summary>
+            Primary worker for returning a list of all members in a type.  Can be called with different MemberBinder's to alter the scope
+            of the search.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetInstanceOpsMethod(System.Type,System.String[])">
+            <summary>
+            Helper to get a MemberGroup for methods declared on InstanceOps
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.FindCastMethod(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type,System.Collections.Generic.List{System.Type})">
+            <summary>
+            Helper to get the proper typecasting method, according to the following precedence rules:
+            
+            1. Strongest (most specific) declaring type
+            2. Strongest (most specific) parameter type
+            3. Type of conversion
+                i.  Implicit
+                ii. Explicit
+            4. Return type (order specified in toTypes)
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.MakeConversionResolver(System.Collections.Generic.List{System.Type})">
+            <summary>
+            Helper for creating a typecast resolver
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.MakeIndexerResolver(System.Boolean)">
+            <summary>
+            Helper for creating __getitem__/__setitem__ resolvers
+            </summary>
+            <param name="set">false for a getter, true for a setter</param>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.IncludeOperatorMethod(System.Type,IronPython.Runtime.Binding.PythonOperationKind)">
+            <summary>
+            Filters out methods which are present on standard .NET types but shouldn't be there in Python
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.FilterFieldAndEvent(Microsoft.Scripting.Actions.MemberGroup)">
+            <summary>
+            When private binding is enabled we can have a collision between the private Event
+            and private field backing the event.  We filter this out and favor the event.
+            
+            This matches the v1.0 behavior of private binding.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.ProtectedOnly(System.Reflection.MemberInfo)">
+            <summary>
+            Filters down to include only protected methods
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.FilterForwardReverseMethods(System.String,Microsoft.Scripting.Actions.MemberGroup,System.Type,IronPython.Runtime.Binding.PythonOperationKind)">
+            <summary>
+            If an operator is a reverisble operator (e.g. addition) then we need to filter down to just the forward/reverse
+            versions of the .NET method.  For example consider:
+            
+                String.op_Multiplication(int, string)
+                String.op_Multiplication(string, int)
+                
+            If this method were defined on string it defines that you can do:
+                2 * 'abc'
+              or:
+                'abc' * 2
+                
+            either of which will produce 'abcabc'.  The 1st form is considered the reverse form because it is declared on string
+            but takes a non-string for the 1st argument.  The 2nd is considered the forward form because it takes a string as the
+            1st argument.
+            
+            When dynamically dispatching for 2 * 'abc' we'll first try __mul__ on int, which will fail with a string argument.  Then we'll try
+            __rmul__ on a string which will succeed and dispatch to the (int, string) overload.
+            
+            For multiplication in this case it's not too interesting because it's commutative.  For addition this might be more interesting
+            if, for example, we had unicode and ASCII strings.  In that case Unicode strings would define addition taking both unicode and
+            ASCII strings in both forms.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.AreTypesCompatible(System.Type,System.Type)">
+            <summary>
+            Checks to see if the parameter type and the declaring type are compatible to determine
+            if an operator is forward or reverse.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeInfo.IsPythonRecognizedOperator(System.String)">
+            <summary>
+            Checks to see if this is an operator method which Python recognizes.  For example
+            op_Comma is not recognized by Python and therefore should exposed to the user as
+            a method that is callable by name.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.BuiltinFunction">
+            <summary>
+            BuiltinFunction represents any standard CLR function exposed to Python.
+            This is used for both methods on standard Python types such as list or tuple
+            and for methods from arbitrary .NET assemblies.
+            
+            All calls are made through the optimizedTarget which is created lazily.
+            
+            TODO: Back BuiltinFunction's by MethodGroup's.
+            </summary>    
+        </member>
+        <member name="M:IronPython.Runtime.Types.BuiltinFunction.MakeFunction(System.String,System.Reflection.MethodBase[],System.Type)">
+            <summary>
+            Creates a new builtin function for a static .NET function.  This is used for module methods
+            and well-known __new__ methods.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.BuiltinFunction.MakeMethod(System.String,System.Reflection.MethodBase[],System.Type,IronPython.Runtime.Types.FunctionType)">
+            <summary>
+            Creates a built-in function for a .NET method declared on a type.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.BuiltinFunction.#ctor(System.Object,IronPython.Runtime.Types.BuiltinFunction.BuiltinFunctionData)">
+            <summary>
+            Creates a bound built-in function.  The instance may be null for built-in functions
+            accessed for None.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.BuiltinFunction.MakeGenericMethod(System.Type[])">
+            <summary>
+            Returns a BuiltinFunction bound to the provided type arguments.  Returns null if the binding
+            cannot be performed.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.BuiltinFunction.GetDescriptor">
+            <summary>
+            Returns a descriptor for the built-in function if one is
+            neededed
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.BuiltinFunction.Targets">
+            <summary>
+            Gets the target methods that we'll be calling.  
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.BuiltinFunction.IsAlwaysVisible">
+            <summary>
+            True if the method should be visible to non-CLS opt-in callers
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.BuiltinFunction.MakeBoundFunctionTest(System.Linq.Expressions.Expression)">
+            <summary>
+            Makes a test for the built-in function against the private _data 
+            which is unique per built-in function.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.BuiltinFunction.MakeBuiltinFunctionCall(System.Dynamic.DynamicMetaObjectBinder,System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[],System.Boolean,System.Dynamic.BindingRestrictions,System.Func{System.Dynamic.DynamicMetaObject[],IronPython.Runtime.Types.BuiltinFunction.BindingResult})">
+            <summary>
+            Helper for generating the call to a builtin function.  This is used for calls from built-in method
+            descriptors and built-in functions w/ and w/o a bound instance.  
+            
+            This provides all sorts of common checks on top of the call while the caller provides a delegate
+            to do the actual call.  The common checks include:
+                check for generic-only methods
+                reversed operator support
+                transforming arguments so the default binder can understand them (currently user defined mapping types to PythonDictionary)
+                returning NotImplemented from binary operators
+                Warning when calling certain built-in functions
+                
+            </summary>
+            <param name="call">The call binder we're doing the call for</param>
+            <param name="codeContext">An expression which points to the code context</param>
+            <param name="function">the meta object for the built in function</param>
+            <param name="hasSelf">true if we're calling with an instance</param>
+            <param name="args">The arguments being passed to the function</param>
+            <param name="functionRestriction">A restriction for the built-in function, method desc, etc...</param>
+            <param name="bind">A delegate to perform the actual call to the method.</param>
+        </member>
+        <member name="P:IronPython.Runtime.Types.BuiltinFunction.Overloads">
+            <summary>
+            Provides (for reflected methods) a mapping from a signature to the exact target
+            which takes this signature.
+            signature with syntax like the following:
+               someClass.SomeMethod.Overloads[str, int]("Foo", 123)
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.BuiltinFunction.OverloadDictionary">
+            <summary>
+            Gets the overload dictionary for the logical function.  These overloads
+            are never bound to an instance.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.BuiltinFunction.BindingSelf">
+            <summary>
+            Returns the instance used for binding.  This differs on module functions implemented
+            using instance methods so the built-in functions there don't expose the instance.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.GenericBuiltinFunction">
+            <summary>
+            A custom built-in function which supports indexing 
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.GenericBuiltinFunction.Item(System.Object[])">
+            <summary>
+            Use indexing on generic methods to provide a new reflected method with targets bound with
+            the supplied type arguments.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.ReflectedEvent">
+            <summary>
+            The unbound representation of an event property
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.ReflectedEvent.BoundEvent">
+            <summary>
+            BoundEvent is the object that gets returned when the user gets an event object.  An
+            BoundEvent tracks where the event was received from and is used to verify we get
+            a proper add when dealing w/ statics events.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.ReflectedExtensionProperty">
+            <summary>
+            Represents a ReflectedProperty created for an extension method.  Logically the property is an
+            instance property but the method implementing it is static.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.ReflectedField.GetValue(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Convenience function for users to call directly
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.ReflectedField.SetValue(IronPython.Runtime.CodeContext,System.Object,System.Object)">
+            <summary>
+            This function can be used to set a field on a value type without emitting a warning. Otherwise it is provided only to have symmetry with properties which have GetValue/SetValue for supporting explicitly implemented interfaces.
+            
+            Setting fields on value types usually warns because it can silently fail to update the value you expect.  For example consider this example where Point is a value type with the public fields X and Y:
+            
+            arr = System.Array.CreateInstance(Point, 10)
+            arr[0].X = 42
+            print arr[0].X
+            
+            prints 0.  This is because reading the value from the array creates a copy of the value.  Setting the value then mutates the copy and the array does not get updated.  The same problem exists when accessing members of a class.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.ReflectedGetterSetter">
+            <summary>
+            Base class for properties backed by methods.  These include our slot properties,
+            indexers, and normal properties.  This class provides the storage of these as well
+            as the storage of our optimized getter/setter methods, documentation for the property,
+            etc...
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.ReflectedIndexer">
+            <summary>
+            Provides access to non-default .NET indexers (aka properties w/ parameters).
+            
+            C# doesn't support these, but both COM and VB.NET do.  The types dictionary
+            gets populated w/a ReflectedGetterSetter indexer which is a descriptor.  Getting
+            the descriptor returns a bound indexer.  The bound indexer supports indexing.
+            We support multiple indexer parameters via expandable tuples.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.ReflectedProperty.CanOptimizeGets">
+            <summary>
+            True if generating code for gets can result in more optimal accesses.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.ReflectedProperty.GetValue(IronPython.Runtime.CodeContext,System.Object)">
+            <summary>
+            Convenience function for users to call directly
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.ReflectedProperty.SetValue(IronPython.Runtime.CodeContext,System.Object,System.Object)">
+            <summary>
+            Convenience function for users to call directly
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Types.IPythonObject">
+            <summary>
+            This interface is used for implementing parts of the IronPython type system.  It
+            is not intended for consumption from user programs.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.IPythonObject.SetDict(IronPython.Runtime.PythonDictionary)">
+            <summary>
+            Thread-safe dictionary set.  Returns the dictionary set or the previous value if already set or 
+            null if the dictionary set isn't supported.
+            </summary>
+            <param name="dict"></param>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.Types.IPythonObject.ReplaceDict(IronPython.Runtime.PythonDictionary)">
+            <summary>
+            Dictionary replacement.  Returns true if replaced, false if the dictionary set isn't supported.
+            </summary>
+            <param name="dict"></param>
+            <returns></returns>
+        </member>
+        <member name="T:IronPython.Runtime.Types.PythonTypeSlot">
+            <summary>
+            A TypeSlot is an item that gets stored in a type's dictionary.  Slots provide an 
+            opportunity to customize access at runtime when a value is get or set from a dictionary.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeSlot.TryGetValue(IronPython.Runtime.CodeContext,System.Object,IronPython.Runtime.Types.PythonType,System.Object@)">
+            <summary>
+            Gets the value stored in the slot for the given instance binding it to an instance if one is provided and
+            the slot binds to instances.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeSlot.TrySetValue(IronPython.Runtime.CodeContext,System.Object,IronPython.Runtime.Types.PythonType,System.Object)">
+            <summary>
+            Sets the value of the slot for the given instance.
+            </summary>
+            <returns>true if the value was set, false if it can't be set</returns>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeSlot.TryDeleteValue(IronPython.Runtime.CodeContext,System.Object,IronPython.Runtime.Types.PythonType)">
+            <summary>
+            Deletes the value stored in the slot from the instance.
+            </summary>
+            <returns>true if the value was deleted, false if it can't be deleted</returns>
+        </member>
+        <member name="P:IronPython.Runtime.Types.PythonTypeSlot.CanOptimizeGets">
+            <summary>
+            True if generating code for gets can result in more optimal accesses.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Types.PythonTypeSlot.MakeGetExpression(IronPython.Runtime.Binding.PythonBinder,System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject,IronPython.Runtime.Binding.ConditionalBuilder)">
+            <summary>
+            Gets an expression which is used for accessing this slot.  If the slot lookup fails the error expression
+            is used again.
+            
+            The default implementation just calls the TryGetValue method.  Subtypes of PythonTypeSlot can override
+            this and provide a more optimal implementation.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.Types.PythonTypeSlot.GetAlwaysSucceeds">
+            <summary>
+            True if TryGetValue will always succeed, false if it may fail.
+            
+            This is used to optimize away error generation code.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.CommonDictionaryStorage">
+            <summary>
+            General purpose storage used for most PythonDictionarys.
+            
+            This dictionary storage is thread safe for multiple readers or writers.
+            
+            Mutations to the dictionary involves a simple locking strategy of
+            locking on the DictionaryStorage object to ensure that only one
+            mutation happens at a time.
+            
+            Reads against the dictionary happen lock free.  When the dictionary is mutated
+            it is either adding or removing buckets in a thread-safe manner so that the readers
+            will either see a consistent picture as if the read occured before or after the mutation.
+            
+            When resizing the dictionary the buckets are replaced atomically so that the reader
+            sees the new buckets or the old buckets.  When reading the reader first reads
+            the buckets and then calls a static helper function to do the read from the bucket
+            array to ensure that readers are not seeing multiple bucket arrays.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.#ctor">
+            <summary>
+            Creates a new dictionary storage with no buckets
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.#ctor(System.Int32)">
+            <summary>
+            Creates a new dictionary storage with no buckets
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.#ctor(System.Object[],System.Boolean)">
+            <summary>
+            Creates a new dictionary geting values/keys from the
+            items arary
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.#ctor(IronPython.Runtime.CommonDictionaryStorage.Bucket[],System.Int32,System.Type,System.Func{System.Object,System.Int32},System.Func{System.Object,System.Object,System.Boolean},IronPython.Runtime.CommonDictionaryStorage.NullValue)">
+            <summary>
+            Creates a new dictionary storage with the given set of buckets
+            and size.  Used when cloning the dictionary storage.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Add(System.Object,System.Object)">
+            <summary>
+            Adds a new item to the dictionary, replacing an existing one if it already exists.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Initialize">
+            <summary>
+            Initializes the buckets to their initial capacity, the caller
+            must check if the buckets are empty first.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Add(IronPython.Runtime.CommonDictionaryStorage.Bucket[],System.Object,System.Object)">
+            <summary>
+            Add helper that works over a single set of buckets.  Used for
+            both the normal add case as well as the resize case.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.AddWorker(IronPython.Runtime.CommonDictionaryStorage.Bucket[],System.Object,System.Object,System.Int32)">
+            <summary>
+            Add helper which adds the given key/value (where the key is not null) with
+            a pre-computed hash code.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Remove(IronPython.Runtime.DictionaryStorage@,System.Object)">
+            <summary>
+            Removes an entry from the dictionary and returns true if the
+            entry was removed or false.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.RemoveAlwaysHash(System.Object)">
+            <summary>
+            Removes an entry from the dictionary and returns true if the
+            entry was removed or false.  The key will always be hashed
+            so if it is unhashable an exception will be thrown - even
+            if the dictionary has no buckets.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Contains(System.Object)">
+            <summary>
+            Checks to see if the key exists in the dictionary.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.TryGetValue(System.Object,System.Object@)">
+            <summary>
+            Trys to get the value associated with the given key and returns true
+            if it's found or false if it's not present.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.TryGetValue(IronPython.Runtime.CommonDictionaryStorage.Bucket[],System.Object,System.Object@)">
+            <summary>
+            Static helper to try and get the value from the dictionary.
+            
+            Used so the value lookup can run against a buckets while a writer
+            replaces the buckets.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.CommonDictionaryStorage.Count">
+            <summary>
+            Returns the number of key/value pairs currently in the dictionary.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Clear(IronPython.Runtime.DictionaryStorage@)">
+            <summary>
+            Clears the contents of the dictionary.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Clone">
+            <summary>
+            Clones the storage returning a new DictionaryStorage object.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.CommonDictionaryStorage.Hash(System.Object)">
+            <summary>
+            Helper to hash the given key w/ support for null.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.CommonDictionaryStorage.Bucket">
+            <summary>
+            Used to store a single hashed key/value.
+            
+            Bucket is not serializable because it stores the computed hash
+            code which could change between serialization and deserialization.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.CommonDictionaryStorage.DeserializationNullValue">
+            <summary>
+            Special marker NullValue used during deserialization to not add
+            an extra field to the dictionary storage type.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.DictionaryStorage">
+            <summary>
+            Abstract base class for all PythonDictionary storage.
+            
+            Defined as a class instead of an interface for performance reasons.  Also not
+            using IDictionary* for keeping a simple interface.
+            
+            Full locking is defined as being on the DictionaryStorage object it's self,
+            not an internal member.  This enables subclasses to provide their own locking
+            aruond large operations and call lock free functions.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.DictionaryStorage.CopyTo(IronPython.Runtime.DictionaryStorage@)">
+            <summary>
+            Adds items from this dictionary into the other dictionary
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.DictionaryStorage.TryGetPath(System.Object@)">
+            <summary>
+            Provides fast access to the __path__ attribute if the dictionary storage supports caching it.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.DictionaryStorage.TryGetPackage(System.Object@)">
+            <summary>
+            Provides fast access to the __package__ attribute if the dictionary storage supports caching it.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.DictionaryStorage.TryGetBuiltins(System.Object@)">
+            <summary>
+            Provides fast access to the __builtins__ attribute if the dictionary storage supports caching it.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.DictionaryStorage.TryGetName(System.Object@)">
+            <summary>
+            Provides fast access to the __name__ attribute if the dictionary storage supports caching it.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.DictionaryStorage.TryGetImport(System.Object@)">
+            <summary>
+            Provides fast access to the __import__ attribute if the dictionary storage supports caching it.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.IParameterSequence">
+            <summary>
+            Represents a sequence which may have been provided as a set of parameters to an indexer.
+            
+            TODO: This should be removed, and all uses of this should go to [SpecialName]object GetItem(..., params object[] keys)
+            and [SpecialName]void SetItem(..., params object [] keys) or this[params object[]xyz] which is also legal.  
+            
+            currently this exists for backwards compatibility w/ IronPython's "expandable tuples".
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.ModuleDictionaryStorage">
+            <summary>
+            Enables lazy initialization of module dictionaries.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.PythonAsciiEncoding">
+            <summary>
+            Simple implementation of ASCII encoding/decoding.  The default instance (PythonAsciiEncoding.Instance) is
+            setup to always convert even values outside of the ASCII range.  The EncoderFallback/DecoderFallbacks can
+            be replaced with versions that will throw exceptions instead though.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.FunctionAttributes.ArgumentList">
+            <summary>
+            Set if the function includes a *args argument list.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.FunctionAttributes.KeywordDictionary">
+            <summary>
+            Set if the function includes a **kwargs argument dictionary.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.FunctionAttributes.Generator">
+            <summary>
+            Set if the function is a generator.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.FunctionAttributes.FutureDivision">
+            <summary>
+            Set if the function was compiled with future division.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.FunctionAttributes.CanSetSysExcInfo">
+            <summary>
+            IronPython specific: Set if the function includes nested exception handling and therefore can alter
+            sys.exc_info().
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.FunctionAttributes.ContainsTryFinally">
+            <summary>
+            IronPython specific: Set if the function includes a try/finally block.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.FunctionCode">
+            <summary>
+            Represents a piece of code.  This can reference either a CompiledCode
+            object or a Function.   The user can explicitly call FunctionCode by
+            passing it into exec or eval.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.FunctionCode._CodeCreateAndUpdateDelegateLock">
+            <summary>
+            This is both the lock that is held while enumerating the threads or updating the thread accounting
+            information.  It's also a marker CodeList which is put in place when we are enumerating the thread
+            list and all additions need to block.
+            
+            This lock is also acquired whenever we need to calculate how a function's delegate should be created 
+            so that we don't race against sys.settrace/sys.setprofile.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.FunctionCode.#ctor(IronPython.Runtime.PythonContext,System.Delegate,IronPython.Compiler.Ast.ScopeStatement,System.String,System.Int32)">
+            <summary>
+            Constructor used to create a FunctionCode for code that's been serialized to disk.  
+            
+            Code constructed this way cannot be interpreted or debugged using sys.settrace/sys.setprofile.
+            
+            Function codes created this way do support recursion enforcement and are therefore registered in the global function code registry.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.FunctionCode.#ctor(IronPython.Runtime.PythonContext,System.Delegate,IronPython.Compiler.Ast.ScopeStatement,System.String,System.Nullable{System.Boolean},System.Boolean)">
+            <summary>
+            Constructor to create a FunctionCode at runtime.
+            
+            Code constructed this way supports both being interpreted and debugged.  When necessary the code will
+            be re-compiled or re-interpreted for that specific purpose.
+            
+            Function codes created this way do support recursion enforcement and are therefore registered in the global function code registry.
+            
+            the initial delegate provided here should NOT be the actual code.  It should always be a delegate which updates our Target lazily.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.FunctionCode.RegisterFunctionCode(IronPython.Runtime.PythonContext)">
+            <summary>
+            Registers the current function code in our global weak list of all function codes.
+            
+            The weak list can be enumerated with GetAllCode().
+            
+            Ultimately there are 3 types of threads we care about races with:
+                1. Other threads which are registering function codes
+                2. Threads calling sys.settrace which require the world to stop and get updated
+                3. Threads running cleanup (thread pool thread, or call to gc.collect).
+                
+            The 1st two must have perfect synchronization.  We cannot have a thread registering
+            a new function which another thread is trying to update all of the functions in the world.  Doing
+            so would mean we could miss adding tracing to a thread.   
+            
+            But the cleanup thread can run in parallel to either registrying or sys.settrace.  The only
+            thing it needs to take a lock for is updating our accounting information about the
+            number of code objects are alive.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.FunctionCode.GetAllCode(IronPython.Runtime.PythonContext)">
+            <summary>
+            Enumerates all function codes for updating the current type of targets we generate.
+            
+            While enumerating we hold a lock so that users cannot change sys.settrace/sys.setprofile
+            until the lock is released.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.FunctionCode.co_cellvars">
+            <summary>
+            Returns a list of variable names which are accessed from nested functions.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.FunctionCode.co_code">
+            <summary>
+            Returns the byte code.  IronPython does not implement this and always
+            returns an empty string for byte code.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.FunctionCode.co_consts">
+            <summary>
+            Returns a list of constants used by the function.
+            
+            The first constant is the doc string, or None if no doc string is provided.
+            
+            IronPython currently does not include any other constants than the doc string.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.FunctionCode.co_filename">
+            <summary>
+            Returns the filename that the code object was defined in.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.FunctionCode.co_firstlineno">
+            <summary>
+            Returns the 1st line number of the code object.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.FunctionCode.co_flags">
+            <summary>
+            Returns a set of flags for the function.
+            
+                0x04 is set if the function used *args
+                0x08 is set if the function used **args
+                0x20 is set if the function is a generator
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.FunctionCode.co_freevars">
+            <summary>
+            Returns a list of free variables (variables accessed
+            from an outer scope).  This does not include variables
+            accessed in the global scope.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.FunctionCode.co_lnotab">
+            <summary>
+            Returns a mapping between byte code and line numbers.  IronPython does
+            not implement this because byte code is not available.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.FunctionCode.co_name">
+            <summary>
+            Returns the name of the code (function name, class name, or &lt;module&gt;).
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.FunctionCode.co_names">
+            <summary>
+            Returns a list of global variable names accessed by the code.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.FunctionCode.co_nlocals">
+            <summary>
+            Returns the number of local varaibles defined in the function.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.FunctionCode.co_stacksize">
+            <summary>
+            Returns the stack size.  IronPython does not implement this
+            because byte code is not supported.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.FunctionCode.FromSourceUnit(Microsoft.Scripting.SourceUnit,IronPython.Compiler.PythonCompilerOptions,System.Boolean)">
+            <summary>
+            Creates a FunctionCode object for exec/eval/execfile'd/compile'd code.
+            
+            The code is then executed in a specific CodeContext by calling the .Call method.
+            
+            If the code is being used for compile (vs. exec/eval/execfile) then it needs to be
+            registered in case our tracing mode changes.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.FunctionCode.LazyCompileFirstTarget(IronPython.Runtime.PythonFunction)">
+            <summary>
+            Called the 1st time a function is invoked by our OriginalCallTarget* methods
+            over in PythonCallTargets.  This computes the real delegate which needs to be
+            created for the function.  Usually this means starting off interpretering.  It 
+            also involves adding the wrapper function for recursion enforcement.
+            
+            Because this can race against sys.settrace/setprofile we need to take our 
+            _ThreadIsEnumeratingAndAccountingLock to ensure no one is actively changing all
+            of the live functions.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.FunctionCode.UpdateDelegate(IronPython.Runtime.PythonContext,System.Boolean)">
+            <summary>
+            Updates the delegate based upon current Python context settings for recursion enforcement
+            and for tracing.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.FunctionCode.SetDebugTarget(IronPython.Runtime.PythonContext,System.Delegate)">
+            <summary>
+            Called to set the initial target delegate when the user has passed -X:Debug to enable
+            .NET style debugging.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.FunctionCode.GetGeneratorOrNormalLambdaTracing(IronPython.Runtime.PythonContext)">
+            <summary>
+            Gets the LambdaExpression for tracing.  
+            
+            If this is a generator function code then the lambda gets tranformed into the correct generator code.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.FunctionCode.GetGeneratorOrNormalLambda">
+            <summary>
+            Gets the correct final LambdaExpression for this piece of code.
+            
+            This is either just _lambda or _lambda re-written to be a generator expression.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.FunctionCode.CodeList">
+            <summary>
+            Extremely light weight linked list of weak references used for tracking
+            all of the FunctionCode objects which get created and need to be updated
+            for purposes of recursion enforcement or tracing.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Converter.TryConvert(System.Object,System.Type,System.Object@)">
+            <summary>
+            General conversion routine TryConvert - tries to convert the object to the desired type.
+            Try to avoid using this method, the goal is to ultimately remove it!
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Converter.TryConvertToIEnumerator(System.Object,System.Collections.IEnumerator@)">
+            <summary>
+            This function tries to convert an object to IEnumerator, or wraps it into an adapter
+            Do not use this function directly. It is only meant to be used by Ops.GetEnumerator.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Converter.ConvertToIEnumerator(System.Object)">
+            <summary>
+            This function tries to convert an object to IEnumerator, or wraps it into an adapter
+            Do not use this function directly. It is only meant to be used by Ops.GetEnumerator.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Converter.TryConvertToIndex(System.Object,System.Boolean,System.Int32@)">
+            <summary>
+            Attempts to convert value into a index usable for slicing and return the integer
+            value.  If the conversion fails false is returned.
+            
+            If throwOverflowError is true then BigInteger's outside the normal range of integers will
+            result in an OverflowError.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Converter.TryConvertToIndex(System.Object,System.Boolean,System.Object@)">
+            <summary>
+            Attempts to convert value into a index usable for slicing and return the integer
+            value.  If the conversion fails false is returned.
+            
+            If throwOverflowError is true then BigInteger's outside the normal range of integers will
+            result in an OverflowError.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Converter.ImplicitConvertToInt32(System.Object)">
+            <summary>
+            Converts a value to int ignoring floats
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.DictionaryKeyEnumerator">
+            <summary>
+            Note: 
+              IEnumerator innerEnum = Dictionary&lt;K,V&gt;.KeysCollections.GetEnumerator();
+              innerEnum.MoveNext() will throw InvalidOperation even if the values get changed,
+              which is supported in python
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.DictionaryValueEnumerator">
+            <summary>
+            Note: 
+              IEnumerator innerEnum = Dictionary&lt;K,V&gt;.KeysCollections.GetEnumerator();
+              innerEnum.MoveNext() will throw InvalidOperation even if the values get changed,
+              which is supported in python
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.DictionaryItemEnumerator">
+            <summary>
+            Note: 
+              IEnumerator innerEnum = Dictionary&lt;K,V&gt;.KeysCollections.GetEnumerator();
+              innerEnum.MoveNext() will throw InvalidOperation even if the values get changed,
+              which is supported in python
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.DictionaryOps">
+            <summary>
+            Provides both helpers for implementing Python dictionaries as well
+            as providing public methods that should be exposed on all dictionary types.
+            
+            Currently these are published on IDictionary&lt;object, object&gt;
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.PythonGenerator._active">
+            <summary>
+            True iff the thread is currently inside the generator (ie, invoking the _next delegate).
+            This can be used to enforce that a generator does not call back into itself. 
+            Pep255 says that a generator should throw a ValueError if called reentrantly.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.PythonGenerator._LastFinalizer">
+            <summary>
+            We cache the GeneratorFinalizer of generators that were closed on the user
+            thread, and did not get finalized on the finalizer thread. We can then reuse
+            the object. Reusing objects with a finalizer is good because it reduces
+            the load on the GC's finalizer queue.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.PythonGenerator._excInfo">
+            <summary>
+            Fields set by Throw() to communicate an exception to the yield point.
+            These are plumbed through the generator to become parameters to Raise(...) invoked 
+            at the yield suspension point in the generator.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.PythonGenerator._sendValue">
+            <summary>
+            Value sent by generator.send().
+            Since send() could send an exception, we need to keep this different from throwable's value.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonGenerator.throw(System.Object)">
+            <summary>
+            See PEP 342 (http://python.org/dev/peps/pep-0342/) for details of new methods on Generator.
+            Full signature including default params for throw is:
+               throw(type, value=None, traceback=None)
+            Use multiple overloads to resolve the default parameters.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonGenerator.throw(System.Object,System.Object,System.Object,System.Boolean)">
+            <summary>
+            Throw(...) is like Raise(...) being called from the yield point within the generator.
+            Note it must come from inside the generator so that the traceback matches, and so that it can 
+            properly cooperate with any try/catch/finallys inside the generator body.
+            
+            If the generator catches the exception and yields another value, that is the return value of g.throw().
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonGenerator.send(System.Object)">
+            <summary>
+            send() was added in Pep342. It sends a result back into the generator, and the expression becomes
+            the result of yield when used as an expression.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonGenerator.close(System.Boolean)">
+            <summary>
+            Close introduced in Pep 342.
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.PythonGenerator.__name__">
+            <summary>
+            Gets the name of the function that produced this generator object.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonGenerator.MoveNextWorker">
+            <summary>
+            Core implementation of IEnumerator.MoveNext()
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonGenerator.NextWorker">
+            <summary>
+            Core implementation of Python's next() method.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonGenerator.CheckThrowableAndReturnSendValue">
+            <summary>
+            Helper called from PythonOps after the yield statement
+            Keepin this in a helper method:
+            - reduces generated code size
+            - allows better coupling with PythonGenerator.Throw()
+            - avoids throws from emitted code (which can be harder to debug).
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.PythonGenerator.CheckThrowable">
+            <summary>
+            Called to throw an exception set by Throw().
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.PythonGenerator.GeneratorFlags.Closed">
+            <summary>
+            True if the generator has finished (is "closed"), else false.
+            Python language spec mandates that calling Next on a closed generator gracefully throws a StopIterationException.
+            This can never be reset.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.PythonGenerator.GeneratorFlags.CanSetSysExcInfo">
+            <summary>
+            True if the generator can set sys exc info and therefore needs exception save/restore.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.Importer">
+            <summary>
+            Importer class - used for importing modules.  Used by Ops and __builtin__
+            Singleton living on Python engine.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Importer.Import(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.PythonTuple,System.Int32)">
+            <summary>
+            Gateway into importing ... called from Ops.  Performs the initial import of
+            a module and returns the module.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Importer.ImportLightThrow(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.PythonTuple,System.Int32)">
+            <summary>
+            Gateway into importing ... called from Ops.  Performs the initial import of
+            a module and returns the module.  This version returns light exceptions instead of throwing.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Importer.ImportFrom(IronPython.Runtime.CodeContext,System.Object,System.String)">
+            <summary>
+            Gateway into importing ... called from Ops.  This is called after
+            importing the module and is used to return individual items from
+            the module.  The outer modules dictionary is then updated with the
+            result.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Importer.ImportModule(IronPython.Runtime.CodeContext,System.Object,System.String,System.Boolean,System.Int32)">
+            <summary>
+            Called by the __builtin__.__import__ functions (general importing) and ScriptEngine (for site.py)
+            
+            level indiciates whether to perform absolute or relative imports.
+                -1 indicates both should be performed
+                0 indicates only absolute imports should be performed
+                Positive numbers indicate the # of parent directories to search relative to the calling module
+            </summary>        
+        </member>
+        <member name="M:IronPython.Runtime.Importer.TryGetNameAndPath(IronPython.Runtime.CodeContext,System.Object,System.String,System.Int32,System.String,System.String@,IronPython.Runtime.List@,IronPython.Runtime.PythonModule@)">
+            <summary>
+            Interrogates the importing module for __name__ and __path__, which determine
+            whether the imported module (whose name is 'name') is being imported as nested
+            module (__path__ is present) or as sibling.
+            
+            For sibling import, the full name of the imported module is parent.sibling
+            For nested import, the full name of the imported module is parent.module.nested
+            where parent.module is the mod.__name__
+            </summary>
+            <param name="context"></param>
+            <param name="globals">the globals dictionary</param>
+            <param name="name">Name of the module to be imported</param>
+            <param name="full">Output - full name of the module being imported</param>
+            <param name="path">Path to use to search for "full"</param>
+            <param name="level">the import level for relaive imports</param>
+            <param name="parentMod">the parent module</param>
+            <param name="package">the global __package__ value</param>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Runtime.Importer.GetParentPathAndModule(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.PythonModule@)">
+            <summary>
+            Given the parent module name looks up the __path__ property.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Importer.TryGetExistingOrMetaPathModule(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.List,System.Object@)">
+            <summary>
+            Trys to get an existing module and if that fails fall backs to searching 
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Importer.TryLoadMetaPathModule(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.List,System.Object@)">
+            <summary>
+            Attempts to load a module from sys.meta_path as defined in PEP 302.
+            
+            The meta_path provides a list of importer objects which can be used to load modules before
+            searching sys.path but after searching built-in modules.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Importer.FindAndLoadModuleFromImporter(IronPython.Runtime.CodeContext,System.Object,System.String,IronPython.Runtime.List,System.Object@)">
+            <summary>
+            Given a user defined importer object as defined in PEP 302 tries to load a module.
+            
+            First the find_module(fullName, path) is invoked to get a loader, then load_module(fullName) is invoked
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Importer.FindImporterForPath(IronPython.Runtime.CodeContext,System.String)">
+            <summary>
+            Finds a user defined importer for the given path or returns null if no importer
+            handles this path.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.IWeakReferenceable">
+            <summary>
+            Defines the internal interface used for accessing weak references and adding finalizers
+            to user-defined types.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.IWeakReferenceable.GetWeakRef">
+            <summary>
+            Gets the current WeakRefTracker for an object that can be used to
+            append additional weak references.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.IWeakReferenceable.SetWeakRef(IronPython.Runtime.WeakRefTracker)">
+            <summary>
+            Attempts to set the WeakRefTracker for an object.  Used on the first
+            addition of a weak ref tracker to an object.  If the object doesn't
+            support adding weak references then it returns false.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.IWeakReferenceable.SetFinalizer(IronPython.Runtime.WeakRefTracker)">
+            <summary>
+            Sets a WeakRefTracker on an object for the purposes of supporting finalization.
+            All user types (new-style and old-style) support finalization even if they don't
+            support weak-references, and therefore this function always succeeds.  Note the
+            slot used to store the WeakRefTracker is still shared between SetWeakRef and 
+            SetFinalizer if a type supports both.
+            </summary>
+            <param name="value"></param>
+        </member>
+        <member name="T:IronPython.Runtime.IWeakReferenceableByProxy">
+            <summary>
+            Allow types to implement weakvreference tracking by returning a proxy.
+            
+            The proxy can refer to the current Python context, whihc is the main purpose.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.IWeakReferenceableByProxy.GetWeakRefProxy(IronPython.Runtime.PythonContext)">
+            <summary>
+            
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.IPythonMembersList">
+            <summary>
+            Provides a list of all the members of an instance.  ie. all the keys in the 
+            dictionary of the object. Note that it can contain objects that are not strings. 
+            
+            Such keys can be added in IronPython using syntax like:
+                obj.__dict__[100] = someOtherObject
+                
+            This Python specific version also supports filtering based upon the show cls 
+            flag by flowing in the code context.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.List.FromArrayNoCopy(System.Object[])">
+            <summary>
+            Creates a new list with the data in the array and a size
+            the same as the length of the array.  The array is held
+            onto and may be mutated in the future by the list.
+            </summary>
+            <param name="data">params array to use for lists storage</param>
+        </member>
+        <member name="M:IronPython.Runtime.List.GetAddSize(System.Int32,System.Int32)">
+            <summary>
+            Gets a reasonable size for the addition of two arrays.  We round
+            to a power of two so that we usually have some extra space if
+            the resulting array gets added to.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.List.AddNoLock(System.Object)">
+            <summary>
+            Non-thread safe adder, should only be used by internal callers that
+            haven't yet exposed their list.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.List.DoCompare(System.Object[],System.Collections.IComparer,System.Int32,System.Int32,System.Boolean)">
+            <summary>
+            Compares the two specified keys
+            </summary>
+        </member>
+        <member name="P:IronPython.Runtime.List.Item(System.Object)">
+            <summary>
+            Supports __index__ on arbitrary types, also prevents __float__
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.OrderedLocker">
+            <summary>
+            we need to lock both objects (or copy all of one's data w/ it's lock held, and
+            then compare, which is bad).  Therefore we have a strong order for locking on 
+            the two objects based upon the hash code or object identity in case of a collision
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.LiteralParser">
+            <summary>
+            Summary description for ConstantValue.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.PythonBuffer.BufferMeta">
+            <summary>
+            A DynamicMetaObject which is just used to support custom conversions to COM.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.IPythonArray">
+            <summary>
+            A marker interface so we can recognize and access sequence members on our array objects.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.UnaryOperators">
+            <summary>
+            List of unary operators which we have sites for to enable fast dispatch that
+            doesn't collide with other operators.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonFile.SetMode(IronPython.Runtime.CodeContext,System.Boolean)">
+            <summary>
+            Sets the mode to text or binary.  Returns true if previously set to text, false if previously set to binary.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonFile.truncate">
+            <summary>
+            Truncates the file to the current length as indicated by tell().
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonFile.truncate(System.Int64)">
+            <summary>
+            Truncates the file to the specified length.
+            </summary>
+            <param name="size"></param>
+        </member>
+        <member name="T:IronPython.Runtime.PythonScopeExtension">
+            <summary>
+            Provides storage of IronPython specific data in the DLR Scope ScopeExtension.
+            
+            This enables IronPython to track code compilation flags such as from __future__
+            flags and import clr flags across multiple executions of user-provided scopes.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.PythonNarrowing">
+            <summary>
+            Provides human readable names for how Python maps the various DLR NarrowingLevel's.
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.PythonNarrowing.None">
+            <summary>
+            No narrowing conversions are performed
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.PythonNarrowing.BinaryOperator">
+            <summary>
+            Double/Single to Decimal
+            PythonTuple to Array
+            Generic conversions
+            BigInteger to Int64
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.PythonNarrowing.IndexOperator">
+            <summary>
+            Numeric conversions excluding from floating point values
+            Boolean conversions
+            Delegate conversions
+            Enumeration conversions
+            </summary>
+        </member>
+        <member name="F:IronPython.Runtime.PythonNarrowing.All">
+            <summary>
+            Enables Python protocol conversions (__int__, etc...)
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.ScopeDictionaryStorage">
+            <summary>
+            Provides dictionary based storage which is backed by a Scope object.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.SetCollection">
+            <summary>
+            Mutable set class
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.SetCollection.update(System.Object)">
+            <summary>
+            Appends an IEnumerable to an existing set
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.FrozenSetCollection">
+            <summary>
+            Immutable set class
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.SetIterator">
+            <summary>
+            Iterator over sets
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.Slice.DeprecatedFixed(System.Object,System.Int32@,System.Int32@)">
+            <summary>
+            Gets the indices for the deprecated __getslice__, __setslice__, __delslice__ functions
+            
+            This form is deprecated in favor of using __getitem__ w/ a slice object as an index.  This
+            form also has subtly different mechanisms for fixing the slice index before calling the function.
+            
+            If an index is negative and __len__ is not defined on the object than an AttributeError
+            is raised.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.StringFormatter">
+            <summary>
+            StringFormatter provides Python's % style string formatting services.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.StringFormatter.ReadMappingKey">
+            <summary>
+            Read a possible mapping key for %(key)s. 
+            </summary>
+            <returns>The key name enclosed between the '%(key)s', 
+            or null if there are no paranthesis such as '%s'.</returns>
+        </member>
+        <member name="M:IronPython.Runtime.StringFormatter.AppendBase(System.Char,System.Int32)">
+            <summary>
+            AppendBase appends an integer at the specified radix doing all the
+            special forms for Python.  We have a copy and paste version of this
+            for BigInteger below that should be kept in sync.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.StringFormatter.AppendBaseBigInt(System.Numerics.BigInteger,System.Char,System.Int32)">
+            <summary>
+            BigInteger version of AppendBase.  Should be kept in sync w/ AppendBase
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonTuple.ToArray">
+            <summary>
+            Return a copy of this tuple's data array.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.TupleEnumerator">
+            <summary>
+            public class to get optimized
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.PythonModule">
+            <summary>
+            Python module.  Stores classes, functions, and data.  Usually a module
+            is created by importing a file or package from disk.  But a module can also
+            be directly created by calling the module type and providing a name or
+            optionally a documentation string.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonModule.#ctor(IronPython.Runtime.PythonContext,Microsoft.Scripting.Runtime.Scope)">
+            <summary>
+            Creates a new module backed by a Scope.  Used for creating modules for foreign Scope's.
+            </summary>
+        </member>
+        <member name="M:IronPython.Runtime.PythonModule.#ctor(IronPython.Runtime.PythonDictionary)">
+            <summary>
+            Creates a new PythonModule with the specified dictionary.
+            
+            Used for creating modules for builtin modules which don't have any code associated with them.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.WeakRefTracker">
+            <summary>
+            single finalizable instance used to track and deliver all the 
+            callbacks for a single object that has been weakly referenced by
+            one or more references and proxies.  The reference to this object
+            is held in objects that implement IWeakReferenceable.
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.InstanceFinalizer">
+            <summary>
+            Finalizable object used to hook up finalization calls for OldInstances.
+            
+            We create one of these each time an object w/ a finalizer gets created.  The
+            only reference to this object is the instance so when that goes out of context
+            this does as well and this will get finalized.  
+            </summary>
+        </member>
+        <member name="T:IronPython.Runtime.WrapperDescriptorAttribute">
+            <summary>
+            Marks a method/field/property as being a wrapper descriptor.  A wrapper desriptor
+            is a member defined on PythonType but is available both for type and other
+            instances of type.  For example type.__bases__.
+            </summary>
+        </member>
+        <member name="T:IronPython.DictionaryTypeInfoAttribute">
+            <summary>
+            Provides more specific type information for Python dictionaries which are not strongly typed.
+            
+            This attribute can be applied to fields, parameters, proeprties, and return values.  It can be
+            inspected to get type information about the types of the keys and values of the expected 
+            dictionary or the returned dictionary.
+            </summary>
+        </member>
+        <member name="T:IronPython.Hosting.PythonService">
+            <summary>
+            Helper class for implementing the Python class.
+            
+            This is exposed as a service through PythonEngine and the helper class
+            uses this service to get the correct remoting semantics.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.PythonService.GetLocalCommandDispatcher">
+            <summary>
+            Returns an ObjectHandle to a delegate of type Action[Action] which calls the current
+            command dispatcher.
+            </summary>
+        </member>
+        <member name="T:IronPython.Hosting.PythonCommandLine">
+            <summary>
+            A simple Python command-line should mimic the standard python.exe
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.PythonCommandLine.GetLogoDisplay">
+            <summary>
+            Returns the display look for IronPython.  
+            
+            The returned string uses This \n instead of Environment.NewLine for it's line seperator 
+            because it is intended to be outputted through the Python I/O system.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.PythonCommandLine.InitializeExtensionDLLs">
+            <summary>
+            Loads any extension DLLs present in sys.prefix\DLLs directory and adds references to them.
+            
+            This provides an easy drop-in location for .NET assemblies which should be automatically referenced
+            (exposed via import), COM libraries, and pre-compiled Python code.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.PythonCommandLine.TryInteractiveActionWorker">
+            <summary>
+            Attempts to run a single interaction and handle any language-specific
+            exceptions.  Base classes can override this and call the base implementation
+            surrounded with their own exception handling.
+            
+            Returns null if successful and execution should continue, or an exit code.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.PythonCommandLine.RunOneInteraction">
+            <summary>
+            Parses a single interactive command and executes it.  
+            
+            Returns null if successful and execution should continue, or the appropiate exit code.
+            </summary>
+        </member>
+        <member name="P:IronPython.Hosting.PythonConsoleOptions.SkipFirstSourceLine">
+            <summary>
+            Skip the first line of the code to execute. This is useful for executing Unix scripts which
+            have the command to execute specified in the first line.
+            This only apply to the script code executed by the ScriptEngine APIs, but not for other script code 
+            that happens to get called as a result of the execution.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.PythonOptionsParser.ParseArgument(System.String)">
+            <exception cref="T:System.Exception">On error.</exception>
+        </member>
+        <member name="T:IronPython.Hosting.Python">
+            <summary>
+            Provides helpers for interacting with IronPython.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.CreateRuntime">
+            <summary>
+            Creates a new ScriptRuntime with the IronPython scipting engine pre-configured.
+            </summary>
+            <returns></returns>
+        </member>
+        <member name="M:IronPython.Hosting.Python.CreateRuntime(System.Collections.Generic.IDictionary{System.String,System.Object})">
+            <summary>
+            Creates a new ScriptRuntime with the IronPython scipting engine pre-configured and
+            additional options.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.CreateRuntime(System.AppDomain)">
+            <summary>
+            Creates a new ScriptRuntime with the IronPython scripting engine pre-configured
+            in the specified AppDomain.  The remote ScriptRuntime may  be manipulated from 
+            the local domain but all code will run in the remote domain.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.CreateRuntime(System.AppDomain,System.Collections.Generic.IDictionary{System.String,System.Object})">
+            <summary>
+            Creates a new ScriptRuntime with the IronPython scripting engine pre-configured
+            in the specified AppDomain with additional options.  The remote ScriptRuntime may 
+            be manipulated from the local domain but all code will run in the remote domain.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.CreateEngine">
+            <summary>
+            Creates a new ScriptRuntime and returns the ScriptEngine for IronPython. If
+            the ScriptRuntime is required it can be acquired from the Runtime property
+            on the engine.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.CreateEngine(System.Collections.Generic.IDictionary{System.String,System.Object})">
+            <summary>
+            Creates a new ScriptRuntime with the specified options and returns the 
+            ScriptEngine for IronPython. If the ScriptRuntime is required it can be 
+            acquired from the Runtime property on the engine.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.CreateEngine(System.AppDomain)">
+            <summary>
+            Creates a new ScriptRuntime and returns the ScriptEngine for IronPython. If
+            the ScriptRuntime is required it can be acquired from the Runtime property
+            on the engine.
+            
+            The remote ScriptRuntime may be manipulated from the local domain but 
+            all code will run in the remote domain.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.CreateEngine(System.AppDomain,System.Collections.Generic.IDictionary{System.String,System.Object})">
+            <summary>
+            Creates a new ScriptRuntime with the specified options and returns the 
+            ScriptEngine for IronPython. If the ScriptRuntime is required it can be 
+            acquired from the Runtime property on the engine.
+            
+            The remote ScriptRuntime may be manipulated from the local domain but 
+            all code will run in the remote domain.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.GetEngine(Microsoft.Scripting.Hosting.ScriptRuntime)">
+            <summary>
+            Given a ScriptRuntime gets the ScriptEngine for IronPython.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.GetSysModule(Microsoft.Scripting.Hosting.ScriptRuntime)">
+            <summary>
+            Gets a ScriptScope which is the Python sys module for the provided ScriptRuntime.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.GetSysModule(Microsoft.Scripting.Hosting.ScriptEngine)">
+            <summary>
+            Gets a ScriptScope which is the Python sys module for the provided ScriptEngine.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.GetBuiltinModule(Microsoft.Scripting.Hosting.ScriptRuntime)">
+            <summary>
+            Gets a ScriptScope which is the Python __builtin__ module for the provided ScriptRuntime.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.GetBuiltinModule(Microsoft.Scripting.Hosting.ScriptEngine)">
+            <summary>
+            Gets a ScriptScope which is the Python __builtin__ module for the provided ScriptEngine.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.GetClrModule(Microsoft.Scripting.Hosting.ScriptRuntime)">
+            <summary>
+            Gets a ScriptScope which is the Python clr module for the provided ScriptRuntime.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.GetClrModule(Microsoft.Scripting.Hosting.ScriptEngine)">
+            <summary>
+            Gets a ScriptScope which is the Python clr module for the provided ScriptEngine.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.ImportModule(Microsoft.Scripting.Hosting.ScriptRuntime,System.String)">
+            <summary>
+            Imports the Python module by the given name and returns its ScriptSCope.  If the 
+            module does not exist an exception is raised.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.ImportModule(Microsoft.Scripting.Hosting.ScriptEngine,System.String)">
+            <summary>
+            Imports the Python module by the given name and returns its ScriptSCope.  If the 
+            module does not exist an exception is raised.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.ImportModule(Microsoft.Scripting.Hosting.ScriptScope,System.String)">
+            <summary>
+            Imports the Python module by the given name and inserts it into the ScriptScope as that name. If the
+            module does not exist an exception is raised.
+            </summary>
+            <param name="scope"></param>
+            <param name="moduleName"></param>
+        </member>
+        <member name="M:IronPython.Hosting.Python.SetHostVariables(Microsoft.Scripting.Hosting.ScriptRuntime,System.String,System.String,System.String)">
+            <summary>
+            Sets sys.exec_prefix, sys.executable and sys.version and adds the prefix to sys.path
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.SetHostVariables(Microsoft.Scripting.Hosting.ScriptEngine,System.String,System.String,System.String)">
+            <summary>
+            Sets sys.exec_prefix, sys.executable and sys.version and adds the prefix to sys.path
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.SetTrace(Microsoft.Scripting.Hosting.ScriptEngine,IronPython.Runtime.Exceptions.TracebackDelegate)">
+            <summary>
+            Enables call tracing for the current thread in this ScriptEngine.  
+            
+            TracebackDelegate will be called back for each function entry, exit, exception, and line change.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.SetTrace(Microsoft.Scripting.Hosting.ScriptRuntime,IronPython.Runtime.Exceptions.TracebackDelegate)">
+            <summary>
+            Enables call tracing for the current thread for the Python engine in this ScriptRuntime.  
+            
+            TracebackDelegate will be called back for each function entry, exit, exception, and line change.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.CallTracing(Microsoft.Scripting.Hosting.ScriptRuntime,System.Object,System.Object[])">
+            <summary>
+            Provides nested level debugging support when SetTrace or SetProfile are used.
+            
+            This saves the current tracing information and then calls the provided object.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.CallTracing(Microsoft.Scripting.Hosting.ScriptEngine,System.Object,System.Object[])">
+            <summary>
+            Provides nested level debugging support when SetTrace or SetProfile are used.
+            
+            This saves the current tracing information and then calls the provided object.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.CreateRuntimeSetup(System.Collections.Generic.IDictionary{System.String,System.Object})">
+            <summary>
+            Creates a ScriptRuntimeSetup object which includes the Python script engine with the specified options.
+            
+            The ScriptRuntimeSetup object can then be additional configured and used to create a ScriptRuntime.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.CreateLanguageSetup(System.Collections.Generic.IDictionary{System.String,System.Object})">
+            <summary>
+            Creates a LanguageSetup object which includes the Python script engine with the specified options.
+            
+            The LanguageSetup object can be used with other LanguageSetup objects from other languages to
+            configure a ScriptRuntimeSetup object.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.CreateModule(Microsoft.Scripting.Hosting.ScriptEngine,System.String)">
+            <summary>
+            Creates a new PythonModule with the specified name and published it in sys.modules.  
+            
+            Returns the ScriptScope associated with the module.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.CreateModule(Microsoft.Scripting.Hosting.ScriptEngine,System.String,System.String)">
+            <summary>
+            Creates a new PythonModule with the specified name and filename published it 
+            in sys.modules.  
+            
+            Returns the ScriptScope associated with the module.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.CreateModule(Microsoft.Scripting.Hosting.ScriptEngine,System.String,System.String,System.String)">
+            <summary>
+            Creates a new PythonModule with the specified name, filename, and doc string and 
+            published it in sys.modules.  
+            
+            Returns the ScriptScope associated with the module.
+            </summary>
+        </member>
+        <member name="M:IronPython.Hosting.Python.GetModuleFilenames(Microsoft.Scripting.Hosting.ScriptEngine)">
+            <summary>
+            Gets the list of loaded Python module files names which are available in the provided ScriptEngine.
+            </summary>
+        </member>
+        <member name="F:IronPython.Hosting.ErrorCodes.IncompleteStatement">
+            <summary>
+            The error involved an incomplete statement due to an unexpected EOF.
+            </summary>
+        </member>
+        <member name="F:IronPython.Hosting.ErrorCodes.IncompleteToken">
+            <summary>
+            The error involved an incomplete token.
+            </summary>
+        </member>
+        <member name="F:IronPython.Hosting.ErrorCodes.ErrorMask">
+            <summary>
+            The mask for the actual error values 
+            </summary>
+        </member>
+        <member name="F:IronPython.Hosting.ErrorCodes.SyntaxError">
+            <summary>
+            The error was a general syntax error
+            </summary>
+        </member>
+        <member name="F:IronPython.Hosting.ErrorCodes.IndentationError">
+            <summary>
+            The error was an indentation error.
+            </summary>
+        </member>
+        <member name="F:IronPython.Hosting.ErrorCodes.TabError">
+            <summary>
+            The error was a tab error.
+            </summary>
+        </member>
+        <member name="F:IronPython.Hosting.ErrorCodes.NoCaret">
+            <summary>
+            syntax error shouldn't include a caret (no column offset should be included)
+            </summary>
+        </member>
+        <member name="T:IronPython.MaybeNotImplementedAttribute">
+            <summary>
+            Marks that the return value of a function might include NotImplemented.
+            
+            This is added to an operator method to ensure that all necessary methods are called
+            if one cannot guarantee that it can perform the comparison.
+            </summary>
+        </member>
+        <member name="T:IronPython.BytesConversionAttribute">
+            <summary>
+            For IList<byte/> arguments: Marks that the argument is typed to accept a bytes or
+            bytearray object.  This attribute disallows passing a Python list object and
+            auto-applying our generic conversion.  It also enables conversion of a string to
+            a IList of byte in IronPython 2.6.
+            
+            For string arguments: Marks that the argument is typed to accept a bytes object
+            as well. (2.6 only)
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.Arguments">
+            <summary>
+            Gets the collection of command line arguments.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.Optimize">
+            <summary>
+             Should we strip out all doc strings (the -O command line option).
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.StripDocStrings">
+            <summary>
+             Should we strip out all doc strings (the -OO command line option).
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.WarningFilters">
+            <summary>
+             List of -W (warning filter) options collected from the command line.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.WarnPython30">
+            <summary>
+            Enables warnings related to Python 3.0 features.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.Python30">
+            <summary>
+            Enables 3.0 features that are implemented in IronPython.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.Debug">
+            <summary>
+            Enables debugging support.  When enabled a .NET debugger can be attached
+            to the process to step through Python code.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.Inspect">
+            <summary>
+            Enables inspect mode.  After running the main module the REPL will be started
+            within that modules context.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.NoUserSite">
+            <summary>
+            Suppresses addition of the user site directory.  This is ignored by IronPython
+            except for updating sys.flags.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.NoSite">
+            <summary>
+            Disables import site on startup.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.IgnoreEnvironment">
+            <summary>
+            Ignore environment variables that configure the IronPython context.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.Verbose">
+            <summary>
+            Enables the verbose option which traces import statements.  This is ignored by IronPython
+            except for setting sys.flags.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.RecursionLimit">
+            <summary>
+            Sets the maximum recursion depth.  Setting to Int32.MaxValue will disable recursion
+            enforcement.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.Frames">
+            <summary>
+            Makes available sys._getframe.  Local variables will not be available in frames unless the
+            function calls locals(), dir(), vars(), etc...  For ensuring locals are always available use
+            the FullFrames option.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.FullFrames">
+            <summary>
+            Makes available sys._getframe.  All locals variables will live on the heap (for a considerable
+            performance cost) enabling introspection of all code.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.Tracing">
+            <summary>
+            Tracing is always available.  Without this option tracing is only enabled when sys.settrace
+            is called. This means code that was already running before sys.settrace will not be debuggable.
+            
+            With this option pdb.set_trace and pdb.post_mortem will always work properly.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.IndentationInconsistencySeverity">
+            <summary> 
+            Severity of a warning that indentation is formatted inconsistently.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.DivisionOptions">
+            <summary>
+            The division options (old, new, warn, warnall)
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.LightweightScopes">
+            <summary>
+            Forces all code to be compiled in a mode in which the code can be reliably collected by the CLR.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.EnableProfiler">
+            <summary>
+            Enable profiling code
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.NoDebug">
+            <summary>
+            Returns a regular expression of Python files which should not be emitted in debug mode.
+            </summary>
+        </member>
+        <member name="P:IronPython.PythonOptions.PythonVersion">
+            <summary>
+            Gets the CPython version which IronPython will emulate.  Currently limited
+            to either 2.6 or 3.0.
+            </summary>
+        </member>
+        <member name="T:IronPython.Resources">
+            <summary>
+              A strongly-typed resource class, for looking up localized strings, etc.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.ResourceManager">
+            <summary>
+              Returns the cached ResourceManager instance used by this class.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.Culture">
+            <summary>
+              Overrides the current thread's CurrentUICulture property for all
+              resource lookups using this strongly typed resource class.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.CantFindMember">
+            <summary>
+              Looks up a localized string similar to couldn&apos;t find member {0}.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.DefaultRequired">
+            <summary>
+              Looks up a localized string similar to default value must be specified here.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.DuplicateArgumentInFuncDef">
+            <summary>
+              Looks up a localized string similar to duplicate argument &apos;{0}&apos; in function definition.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.DuplicateKeywordArg">
+            <summary>
+              Looks up a localized string similar to duplicate keyword argument.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.EofInString">
+            <summary>
+              Looks up a localized string similar to &lt;eof&gt; while reading string.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.EofInTripleQuotedString">
+            <summary>
+              Looks up a localized string similar to EOF while scanning triple-quoted string.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.EolInSingleQuotedString">
+            <summary>
+              Looks up a localized string similar to EOL while scanning single-quoted string.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.ExpectedIndentation">
+            <summary>
+              Looks up a localized string similar to expected an indented block.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.ExpectedName">
+            <summary>
+              Looks up a localized string similar to expected name.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.ExpectingIdentifier">
+            <summary>
+              Looks up a localized string similar to Expecting identifier:.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.InconsistentWhitespace">
+            <summary>
+              Looks up a localized string similar to inconsistent use of tabs and spaces in indentation.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.IndentationMismatch">
+            <summary>
+              Looks up a localized string similar to unindent does not match any outer indentation level.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.InvalidArgumentValue">
+            <summary>
+              Looks up a localized string similar to Invalid argument value..
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.InvalidOperation_MakeGenericOnNonGeneric">
+            <summary>
+              Looks up a localized string similar to MakeGenericType on non-generic type.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.InvalidParameters">
+            <summary>
+              Looks up a localized string similar to Invalid parameter collection for the function..
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.InvalidSyntax">
+            <summary>
+              Looks up a localized string similar to invalid syntax.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.KeywordCreateUnavailable">
+            <summary>
+              Looks up a localized string similar to object ({0}) is not creatable w/ keyword arguments.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.KeywordOutOfSequence">
+            <summary>
+              Looks up a localized string similar to keywords must come before * args.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.MemberDoesNotExist">
+            <summary>
+              Looks up a localized string similar to type does not have {0} field.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.MisplacedFuture">
+            <summary>
+              Looks up a localized string similar to from __future__ imports must occur at the beginning of the file.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.MisplacedReturn">
+            <summary>
+              Looks up a localized string similar to &apos;return&apos; outside function.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.MisplacedYield">
+            <summary>
+              Looks up a localized string similar to &apos;yield&apos; outside function.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.NewLineInDoubleQuotedString">
+            <summary>
+              Looks up a localized string similar to NEWLINE in double-quoted string.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.NewLineInSingleQuotedString">
+            <summary>
+              Looks up a localized string similar to NEWLINE in single-quoted string.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.NoFutureStar">
+            <summary>
+              Looks up a localized string similar to future statement does not support import *.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.NonKeywordAfterKeywordArg">
+            <summary>
+              Looks up a localized string similar to non-keyword arg after keyword arg.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.NotAChance">
+            <summary>
+              Looks up a localized string similar to not a chance.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.NotImplemented">
+            <summary>
+              Looks up a localized string similar to The method or operation is not implemented..
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.OneKeywordArgOnly">
+            <summary>
+              Looks up a localized string similar to only one ** allowed.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.OneListArgOnly">
+            <summary>
+              Looks up a localized string similar to only one * allowed.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.PythonContextRequired">
+            <summary>
+              Looks up a localized string similar to Context must be PythonCompilerContext.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.Slot_CantDelete">
+            <summary>
+              Looks up a localized string similar to cannot delete slot.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.Slot_CantGet">
+            <summary>
+              Looks up a localized string similar to cannot get slot.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.Slot_CantSet">
+            <summary>
+              Looks up a localized string similar to cannot set slot.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.StaticAccessFromInstanceError">
+            <summary>
+              Looks up a localized string similar to static property &apos;{0}&apos; of &apos;{1}&apos; can only be read through a type, not an instance.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.StaticAssignmentFromInstanceError">
+            <summary>
+              Looks up a localized string similar to static property &apos;{0}&apos; of &apos;{1}&apos; can only be assigned to through a type, not an instance.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.TokenHasNoValue">
+            <summary>
+              Looks up a localized string similar to no value for this token.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.TooManyVersions">
+            <summary>
+              Looks up a localized string similar to too many versions.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.UnexpectedToken">
+            <summary>
+              Looks up a localized string similar to unexpected token &apos;{0}&apos;.
+            </summary>
+        </member>
+        <member name="P:IronPython.Resources.UnknownFutureFeature">
+            <summary>
+              Looks up a localized string similar to future feature is not defined:.
+            </summary>
+        </member>
+    </members>
+</doc>