def Execute(result):
   result["AggregateNode"].__doc__ = """
A representation of a call tree. Each node represents one or more
calls that occurred in the trace. Multiple calls to a child node are
aggregated into one node.

"""
   result["Collector"].__doc__ = """
This is a singleton class that records TraceEvent instances and
populates TraceCollection instances.

All public methods of TraceCollector are safe to call from any thread.

"""
   result["Collector"].BeginEvent.func_doc = """BeginEvent(key) -> TimeStamp


Record a begin event with *key* if ``Category`` is enabled.


A matching end event is expected some time in the future.

If the key is known at compile time ``BeginScope`` and ``Scope``
methods are preferred because they have lower overhead.

The TimeStamp of the TraceEvent or 0 if the collector is disabled.

BeginScope

Scope


Parameters
----------
key : Key


"""
   result["Collector"].BeginEventAtTime.func_doc = """BeginEventAtTime(key, ms) -> None


Record a begin event with *key* at a specified time if ``Category`` is
enabled.


This version of the method allows the passing of a specific number of
elapsed milliseconds, *ms*, to use for this event. This method is used
for testing and debugging code.


Parameters
----------
key : Key

ms : float


"""
   result["Collector"].EndEvent.func_doc = """EndEvent(key) -> TimeStamp


Record an end event with *key* if ``Category`` is enabled.


A matching begin event must have preceded this end event.

If the key is known at compile time EndScope and Scope methods are
preferred because they have lower overhead.

The TimeStamp of the TraceEvent or 0 if the collector is disabled.

EndScope

Scope


Parameters
----------
key : Key


"""
   result["Collector"].EndEventAtTime.func_doc = """EndEventAtTime(key, ms) -> None


Record an end event with *key* at a specified time if ``Category`` is
enabled.


This version of the method allows the passing of a specific number of
elapsed milliseconds, *ms*, to use for this event. This method is used
for testing and debugging code.


Parameters
----------
key : Key

ms : float


"""
   result["Collector"].Clear.func_doc = """Clear() -> None


Clear all pending events from the collector.


No TraceCollection will be made for these events.



"""
   result["Collector"].GetLabel.func_doc = """GetLabel() -> str


Return the label associated with this collector.



"""
   result["Collector"].__init__.func_doc = """__init__()



"""
   result["Reporter"].__doc__ = """
This class converts streams of TraceEvent objects into call trees
which can then be used as a data source to a GUI or written out to a
file.

"""
   result["Reporter"].Report.func_doc = """Report(s, iterationCount) -> None


Generates a report to the ostream *s*, dividing all times by
*iterationCount*.


Parameters
----------
s : ostream

iterationCount : int


"""
   result["Reporter"].ReportTimes.func_doc = """ReportTimes(s) -> None


Generates a report of the times to the ostream *s*.


Parameters
----------
s : ostream


"""
   result["Reporter"].ReportChromeTracing.func_doc = """ReportChromeTracing(s) -> None


Generates a timeline trace report suitable for viewing in Chrome's
trace viewer.


Parameters
----------
s : ostream


"""
   result["Reporter"].GetLabel.func_doc = """GetLabel() -> str


Return the label associated with this reporter.



"""
   result["Reporter"].UpdateTraceTrees.func_doc = """UpdateTraceTrees() -> None


This fully re-builds the event and aggregate trees from whatever the
current collection holds.


It is ok to call this multiple times in case the collection gets
appended on inbetween.

If we want to have multiple reporters per collector, this will need to
be changed so that all reporters reporting on a collector update their
respective trees.



"""
   result["Reporter"].ClearTree.func_doc = """ClearTree() -> None


Clears event tree and counters.



"""
   result["Reporter"].__init__.func_doc = """__init__(label, dataSource)


Parameters
----------
label : str

dataSource : DataSource


"""
   result["AggregateNode"].inclusiveTime = property(result["AggregateNode"].inclusiveTime.fget, result["AggregateNode"].inclusiveTime.fset, result["AggregateNode"].inclusiveTime.fdel, """type : TimeStamp


Returns the total time of this node ands its children.

""")
   result["AggregateNode"].exclusiveTime = property(result["AggregateNode"].exclusiveTime.fget, result["AggregateNode"].exclusiveTime.fset, result["AggregateNode"].exclusiveTime.fdel, """type : TimeStamp


Returns the time spent in this node but not its children.

""")
   result["AggregateNode"].count = property(result["AggregateNode"].count.fget, result["AggregateNode"].count.fset, result["AggregateNode"].count.fdel, """type : int


Returns the call count of this node.


``recursive`` determines if recursive calls are counted.

""")
   result["AggregateNode"].exclusiveCount = property(result["AggregateNode"].exclusiveCount.fget, result["AggregateNode"].exclusiveCount.fset, result["AggregateNode"].exclusiveCount.fdel, """type : int


Returns the exclusive count.

""")
   result["AggregateNode"].children = property(result["AggregateNode"].children.fget, result["AggregateNode"].children.fset, result["AggregateNode"].children.fdel, """type : list[TraceAggregateNodePtr]

""")
   result["AggregateNode"].key = property(result["AggregateNode"].key.fget, result["AggregateNode"].key.fset, result["AggregateNode"].key.fdel, """type : str


Returns the node's key.

""")
   result["AggregateNode"].id = property(result["AggregateNode"].id.fget, result["AggregateNode"].id.fset, result["AggregateNode"].id.fdel, """type : Id


Returns the node's id.

""")
   result["AggregateNode"].expanded = property(result["AggregateNode"].expanded.fget, result["AggregateNode"].expanded.fset, result["AggregateNode"].expanded.fdel, """type : bool


Returns whether this node is expanded in a gui.

----------------------------------------------------------------------

type : None


Sets whether or not this node is expanded in a gui.

""")
   result["Collector"].enabled = property(result["Collector"].enabled.fget, result["Collector"].enabled.fset, result["Collector"].enabled.fdel, """**classmethod** type : bool


Returns whether collection of events is enabled for DefaultCategory.

----------------------------------------------------------------------

type : None


Enables or disables collection of events for DefaultCategory.

""")
   result["Collector"].pythonTracingEnabled = property(result["Collector"].pythonTracingEnabled.fget, result["Collector"].pythonTracingEnabled.fset, result["Collector"].pythonTracingEnabled.fdel, """type : None


Set whether automatic tracing of all python scopes is enabled.

----------------------------------------------------------------------

type : bool


Returns whether automatic tracing of all python scopes is enabled.

""")
   result["Reporter"].groupByFunction = property(result["Reporter"].groupByFunction.fget, result["Reporter"].groupByFunction.fset, result["Reporter"].groupByFunction.fdel, """type : bool


Returns the current group-by-function state.

----------------------------------------------------------------------

type : None


This affects only stack trace event reporting.


If ``true`` then all events in a function are grouped together
otherwise events are split out by address.

""")
   result["Reporter"].foldRecursiveCalls = property(result["Reporter"].foldRecursiveCalls.fget, result["Reporter"].foldRecursiveCalls.fset, result["Reporter"].foldRecursiveCalls.fdel, """type : bool


Returns the current setting for recursion folding for stack trace
event reporting.

----------------------------------------------------------------------

type : None


When stack trace event reporting, this sets whether or not recursive
calls are folded in the output.


Recursion folding is useful when the stacks contain deep recursive
structures.

""")
   result["Reporter"].shouldAdjustForOverheadAndNoise = property(result["Reporter"].shouldAdjustForOverheadAndNoise.fget, result["Reporter"].shouldAdjustForOverheadAndNoise.fset, result["Reporter"].shouldAdjustForOverheadAndNoise.fdel, """type : None


Set whether or not the reporter should adjust scope times for overhead
and noise.

""")
   result["Reporter"].aggregateTreeRoot = property(result["Reporter"].aggregateTreeRoot.fget, result["Reporter"].aggregateTreeRoot.fset, result["Reporter"].aggregateTreeRoot.fdel, """type : AggregateNode


Returns the root node of the aggregated call tree.

""")
   result["Reporter"].globalReporter.__doc__ = """**classmethod** globalReporter() -> Reporter


Returns the global reporter.



"""